Recherche avancée

Sur d’autres sites (9888)

• FFmpeg memory leak

  10 septembre 2015, par Spamdark

  I have developed just a simple library modifing a library that I found on the internet.

  What scares me, is that, when I play an avi, it plays and free the memory when the video ends, but when I play the video, it’s like a memory leak ! It grows to 138mb although the video has ended and the FreeAll method (A function that deletes the context, etc...) has been called.

  Here is the code of the method that is causing the memory leak :

  int VideoGL::NextVideoFrame(){
  
  int frameDone = 0;
  
  int result = 0;
  
  double pts = 0;
  
  
  
  if(!this->ended){
  
  
  
  if (!_started) return 0;
  
  AVPacket* packet;
  
  
  
  // Get the number of milliseconds passed and see if we should display a new frame
  
  int64_t msPassed = (1000 * (clock() - _baseTime)) / CLOCKS_PER_SEC;
  
  if (msPassed >= _currentPts)
  
  {
  
      // If this is not the current frame, copy it to the buffer
  
      if (_currentFramePts != _currentPts){
  
          _currentFramePts = _currentPts;
  
          memcpy(buffer_a,buffer, 3 * _codec_context_video->width * _codec_context_video->height);
  
          result = 1;
  
      }
  
  
  
      // Try to load a new frame from the video packet queue
  
      bool goodop=false;
  
      AVFrame *_n_frame = avcodec_alloc_frame();
  
      while (!frameDone && (packet = this->DEQUEUE(VIDEO)) != NULL)
  
      {
  
          if (packet == (AVPacket*)-1) return -1;
  
  
  
          goodop=true;
  
  
  
          _s_pts = packet->pts;
  
          avcodec_decode_video2(_codec_context_video, _n_frame, &frameDone, packet);
  
          av_free_packet(packet);
  
  
  
          if (packet->dts == AV_NOPTS_VALUE)
  
          {
  
              if (_n_frame->opaque && *(uint64_t*)_n_frame->opaque != AV_NOPTS_VALUE) pts = (double) *(uint64_t*)_n_frame->opaque;
  
              else pts = 0;
  
          }
  
          else pts = (double) packet->dts;
  
  
  
          pts *= av_q2d(_codec_context_video->time_base);
  
  
  
      }
  
  
  
      if (frameDone)
  
      {
  
          // if a frame was loaded scale it to the current texture frame buffer, but also set the pts so that it won't be copied to the texture until it's time
  
          sws_scale(sws_ctx,_n_frame->data, _n_frame->linesize, 0, _codec_context_video->height, _rgb_frame->data, _rgb_frame->linesize);
  
  
  
  
  
          double nts = 1.0/av_q2d(_codec_context_video->time_base);
  
          _currentPts = (uint64_t) (pts*nts);
  
  
  
      }
  
  
  
      avcodec_free_frame(&_n_frame);
  
      av_free(_n_frame);
  
  
  
      if(!goodop){
  
          ended=true;
  
      }
  
  }
  
  }
  
  
  
  return result;
  
  }

  I’ll be waiting for answers, thanks.

• Ffmpeg : how to keep orientation when trimming video file ?

  7 mars 2013, par Alex

  I have a video file which I capture from my Android program and save as an mp4 video.

  In this my Android program I use

  setOrientationHint(90)

  call to indicate to a videoplayer that my camera has been rotated 90 degrees.

  I'm not really sure what setOrientationHint(90) does but with it I can see the file properly oriented when it plays in the video player. If not, then a video player orients my file incorrectly.

  Now I trim this file using FFMPEG command (here in.mp4, out.mp4, 1000 and 2000 are just for example)

  ffmpeg -i in.mp4 -ss 1000 -t 2000 -vcodec copy -acodec

  However, the resulting file is again wrongly oriented in the player.

  I wonder what should I do to keep the orientation hint in the trimmed video file ?

