Recherche avancée

Sur d’autres sites (8001)

• Android recording video with overlay view [way 2]

  2 mars 2016, par t0m

  I am trying app in android which have functionality to capture video with overlay views. I tried two ways (1. and 2.).
  1. Via SurfaceView and JavaCV with FFmpeg.
  2. Via OpenCV and JavaCV with FFmpeg.
  3. For API21+ maybe with MediaProjection.

  (Question is divided to two questions, due to stackoverflow length limit.)

  ad 1. Via SurfaceView and JavaCV with FFmpeg :

  Here

  ad 2. Via OpenCV and JavaCV with FFmpeg :

  OpenCVCameraActivity.java :

  import android.app.Activity;
  
  import android.hardware.Camera;
  
  import android.media.AudioFormat;
  
  import android.media.AudioRecord;
  
  import android.media.MediaRecorder;
  
  import android.os.Bundle;
  
  import android.os.Environment;
  
  import android.util.Log;
  
  import android.view.Menu;
  
  import android.view.MenuItem;
  
  import android.view.MotionEvent;
  
  import android.view.SubMenu;
  
  import android.view.SurfaceView;
  
  import android.view.View;
  
  import android.view.WindowManager;
  
  import android.widget.Toast;
  
  
  
  import org.bytedeco.javacv.FFmpegFrameRecorder;
  
  import org.bytedeco.javacv.Frame;
  
  import org.opencv.android.BaseLoaderCallback;
  
  import org.opencv.android.CameraBridgeViewBase;
  
  import org.opencv.android.LoaderCallbackInterface;
  
  import org.opencv.android.OpenCVLoader;
  
  import org.opencv.core.Mat;
  
  
  
  import java.io.File;
  
  import java.nio.ByteBuffer;
  
  import java.nio.ShortBuffer;
  
  import java.text.SimpleDateFormat;
  
  import java.util.Date;
  
  import java.util.List;
  
  import java.util.ListIterator;
  
  
  
  @SuppressWarnings("ALL")
  
  public class OpenCVCameraActivity extends Activity implements
  
          CameraBridgeViewBase.CvCameraViewListener2,
  
          View.OnTouchListener {
  
  
  
      //name of activity, for DEBUGGING
  
      private static final String TAG = OpenCVCameraActivity.class.getSimpleName();
  
  
  
      private OpenCVCameraPreview mOpenCvCameraView;
  
      private List mResolutionList;
  
      private MenuItem[] mEffectMenuItems;
  
      private SubMenu mColorEffectsMenu;
  
      private MenuItem[] mResolutionMenuItems;
  
      private SubMenu mResolutionMenu;
  
  
  
      private static long frameCounter = 0;
  
  
  
      long startTime = 0;
  
      private Mat edgesMat;
  
      boolean recording = false;
  
      private int sampleAudioRateInHz = 44100;
  
      private int imageWidth = 1280;
  
      private int imageHeight = 720;
  
      private int frameRate = 30;
  
      private Frame yuvImage = null;
  
      private File ffmpeg_link;
  
      private FFmpegFrameRecorder recorder;
  
  
  
      /*audio data getting thread */
  
      private AudioRecord audioRecord;
  
      private AudioRecordRunnable audioRecordRunnable;
  
      private Thread audioThread;
  
      volatile boolean runAudioThread = true;
  
      ShortBuffer[] samples;
  
  
  
  
  
      private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
  
          @Override
  
          public void onManagerConnected(int status) {
  
              switch (status) {
  
                  case LoaderCallbackInterface.SUCCESS:
  
                      Log.i(TAG, "OpenCV loaded successfully");
  
                      mOpenCvCameraView.enableView();
  
                      mOpenCvCameraView.setOnTouchListener(OpenCVCameraActivity.this);
  
                  break;
  
                  default:
  
                      super.onManagerConnected(status);
  
                  break;
  
              }
  
          }
  
      };
  
  
  
      @Override
  
      protected void onCreate(Bundle savedInstanceState) {
  
          super.onCreate(savedInstanceState);
  
          if(Static.DEBUG) Log.i(TAG, "onCreate()");
  
  
  
          getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
  
  
  
          Thread.setDefaultUncaughtExceptionHandler(uncaughtExceptionHandler);
  
  
  
          try {
  
              setContentView(R.layout.activity_opencv);
  
  
  
              mOpenCvCameraView = (OpenCVCameraPreview) findViewById(R.id.openCVCameraPreview);
  
              mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
  
              mOpenCvCameraView.setCvCameraViewListener(this);
  
  
  
              mOpenCvCameraView.enableFpsMeter();
  
  
  
              ffmpeg_link = new File(Environment.getExternalStorageDirectory(), "stream.mp4");
  
          } catch (Exception e){
  
              e.printStackTrace();
  
          }
  
      }
  
  
  
      private Thread.UncaughtExceptionHandler uncaughtExceptionHandler =
  
              new Thread.UncaughtExceptionHandler() {
  
                  public void uncaughtException(Thread thread, Throwable ex) {
  
                      if(Static.DEBUG) Log.e(TAG, "Uncaught exception", ex);
  
                  }
  
              };
  
  
  
      @Override
  
      protected void onRestart() {
  
          if (Static.DEBUG) Log.i(TAG, "onRestart()");
  
          super.onRestart();
  
      }
  
  
  
      @Override
  
      protected void onStart() {
  
          if (Static.DEBUG) Log.i(TAG, "onStart()");
  
          super.onStart();
  
      }
  
  
  
      @Override
  
      protected void onResume() {
  
          if (Static.DEBUG) Log.i(TAG, "onResume()");
  
          super.onResume();
  
  
  
          if (!OpenCVLoader.initDebug()) {
  
              Log.i(TAG, "Internal OpenCV library not found. Using OpenCV Manager for initialization");
  
              OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_1_0, this, mLoaderCallback);
  
          } else {
  
              Log.i(TAG, "OpenCV library found inside package. Using it!");
  
              mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
  
          }
  
  
  
      }
  
  
  
      @Override
  
      public boolean onCreateOptionsMenu(Menu menu) {
  
          if (Static.DEBUG) Log.i(TAG, "onCreateOptionsMenu()");
  
          super.onCreateOptionsMenu(menu);
  
  
  
          List<string> effects = mOpenCvCameraView.getEffectList();
  
  
  
          if (effects == null) {
  
              Log.e(TAG, "Color effects are not supported by device!");
  
              return true;
  
          }
  
  
  
          mColorEffectsMenu = menu.addSubMenu("Color Effect");
  
          mEffectMenuItems = new MenuItem[effects.size()];
  
  
  
          int idx = 0;
  
          ListIterator<string> effectItr = effects.listIterator();
  
          while(effectItr.hasNext()) {
  
              String element = effectItr.next();
  
              mEffectMenuItems[idx] = mColorEffectsMenu.add(1, idx, Menu.NONE, element);
  
              idx++;
  
          }
  
  
  
          mResolutionMenu = menu.addSubMenu("Resolution");
  
          mResolutionList = mOpenCvCameraView.getResolutionList();
  
          mResolutionMenuItems = new MenuItem[mResolutionList.size()];
  
  
  
          ListIterator resolutionItr = mResolutionList.listIterator();
  
          idx = 0;
  
          while(resolutionItr.hasNext()) {
  
              Camera.Size element = resolutionItr.next();
  
              mResolutionMenuItems[idx] = mResolutionMenu.add(2, idx, Menu.NONE,
  
                      Integer.valueOf(element.width).toString() + "x" + Integer.valueOf(element.height).toString());
  
              idx++;
  
          }
  
  
  
          return true;
  
      }
  
  
  
      @Override
  
      protected void onPause() {
  
          if (Static.DEBUG) Log.i(TAG, "onPause()");
  
          super.onPause();
  
  
  
          if (mOpenCvCameraView != null)
  
              mOpenCvCameraView.disableView();
  
  
  
      }
  
  
  
      @Override
  
      protected void onStop() {
  
          if (Static.DEBUG) Log.i(TAG, "onStop()");
  
          super.onStop();
  
      }
  
  
  
      @Override
  
      protected void onDestroy() {
  
          if (Static.DEBUG) Log.i(TAG, "onDestroy()");
  
          super.onDestroy();
  
  
  
          if (mOpenCvCameraView != null)
  
              mOpenCvCameraView.disableView();
  
      }
  
  
  
      public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame inputFrame) {
  
  
  
          ++frameCounter;
  
          //Log.i(TAG, "Frame number: "+frameCounter);
  
  
  
          final Mat rgba = inputFrame.rgba();
  
          //Core.flip(rgba, rgba, 1);
  
  
  
          /*if(Static.DEBUG) Log.i(TAG,"rgba.total(): "+rgba.total());
  
          if(Static.DEBUG) Log.i(TAG,"rgba.channels(): " +rgba.channels());*/
  
          byte[] data = new byte[(int) (rgba.total() * rgba.channels())];
  
          rgba.get(0, 0, data);
  
          //if(Static.DEBUG) Log.i(TAG,"return_buff: "+return_buff.length);
  
  
  
          if (audioRecord == null || audioRecord.getRecordingState() != AudioRecord.RECORDSTATE_RECORDING) {
  
              startTime = System.currentTimeMillis();
  
              return rgba;
  
          }
  
  
  
          // get video data
  
          if (yuvImage != null &amp;&amp; recording) {
  
              ByteBuffer b = (ByteBuffer)yuvImage.image[0].position(0);
  
              b.put(data);
  
  
  
              try {
  
                  long t = 1000 * (System.currentTimeMillis() - startTime);
  
                  if(Static.DEBUG) Log.i(TAG,"Writing Frame on timestamp: "+t);
  
                  if (t > recorder.getTimestamp()) {
  
                      recorder.setTimestamp(t);
  
                  }
  
                  recorder.record(yuvImage);
  
              } catch (FFmpegFrameRecorder.Exception e) {
  
                  if(Static.DEBUG) Log.i(TAG,e.getMessage());
  
                  e.printStackTrace();
  
              }
  
          }
  
  
  
          return rgba;
  
      }
  
  
  
      @Override
  
      public void onCameraViewStarted(int width, int height) {
  
          edgesMat = new Mat();
  
      }
  
  
  
      @Override
  
      public void onCameraViewStopped() {
  
          if (edgesMat != null)
  
              edgesMat.release();
  
  
  
          edgesMat = null;
  
      }
  
  
  
      public boolean onOptionsItemSelected(MenuItem item) {
  
          Log.i(TAG, "called onOptionsItemSelected; selected item: " + item);
  
          if (item.getGroupId() == 1)
  
          {
  
              mOpenCvCameraView.setEffect((String) item.getTitle());
  
              Toast.makeText(this, mOpenCvCameraView.getEffect(), Toast.LENGTH_SHORT).show();
  
          } else if (item.getGroupId() == 2) {
  
              int id = item.getItemId();
  
              Camera.Size resolution = mResolutionList.get(id);
  
              mOpenCvCameraView.setResolution(resolution);
  
              resolution = mOpenCvCameraView.getResolution();
  
              String caption = Integer.valueOf(resolution.width).toString() + "x" + Integer.valueOf(resolution.height).toString();
  
              Toast.makeText(this, caption, Toast.LENGTH_SHORT).show();
  
          }
  
  
  
          return true;
  
      }
  
  
  
      @Override
  
      public boolean onTouch(View v, MotionEvent event) {
  
          Log.i(TAG,"onTouch event");
  
          SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd_HH-mm-ss");
  
          String currentDateandTime = sdf.format(new Date());
  
          String fileName = Environment.getExternalStorageDirectory().getPath() +
  
                  "/sample_picture_" + currentDateandTime + ".jpg";
  
          mOpenCvCameraView.takePicture(fileName);
  
          Toast.makeText(this, fileName + " saved", Toast.LENGTH_SHORT).show();
  
          return false;
  
      }
  
  
  
      /**
  
       * Click to ImageButton to start recording.
  
       */
  
      public void onClickBtnStartRecord2(View v) {
  
          if (Static.DEBUG) Log.i(TAG, "onClickBtnStartRecord()");
  
  
  
          if(!recording)
  
              startRecording();
  
          else
  
              stopRecording();
  
      }
  
  
  
      private void startRecording() {
  
          if (Static.DEBUG) Log.i(TAG, "startRecording()");
  
          initRecorder();
  
  
  
          try {
  
              recorder.start();
  
              startTime = System.currentTimeMillis();
  
              recording = true;
  
              audioThread.start();
  
              if (Static.DEBUG) Log.i(TAG, "startRecording() success");
  
          } catch(FFmpegFrameRecorder.Exception e) {
  
              e.printStackTrace();
  
          }
  
      }
  
  
  
      private void stopRecording() {
  
          if (Static.DEBUG) Log.i(TAG, "stopRecording()");
  
  
  
          runAudioThread = false;
  
          try {
  
              audioThread.join();
  
          } catch(InterruptedException e) {
  
              e.printStackTrace();
  
          }
  
          audioRecordRunnable = null;
  
          audioThread = null;
  
          if (Static.DEBUG) Log.i(TAG, "stopRecording() 2");
  
          if(recorder != null &amp;&amp; recording) {
  
  
  
              recording = false;
  
              try {
  
                  recorder.stop();
  
                  recorder.release();
  
                  Log.i(TAG, "Finishing recording, calling stop and release on recorder");
  
              } catch(FFmpegFrameRecorder.Exception e) {
  
                  e.printStackTrace();
  
              }
  
              recorder = null;
  
          }
  
      }
  
  
  
  
  
      //---------------------------------------
  
      // initialize ffmpeg_recorder
  
      //---------------------------------------
  
      private void initRecorder() {
  
  
  
          Log.i(TAG, "init recorder");
  
          try {
  
  
  
              if (yuvImage == null) {
  
                  yuvImage = new Frame(imageWidth, imageHeight, Frame.DEPTH_UBYTE, 4);
  
                  Log.i(TAG, "create yuvImage");
  
              }
  
  
  
              Log.i(TAG, "ffmpeg_url: " + ffmpeg_link.getAbsolutePath());
  
              //Log.i(TAG, "ffmpeg_url: " + ffmpeg_link.exists());
  
              recorder = new FFmpegFrameRecorder(ffmpeg_link, imageWidth, imageHeight, 1);
  
              recorder.setFormat("mp4");
  
              recorder.setSampleRate(sampleAudioRateInHz);
  
              // Set in the surface changed method
  
              recorder.setFrameRate(frameRate);
  
  
  
              audioRecordRunnable = new AudioRecordRunnable();
  
              audioThread = new Thread(audioRecordRunnable);
  
              runAudioThread = true;
  
              Log.i(TAG, "recorder initialize success");
  
          } catch (Exception e){
  
              e.printStackTrace();
  
          }
  
      }
  
  
  
      //---------------------------------------------
  
      // audio thread, gets and encodes audio data
  
      //---------------------------------------------
  
      class AudioRecordRunnable implements Runnable {
  
  
  
          @Override
  
          public void run() {
  
              android.os.Process.setThreadPriority(android.os.Process.THREAD_PRIORITY_URGENT_AUDIO);
  
  
  
              // Audio
  
              int bufferSize;
  
              ShortBuffer audioData;
  
              int bufferReadResult;
  
  
  
              bufferSize = AudioRecord.getMinBufferSize(sampleAudioRateInHz,
  
                      AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT);
  
              audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, sampleAudioRateInHz,
  
                      AudioFormat.CHANNEL_IN_MONO, AudioFormat.ENCODING_PCM_16BIT, bufferSize);
  
  
  
              audioData = ShortBuffer.allocate(bufferSize);
  
  
  
              Log.d(TAG, "audioRecord.startRecording()");
  
              audioRecord.startRecording();
  
  
  
              // ffmpeg_audio encoding loop
  
              while(runAudioThread) {
  
                  //Log.v(TAG,"recording? " + recording);
  
                  bufferReadResult = audioRecord.read(audioData.array(), 0, audioData.capacity());
  
                  audioData.limit(bufferReadResult);
  
                  if(bufferReadResult > 0) {
  
                      Log.v(TAG, "bufferReadResult: " + bufferReadResult);
  
                      // If "recording" isn't true when start this thread, it never get's set according to this if statement...!!!
  
                      // Why?  Good question...
  
                      if(recording) {
  
                              try {
  
                                  recorder.recordSamples(audioData);
  
                                  //Log.v(TAG,"recording " + 1024*i + " to " + 1024*i+1024);
  
                              } catch(FFmpegFrameRecorder.Exception e) {
  
                                  Log.v(TAG, e.getMessage());
  
                                  e.printStackTrace();
  
                              }
  
                      }
  
                  }
  
              }
  
              Log.v(TAG, "AudioThread Finished, release audioRecord");
  
  
  
              // encoding finish, release recorder
  
              if(audioRecord != null) {
  
                  audioRecord.stop();
  
                  audioRecord.release();
  
                  audioRecord = null;
  
                  Log.v(TAG, "audioRecord released");
  
              }
  
          }
  
      }
  
  }
  
  </string></string>

  OpenCVCameraPreview.java :

  import android.content.Context;
  
  import android.hardware.Camera;
  
  import android.util.AttributeSet;
  
  import android.util.Log;
  
  
  
  import org.opencv.android.JavaCameraView;
  
  
  
  import java.io.FileOutputStream;
  
  import java.util.List;
  
  
  
  public class OpenCVCameraPreview extends JavaCameraView implements Camera.PictureCallback {
  
  
  
      private static final String TAG =  OpenCVCameraPreview.class.getSimpleName();
  
      private String mPictureFileName;
  
  
  
      public OpenCVCameraPreview(Context context, AttributeSet attrs) {
  
          super(context, attrs);
  
      }
  
  
  
      public List<string> getEffectList() {
  
          return mCamera.getParameters().getSupportedColorEffects();
  
      }
  
  
  
      public boolean isEffectSupported() {
  
          return (mCamera.getParameters().getColorEffect() != null);
  
      }
  
  
  
      public String getEffect() {
  
          return mCamera.getParameters().getColorEffect();
  
      }
  
  
  
      public void setEffect(String effect) {
  
          Camera.Parameters params = mCamera.getParameters();
  
          params.setColorEffect(effect);
  
          mCamera.setParameters(params);
  
      }
  
  
  
      public List getResolutionList() {
  
          return mCamera.getParameters().getSupportedPreviewSizes();
  
      }
  
  
  
      public void setResolution(Camera.Size resolution) {
  
          disconnectCamera();
  
          mMaxHeight = resolution.height;
  
          mMaxWidth = resolution.width;
  
          connectCamera(getWidth(), getHeight());
  
      }
  
  
  
      public Camera.Size getResolution() {
  
          return mCamera.getParameters().getPreviewSize();
  
      }
  
  
  
      public void takePicture(final String fileName) {
  
          Log.i(TAG, "Taking picture");
  
          this.mPictureFileName = fileName;
  
          // Postview and jpeg are sent in the same buffers if the queue is not empty when performing a capture.
  
          // Clear up buffers to avoid mCamera.takePicture to be stuck because of a memory issue
  
          mCamera.setPreviewCallback(null);
  
  
  
          // PictureCallback is implemented by the current class
  
          mCamera.takePicture(null, null, this);
  
      }
  
  
  
      @Override
  
      public void onPictureTaken(byte[] data, Camera camera) {
  
          Log.i(TAG, "Saving a bitmap to file");
  
          // The camera preview was automatically stopped. Start it again.
  
          mCamera.startPreview();
  
          mCamera.setPreviewCallback(this);
  
  
  
          // Write the image in a file (in jpeg format)
  
          try {
  
              FileOutputStream fos = new FileOutputStream(mPictureFileName);
  
  
  
              fos.write(data);
  
              fos.close();
  
  
  
          } catch (java.io.IOException e) {
  
              Log.e("PictureDemo", "Exception in photoCallback", e);
  
          }
  
  
  
      }
  
  }
  
  </string>

  activity_opencv.xml :

  <?xml version="1.0" encoding="utf-8"?>
  
  <relativelayout>
  
  
  
      
  
  
  
      &lt;ImageButton<br />
  
          android:id=&quot;@+id/btnStartRecord2&quot;<br />
  
          android:layout_width=&quot;70dp&quot;<br />
  
          android:layout_height=&quot;70dp&quot;<br />
  
          android:scaleType=&quot;fitXY&quot;<br />
  
          android:src=&quot;@drawable/record_icon&quot;<br />
  
          android:background=&quot;@null&quot;<br />
  
          android:text=&quot;@string/btnStartRecord&quot;<br />
  
          android:onClick=&quot;onClickBtnStartRecord2&quot;<br />
  
          android:layout_centerVertical=&quot;true&quot;<br />
  
          android:layout_alignParentRight=&quot;true&quot;<br />
  
          android:layout_alignParentEnd=&quot;true&quot;/&gt;
  
  
  
  
  
  </relativelayout>

  Overlay views working, but recorded video is without overlay views, and recording with onCameraFrame method is very slow.