• AVIO Open error -RTSP Protocol

  22 février 2016, par Muthukumar S

  Iam new to java CV. I am using java CV 0.8 I used Record Activity.java from samples folder. i did few modification in record activity. I tried to record video in format flv and mp4 . but i got exception like this
  org.bytedeco.javacv.FrameRecorder$Exception : avio_open error() error -1330794744 : Could not open ’rtsp ://10.0.0.136:1935/live/myStream’

  package com.example.javacv10;
  
  
  
  import java.io.IOException;
  
  import java.nio.ShortBuffer;
  
  
  
  import org.bytedeco.javacpp.opencv_core.IplImage;
  
  import org.bytedeco.javacv.FFmpegFrameRecorder;
  
  
  
  import android.app.Activity;
  
  import android.content.Context;
  
  import android.content.pm.ActivityInfo;
  
  import android.hardware.Camera;
  
  import android.hardware.Camera.PreviewCallback;
  
  import android.media.AudioFormat;
  
  import android.media.AudioRecord;
  
  import android.media.MediaRecorder;
  
  import android.os.Bundle;
  
  import android.os.PowerManager;
  
  import android.util.Log;
  
  import android.view.Display;
  
  import android.view.KeyEvent;
  
  import android.view.LayoutInflater;
  
  import android.view.SurfaceHolder;
  
  import android.view.SurfaceView;
  
  import android.view.View;
  
  import android.view.View.OnClickListener;
  
  import android.view.WindowManager;
  
  import android.widget.Button;
  
  import android.widget.LinearLayout;
  
  import android.widget.RelativeLayout;
  
  
  
  public class HomeActivity extends Activity implements OnClickListener {
  
  
  
  
  
      private final static String CLASS_LABEL = "RecordActivity";
  
      private final static String LOG_TAG = CLASS_LABEL;
  
  
  
      private PowerManager.WakeLock mWakeLock;
  
  
  
      private String ffmpeg_link = "rtsp://10.0.0.136:1935/live/myStream";
  
  
  
      long startTime = 0;
  
      boolean recording = false;
  
  
  
      private volatile FFmpegFrameRecorder recorder;
  
  
  
      private boolean isPreviewOn = false;
  
  
  
      private int sampleAudioRateInHz = 44100;
  
      private int imageWidth = 320;
  
      private int imageHeight = 240;
  
      private int frameRate = 30;
  
  
  
      /* audio data getting thread */
  
      private AudioRecord audioRecord;
  
      private AudioRecordRunnable audioRecordRunnable;
  
      private Thread audioThread;
  
      volatile boolean runAudioThread = true;
  
  
  
      /* video data getting thread */
  
      private Camera cameraDevice;
  
      private CameraView cameraView;
  
  
  
      private IplImage yuvIplimage = null;
  
  
  
      /* layout setting */
  
      private final int bg_screen_bx = 232;
  
      private final int bg_screen_by = 128;
  
      private final int bg_screen_width = 700;
  
      private final int bg_screen_height = 500;
  
      private final int bg_width = 1123;
  
      private final int bg_height = 715;
  
      private final int live_width = 640;
  
      private final int live_height = 480;
  
      private int screenWidth, screenHeight;
  
      private Button btnRecorderControl;
  
  
  
  
  
  
  
  
  
      @Override
  
      protected void onCreate(Bundle savedInstanceState) {
  
          super.onCreate(savedInstanceState);
  
          setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
  
  
  
          setContentView(R.layout.activity_home);
  
  
  
          PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE); 
  
          mWakeLock = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, CLASS_LABEL); 
  
          mWakeLock.acquire(); 
  
  
  
          initLayout();
  
          initRecorder();
  
  
  
  
  
  
  
      }
  
  
  
  
  
  
  
  
  
      @Override
  
      protected void onResume() {
  
          super.onResume();
  
  
  
          if (mWakeLock == null) {
  
             PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
  
             mWakeLock = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, CLASS_LABEL);
  
             mWakeLock.acquire();
  
          }
  
      }
  
  
  
      @Override
  
      protected void onPause() {
  
          super.onPause();
  
  
  
          if (mWakeLock != null) {
  
              mWakeLock.release();
  
              mWakeLock = null;
  
          }
  
      }
  
  
  
      @Override
  
      protected void onDestroy() {
  
          super.onDestroy();
  
  
  
          recording = false;
  
  
  
          if (cameraView != null) {
  
              cameraView.stopPreview();
  
          }
  
  
  
          if(cameraDevice != null) {
  
             cameraDevice.stopPreview();
  
             cameraDevice.release();
  
             cameraDevice = null;
  
          }
  
  
  
          if (mWakeLock != null) {
  
              mWakeLock.release();
  
              mWakeLock = null;
  
          }
  
      }
  
  
  
  
  
      private void initLayout() {
  
  
  
          /* get size of screen */
  
          Display display = ((WindowManager) getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay();
  
          screenWidth = display.getWidth();
  
          screenHeight = display.getHeight();
  
          RelativeLayout.LayoutParams layoutParam = null; 
  
          LayoutInflater myInflate = null; 
  
          myInflate = (LayoutInflater) getSystemService(Context.LAYOUT_INFLATER_SERVICE);
  
          RelativeLayout topLayout = new RelativeLayout(this);
  
          setContentView(topLayout);
  
          LinearLayout preViewLayout = (LinearLayout) myInflate.inflate(R.layout.activity_home, null);
  
          layoutParam = new RelativeLayout.LayoutParams(screenWidth, screenHeight);
  
          topLayout.addView(preViewLayout, layoutParam);
  
  
  
          /* add control button: start and stop */
  
          btnRecorderControl = (Button) findViewById(R.id.recorder_control);
  
          btnRecorderControl.setText("Start");
  
          btnRecorderControl.setOnClickListener(this);
  
  
  
          /* add camera view */
  
          int display_width_d = (int) (1.0 * bg_screen_width * screenWidth / bg_width);
  
          int display_height_d = (int) (1.0 * bg_screen_height * screenHeight / bg_height);
  
          int prev_rw, prev_rh;
  
          if (1.0 * display_width_d / display_height_d > 1.0 * live_width / live_height) {
  
              prev_rh = display_height_d;
  
              prev_rw = (int) (1.0 * display_height_d * live_width / live_height);
  
          } else {
  
              prev_rw = display_width_d;
  
              prev_rh = (int) (1.0 * display_width_d * live_height / live_width);
  
          }
  
          layoutParam = new RelativeLayout.LayoutParams(prev_rw, prev_rh);
  
          layoutParam.topMargin = (int) (1.0 * bg_screen_by * screenHeight / bg_height);
  
          layoutParam.leftMargin = (int) (1.0 * bg_screen_bx * screenWidth / bg_width);
  
  
  
          cameraDevice = Camera.open();
  
          Log.i(LOG_TAG, "cameara open");
  
          cameraView = new CameraView(this, cameraDevice);
  
          topLayout.addView(cameraView, layoutParam);
  
          Log.i(LOG_TAG, "cameara preview start: OK");
  
      }
  
  
  
      //---------------------------------------
  
      // initialize ffmpeg_recorder
  
      //---------------------------------------
  
      private void initRecorder() {
  
  
  
          Log.w(LOG_TAG,"init recorder");
  
  
  
          if (yuvIplimage == null) {
  
              yuvIplimage = IplImage.create(imageWidth, imageHeight, 8, 2);
  
              Log.i(LOG_TAG, "create yuvIplimage");
  
          }
  
  
  
          Log.i(LOG_TAG, "ffmpeg_url: " + ffmpeg_link);
  
          recorder = new FFmpegFrameRecorder(ffmpeg_link, imageWidth, imageHeight, 1);
  
          recorder.setFormat("flv");
  
          recorder.setSampleRate(sampleAudioRateInHz);
  
          // Set in the surface changed method
  
          recorder.setFrameRate(frameRate);
  
  
  
          Log.i(LOG_TAG, "recorder initialize success");
  
  
  
          audioRecordRunnable = new AudioRecordRunnable();
  
          audioThread = new Thread(audioRecordRunnable);
  
          runAudioThread = true;
  
      }
  
  
  
      public void startRecording() {
  
  
  
          try {
  
              recorder.start();
  
              startTime = System.currentTimeMillis();
  
              recording = true;
  
              audioThread.start();
  
  
  
          } catch (FFmpegFrameRecorder.Exception e) {
  
              e.printStackTrace();
  
          }
  
      }
  
  
  
      public void stopRecording() {
  
  
  
          runAudioThread = false;
  
          try {
  
              audioThread.join();
  
          } catch (InterruptedException e) {
  
              e.printStackTrace();
  
          }
  
          audioRecordRunnable = null;
  
          audioThread = null;
  
  
  
          if (recorder != null && recording) {
  
              recording = false;
  
              Log.v(LOG_TAG,"Finishing recording, calling stop and release on recorder");
  
              try {
  
                  recorder.stop();
  
                  recorder.release();
  
              } catch (FFmpegFrameRecorder.Exception e) {
  
                  e.printStackTrace();
  
              }
  
              recorder = null;
  
  
  
          }
  
      }
  
  
  
      @Override
  
      public boolean onKeyDown(int keyCode, KeyEvent event) {
  
  
  
          if (keyCode == KeyEvent.KEYCODE_BACK) {
  
              if (recording) {
  
                  stopRecording();
  
              }
  
  
  
              finish();
  
  
  
              return true;
  
          }
  
  
  
          return super.onKeyDown(keyCode, event);
  
      }
  
  
  
  
  
      //---------------------------------------------
  
      // 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;
  
              short[] audioData;
  
              int bufferReadResult;
  
  
  
              bufferSize = AudioRecord.getMinBufferSize(sampleAudioRateInHz, 
  
                      AudioFormat.CHANNEL_IN_MONO, AudioFormat.CHANNEL_OUT_DEFAULT);
  
              audioRecord = new AudioRecord(MediaRecorder.AudioSource.MIC, sampleAudioRateInHz, 
  
                      AudioFormat.CHANNEL_IN_MONO, AudioFormat.CHANNEL_OUT_DEFAULT, bufferSize);
  
  
  
              audioData = new short[bufferSize];
  
  
  
              Log.d(LOG_TAG, "audioRecord.startRecording()");
  
              audioRecord.startRecording();
  
  
  
              /* ffmpeg_audio encoding loop */
  
              while (runAudioThread) {
  
                  //Log.v(LOG_TAG,"recording? " + recording);
  
                  bufferReadResult = audioRecord.read(audioData, 0, audioData.length);
  
                  if (bufferReadResult > 0) {
  
                      Log.v(LOG_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.record(ShortBuffer.wrap(audioData, 0, bufferReadResult));
  
                              //Log.v(LOG_TAG,"recording " + 1024*i + " to " + 1024*i+1024);
  
                          } catch (FFmpegFrameRecorder.Exception e) {
  
                              Log.v(LOG_TAG,e.getMessage());
  
                              e.printStackTrace();
  
                          }
  
                      }
  
                  }
  
              }
  
              Log.v(LOG_TAG,"AudioThread Finished, release audioRecord");
  
  
  
              /* encoding finish, release recorder */
  
              if (audioRecord != null) {
  
                  audioRecord.stop();
  
                  audioRecord.release();
  
                  audioRecord = null;
  
                  Log.v(LOG_TAG,"audioRecord released");
  
              }
  
          }
  
      }
  
  
  
      //---------------------------------------------
  
      // camera thread, gets and encodes video data
  
      //---------------------------------------------
  
      class CameraView extends SurfaceView implements SurfaceHolder.Callback, PreviewCallback {
  
  
  
          private SurfaceHolder mHolder;
  
          private Camera mCamera;
  
  
  
          public CameraView(Context context, Camera camera) {
  
              super(context);
  
              Log.w("camera","camera view");
  
              mCamera = camera;
  
              mHolder = getHolder();
  
              mHolder.addCallback(CameraView.this);
  
              mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
  
              mCamera.setPreviewCallback(CameraView.this);
  
          }
  
  
  
          @Override
  
          public void surfaceCreated(SurfaceHolder holder) {
  
              try {
  
                  stopPreview();
  
                  mCamera.setPreviewDisplay(holder);
  
              } catch (IOException exception) {
  
                  mCamera.release();
  
                  mCamera = null;
  
              }
  
          }
  
  
  
          public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
  
              Log.v(LOG_TAG,"Setting imageWidth: " + imageWidth + " imageHeight: " + imageHeight + " frameRate: " + frameRate);
  
              Camera.Parameters camParams = mCamera.getParameters();
  
              camParams.setPreviewSize(imageWidth, imageHeight);
  
  
  
              Log.v(LOG_TAG,"Preview Framerate: " + camParams.getPreviewFrameRate());
  
  
  
              camParams.setPreviewFrameRate(frameRate);
  
              mCamera.setParameters(camParams);
  
              startPreview();
  
          }
  
  
  
          @Override
  
          public void surfaceDestroyed(SurfaceHolder holder) {
  
              try {
  
                  mHolder.addCallback(null);
  
                  mCamera.setPreviewCallback(null);
  
              } catch (RuntimeException e) {
  
                  // The camera has probably just been released, ignore.
  
              }
  
          }
  
  
  
          public void startPreview() {
  
              if (!isPreviewOn && mCamera != null) {
  
                  isPreviewOn = true;
  
                  mCamera.startPreview();
  
              }
  
          }
  
  
  
          public void stopPreview() {
  
              if (isPreviewOn && mCamera != null) {
  
                  isPreviewOn = false;
  
                  mCamera.stopPreview();
  
              }
  
          }
  
  
  
          @Override
  
          public void onPreviewFrame(byte[] data, Camera camera) {
  
              /* get video data */
  
              if (yuvIplimage != null && recording) {
  
                  yuvIplimage.getByteBuffer().put(data);
  
  
  
                  Log.v(LOG_TAG,"Writing Frame");
  
                  try {
  
                      long t = 1000 * (System.currentTimeMillis() - startTime);
  
                      if (t > recorder.getTimestamp()) {
  
                          recorder.setTimestamp(t);
  
                      }
  
                      recorder.record(yuvIplimage);
  
                  } catch (FFmpegFrameRecorder.Exception e) {
  
                      Log.v(LOG_TAG,e.getMessage());
  
                      e.printStackTrace();
  
                  }
  
              }
  
          }
  
      }
  
  
  
      @Override
  
      public void onClick(View v) {
  
          if (!recording) {
  
              startRecording();
  
              Log.w(LOG_TAG, "Start Button Pushed");
  
              btnRecorderControl.setText("Stop");
  
          } else {
  
              // This will trigger the audio recording loop to stop and then set isRecorderStart = false;
  
              stopRecording();
  
              Log.w(LOG_TAG, "Stop Button Pushed");
  
              btnRecorderControl.setText("Start");
  
          }
  
      }
  
  
  
  
  
  }