• Kivy Crashes when Loading Multiple Audio Files

  26 mars 2022, par Omid Ketabollahi

  I have a music folder and in it I have a script that loads all the files using SoundLoader and assigns them to a variable. I have 9 audio files that I load in the script but it seems like that kivy cannot handle loading many audio files ? When I run my main script I get this error and the program crashes :

  


  Assertion 'pa_atomic_load(&(c)->_ref) >= 1' failed at pulse/context.c:1056, function pa_context_disconnect(). Aborting.


  


  I don't think that this is an issue with the audio files ( I may be wrong ) because I tried loading other files instead of the original ones that I used and I still got this error.

  


  In case you are wondering, this is the code :

  


  import os.path
from typing import Final
from constants import MUSIC_DIRECTORY
from kivy.core.audio import SoundLoader

__all__ = (
    "A_DARK_TIME",
    "BLOOD_PUMPING",
    "BROKEN_VILLAGE",
    "DRUM_COMMERCIAL_B",
    "SUPER_SUSPENSE",
    "THE_HERO_WE_NEED",
    "TROUBLE_IS_BREWING",
    "VIKING_FEAST",
    "WARRIOR_GODS",
)


A_DARK_TIME: Final = SoundLoader.load(
    os.path.join(MUSIC_DIRECTORY, "A-Dark-Time-David-Fesliyan.mp3")
)
BLOOD_PUMPING: Final = SoundLoader.load(
    os.path.join(MUSIC_DIRECTORY, "Blood-Pumping-David-Fesliyan.mp3")
)
BROKEN_VILLAGE: Final = SoundLoader.load(
    os.path.join(MUSIC_DIRECTORY, "Broken-Village-David_Fesliyan.mp3")
)
DRUM_COMMERCIAL_B: Final = SoundLoader.load(
    os.path.join(MUSIC_DIRECTORY, "Drum-Commercial-B-David-Fesliyan.mp3")
)
SUPER_SUSPENSE: Final = SoundLoader.load(
    os.path.join(MUSIC_DIRECTORY, "Super-Suspense-David-Fesliyan.mp3")
)
THE_HERO_WE_NEED: Final = SoundLoader.load(
    os.path.join(MUSIC_DIRECTORY, "The-Hero-We-Need-Steve-Oxen.mp3")
)
TROUBLE_IS_BREWING: Final = SoundLoader.load(
    os.path.join(MUSIC_DIRECTORY, "Trouble-Is-Brewing-David-Fesliyan.mp3")
)
VIKING_FEAST: Final = SoundLoader.load(
    os.path.join(MUSIC_DIRECTORY, "Viking-Feast-David-Fesliyan.mp3")
)
WARRIOR_GODS: Final = SoundLoader.load(
    os.path.join(MUSIC_DIRECTORY, "Warrior-Gods-Steve-Oxen.mp3")
)


  


• Determine which decoders/demuxers/parsers ffmpeg needs to successfully consume file

  10 octobre 2024, par rschristian

  I'm trying to custom compile a build of ffmpeg.wasm as the prebuilt, "support everything" is a tad hefty at 35mb. This base build (as well as standard ffmpeg, running on my desktop) works perfectly fine for the provided file, however, so I do have something I can work against.

  


  My issue is that I'm a bit stuck on figuring out what precisely I need to support the provided file, the correct combination of decoders, demuxers, parsers, etc., and the encoders, muxers I'll need to use to convert it to my desired output.

  


  I'm sure I can brute force this with time, but is there a way of having ffmpeg report precisely which combination it's using when running against a file ? I've tried -report but it doesn't seem to contain this information, really it contains no more useful codex information than the standard output log as far as I can tell.

  


  For example, I can see the current file I'm testing with (foo.m4s) is h264 video and aac audio, so I tried the following flags based on what I've been able to find online and by looking through the list of muxers :

  


  --enable-decoder=aac,h264
--enable-demuxer=aac,h264
--enable-parser=aac,h264


  


  However, this results in the following error :

  


  foo.m4s: Invalid data found when processing input


  


  So it seems like it's not quite the correct list.

  


  Is there any good way to debug this ? Some way of having ffmpeg itself report exactly what I'll need set to handle this conversion using my own compilation ? As the goal is a minimum build, adding the kitchen sink and slowly reducing over time will obviously be super time consuming, so I'd like to avoid it if at all possible.

  


  ---

  


  Edit : Trial and error got me down to this, though I don't quite understand it (and the question still stands as I could reasonably need to handle other files in the future) :

  


  --enable-demuxer=aac,mov
--enable-parser=aac


  


  mov for some reason ended up being the fix ? The first line of ffmpeg's output was Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'foo.m4s', and so I simply grabbed those one-by-one and sure enough mov worked, despite the video having h264. Would love if someone could explain this too.