Recherche avancée

Sur d’autres sites (8016)

• ffmpeg avcodec_encode_video2 hangs when using Quick Sync h264_qsv encoder

  11 janvier 2017, par Mike Simpson

  When I use the mpeg4 or h264 encoders, I am able to successfully encode images to make a valid AVI file using the API for ffmpeg 3.1.0. However, when I use the Quick Sync encoder (h264_qsv), avcodec_encode_video2 will hang some of the time. I found that when using images that are 1920x1080, it was rare that avcodec_encode_video2 would hang. When using 256x256 images, it was very likely that the function would hang.

  I have created the test code below that demonstrates the hang of avcodec_encode_video2. The code will create a 1000 frame, 256x256 AVI with a bit rate of 400000. The frames are simply allocated, so the output video should just be green frames.

  The problem was observed using Windows 7 and Windows 10, using the 32-bit or 64-bit test application.

  If anyone has any idea on how I can avoid the avcodec_encode_video2 hang I would be very grateful ! Thanks in advance for any assistance.

  extern "C"
  
  {
  
  #ifndef __STDC_CONSTANT_MACROS
  
  #define __STDC_CONSTANT_MACROS
  
  #endif
  
  #include "avcodec.h"
  
  #include "avformat.h"
  
  #include "swscale.h"
  
  #include "avutil.h"
  
  #include "imgutils.h"
  
  #include "opt.h"
  
  #include 
  
  }
  
  
  
  #include <iostream>
  
  
  
  
  
  // Globals
  
  AVCodec* m_pCodec = NULL;
  
  AVStream *m_pStream = NULL;
  
  AVOutputFormat* m_pFormat = NULL;
  
  AVFormatContext* m_pFormatContext = NULL;
  
  AVCodecContext* m_pCodecContext = NULL;
  
  AVFrame* m_pFrame = NULL;
  
  int m_frameIndex;
  
  
  
  // Output format
  
  AVPixelFormat m_pixType = AV_PIX_FMT_NV12;
  
  // Use for mpeg4
  
  //AVPixelFormat m_pixType = AV_PIX_FMT_YUV420P;
  
  
  
  // Output frame rate
  
  int m_frameRate = 30;
  
  // Output image dimensions
  
  int m_imageWidth = 256;
  
  int m_imageHeight = 256;
  
  // Number of frames to export
  
  int m_frameCount = 1000;
  
  // Output file name
  
  const char* m_fileName = "c:/test/test.avi";
  
  // Output file type
  
  const char* m_fileType = "AVI";
  
  // Codec name used to encode
  
  const char* m_encoderName = "h264_qsv";
  
  // use for mpeg4
  
  //const char* m_encoderName = "mpeg4";
  
  // Target bit rate
  
  int m_targetBitRate = 400000;
  
  
  
  void addVideoStream()
  
  {
  
      m_pStream = avformat_new_stream( m_pFormatContext, m_pCodec );
  
      m_pStream->id = m_pFormatContext->nb_streams - 1;
  
      m_pStream->time_base = m_pCodecContext->time_base;
  
      m_pStream->codec->pix_fmt = m_pixType;
  
      m_pStream->codec->flags = m_pCodecContext->flags;
  
      m_pStream->codec->width = m_pCodecContext->width;
  
      m_pStream->codec->height = m_pCodecContext->height;
  
      m_pStream->codec->time_base = m_pCodecContext->time_base;
  
      m_pStream->codec->bit_rate = m_pCodecContext->bit_rate;
  
  }
  
  
  
  AVFrame* allocatePicture( enum AVPixelFormat pix_fmt, int width, int height )
  
  {
  
      AVFrame *frame;
  
  
  
      frame = av_frame_alloc();
  
  
  
      if ( !frame )
  
      {
  
          return NULL;
  
      }
  
  
  
      frame->format = pix_fmt;
  
      frame->width  = width;
  
      frame->height = height;
  
  
  
      int checkImage = av_image_alloc( frame->data, frame->linesize, width, height, pix_fmt, 32 );
  
  
  
      if ( checkImage &lt; 0 )
  
      {
  
          return NULL;
  
      }
  
  
  
      return frame;
  
  }
  
  
  
  bool initialize()
  
  {
  
      AVRational frameRate;
  
      frameRate.den = m_frameRate;
  
      frameRate.num = 1;
  
  
  
      av_register_all();
  
  
  
      m_pCodec = avcodec_find_encoder_by_name(m_encoderName);
  
  
  
      if( !m_pCodec )
  
      {
  
          return false;
  
      }
  
  
  
      m_pCodecContext = avcodec_alloc_context3( m_pCodec );
  
      m_pCodecContext->width = m_imageWidth;
  
      m_pCodecContext->height = m_imageHeight;
  
      m_pCodecContext->time_base = frameRate;
  
      m_pCodecContext->gop_size = 0;
  
      m_pCodecContext->pix_fmt = m_pixType;
  
      m_pCodecContext->codec_id = m_pCodec->id;
  
      m_pCodecContext->bit_rate = m_targetBitRate;
  
  
  
      av_opt_set( m_pCodecContext->priv_data, "+CBR", "", 0 );
  
  
  
      return true;
  
  }
  
  
  
  bool startExport()
  
  {
  
      m_frameIndex = 0;
  
      char fakeFileName[512]; 
  
      int checkAllocContext = avformat_alloc_output_context2( &amp;m_pFormatContext, NULL, m_fileType, fakeFileName );
  
  
  
      if ( checkAllocContext &lt; 0 )
  
      {
  
          return false;
  
      }
  
  
  
      if ( !m_pFormatContext ) 
  
      {
  
          return false;
  
      }
  
  
  
      m_pFormat = m_pFormatContext->oformat;
  
  
  
      if ( m_pFormat->video_codec != AV_CODEC_ID_NONE ) 
  
      {
  
          addVideoStream();
  
  
  
          int checkOpen = avcodec_open2( m_pCodecContext, m_pCodec, NULL );
  
  
  
          if ( checkOpen &lt; 0 )
  
          {
  
              return false;
  
          }
  
  
  
          m_pFrame = allocatePicture( m_pCodecContext->pix_fmt, m_pCodecContext->width, m_pCodecContext->height );                
  
          if( !m_pFrame ) 
  
          {
  
              return false;
  
          }
  
          m_pFrame->pts = 0;
  
      }
  
  
  
      int checkOpen = avio_open( &amp;m_pFormatContext->pb, m_fileName, AVIO_FLAG_WRITE );
  
      if ( checkOpen &lt; 0 )
  
      {
  
          return false;
  
      }
  
  
  
      av_dict_set( &amp;(m_pFormatContext->metadata), "title", "QS Test", 0 );
  
  
  
      int checkHeader = avformat_write_header( m_pFormatContext, NULL );
  
      if ( checkHeader &lt; 0 )
  
      {
  
          return false;
  
      }
  
  
  
      return true;
  
  }
  
  
  
  int processFrame( AVPacket&amp; avPacket )
  
  {
  
      avPacket.stream_index = 0;
  
      avPacket.pts = av_rescale_q( m_pFrame->pts, m_pStream->codec->time_base, m_pStream->time_base );
  
      avPacket.dts = av_rescale_q( m_pFrame->pts, m_pStream->codec->time_base, m_pStream->time_base );
  
      m_pFrame->pts++;
  
  
  
      int retVal = av_interleaved_write_frame( m_pFormatContext, &amp;avPacket );
  
      return retVal;
  
  }
  
  
  
  bool exportFrame()
  
  {
  
      int success = 1;
  
      int result = 0;
  
  
  
      AVPacket avPacket;
  
  
  
      av_init_packet( &amp;avPacket );
  
      avPacket.data = NULL;
  
      avPacket.size = 0;
  
  
  
      fflush(stdout);
  
  
  
      std::cout &lt;&lt; "Before avcodec_encode_video2 for frame: " &lt;&lt; m_frameIndex &lt;&lt; std::endl;
  
      success = avcodec_encode_video2( m_pCodecContext, &amp;avPacket, m_pFrame, &amp;result );
  
      std::cout &lt;&lt; "After avcodec_encode_video2 for frame: " &lt;&lt; m_frameIndex &lt;&lt; std::endl;
  
  
  
      if( result )
  
      { 
  
          success = processFrame( avPacket );
  
      }
  
  
  
      av_packet_unref( &amp;avPacket );
  
  
  
      m_frameIndex++;
  
      return ( success == 0 );
  
  }
  
  
  
  void endExport()
  
  {
  
      int result = 0;
  
      int success = 0;
  
  
  
      if (m_pFrame)
  
      {
  
          while ( success == 0 )
  
          {
  
              AVPacket avPacket;
  
              av_init_packet( &amp;avPacket );
  
              avPacket.data = NULL;
  
              avPacket.size = 0;
  
  
  
              fflush(stdout);
  
              success = avcodec_encode_video2( m_pCodecContext, &amp;avPacket, NULL, &amp;result );
  
  
  
              if( result )
  
              { 
  
                  success = processFrame( avPacket );
  
              }
  
              av_packet_unref( &amp;avPacket );
  
  
  
              if (!result)
  
              {
  
                  break;
  
              }
  
          }
  
      }
  
  
  
      if (m_pFormatContext)
  
      {
  
          av_write_trailer( m_pFormatContext );
  
  
  
          if( m_pFrame )
  
          {
  
              av_frame_free( &amp;m_pFrame );
  
          }
  
  
  
          avio_closep( &amp;m_pFormatContext->pb );
  
          avformat_free_context( m_pFormatContext );
  
          m_pFormatContext = NULL;
  
      }
  
  }
  
  
  
  void cleanup()
  
  {
  
      if( m_pFrame || m_pCodecContext )
  
      {
  
          if( m_pFrame )
  
          {
  
              av_frame_free( &amp;m_pFrame );
  
          }
  
  
  
          if( m_pCodecContext )
  
          {
  
              avcodec_close( m_pCodecContext );
  
              av_free( m_pCodecContext );
  
          }
  
      }
  
  }
  
  
  
  int main()
  
  {
  
      bool success = true;
  
      if (initialize())
  
      {
  
          if (startExport())
  
          {
  
              for (int loop = 0; loop &lt; m_frameCount; loop++)
  
              {
  
                  if (!exportFrame())
  
                  {
  
                      std::cout &lt;&lt; "Failed to export frame\n";
  
                      success = false;
  
                      break;
  
                  }
  
              }
  
              endExport();
  
          }
  
          else
  
          {
  
              std::cout &lt;&lt; "Failed to start export\n";
  
              success = false;
  
          }
  
  
  
          cleanup();
  
      }
  
      else
  
      {
  
          std::cout &lt;&lt; "Failed to initialize export\n";
  
          success = false;
  
      }
  
  
  
      if (success)
  
      {
  
          std::cout &lt;&lt; "Successfully exported file\n";
  
      }
  
      return 1;
  
  }
  
  </iostream>

• FFmpeg "movflags" > "faststart" causes av_write_trailer() to return -2

  30 juin 2016, par williamtroup

  I’m setting up the format layout for the ideo as follows :

  AVOutputFormat* outputFormat = ffmpeg.av_guess_format(null, "output.mp4", null);
  
  
  
  AVCodec* videoCodec = ffmpeg.avcodec_find_encoder(outputFormat->video_codec);
  
  
  
  AVFormatContext* formatContext = ffmpeg.avformat_alloc_context();
  
  formatContext->oformat = outputFormat;
  
  formatContext->video_codec_id = videoCodec->id;
  
  
  
  ffmpeg.avformat_new_stream(formatContext, videoCodec);

  This is how I am setting up the Codec Context :

  AVCodecContext* codecContext = ffmpeg.avcodec_alloc_context3(videoCodec);
  
  codecContext->bit_rate = 400000;
  
  codecContext->width = 1280;
  
  codecContext->height = 720;
  
  codecContext->gop_size = 12;
  
  codecContext->max_b_frames = 1;
  
  codecContext->pix_fmt = videoCodec->pix_fmts[0];
  
  codecContext->codec_id = videoCodec->id;
  
  codecContext->codec_type = videoCodec->type;
  
  codecContext->time_base = new AVRational
  
  {
  
      num = 1,
  
      den = 30
  
  };

  I’m using the following code to setup the "movflags" > "faststart" option for the header of the video :

  AVDictionary* options = null;
  
  
  
  int result = ffmpeg.av_dict_set(&options, "movflags", "faststart", 0);
  
  
  
  int writeHeaderResult = ffmpeg.avformat_write_header(formatContext, &options);

  The file is opened and the header is written as follows :

  if ((formatContext->oformat->flags & ffmpeg.AVFMT_NOFILE) == 0)
  
  {
  
      int ioOptionResult = ffmpeg.avio_open(&formatContext->pb, "output.mp4", ffmpeg.AVIO_FLAG_WRITE);
  
  }
  
  
  
  int writeHeaderResult = ffmpeg.avformat_write_header(formatContext, &options);

  After this, I write each video frame as follows :

  outputFrame->pts = frameIndex;
  
  
  
  packet.flags |= ffmpeg.AV_PKT_FLAG_KEY;
  
  packet.pts = frameIndex;
  
  packet.dts = frameIndex;
  
  
  
  int encodedFrame = 0;
  
  int encodeVideoResult = ffmpeg.avcodec_encode_video2(codecContext, &packet, outputFrame, &encodedFrame);
  
  
  
  if (encodedFrame != 0)
  
  {
  
      packet.pts = ffmpeg.av_rescale_q(packet.pts, codecContext->time_base, m_videoStream->time_base);
  
      packet.dts = ffmpeg.av_rescale_q(packet.dts, codecContext->time_base, m_videoStream->time_base);
  
      packet.stream_index = m_videoStream->index;
  
  
  
      if (codecContext->coded_frame->key_frame > 0)
  
      {
  
          packet.flags |= ffmpeg.AV_PKT_FLAG_KEY;
  
      }
  
  
  
      int writeFrameResult = ffmpeg.av_interleaved_write_frame(formatContext, &packet);
  
  }

  After that, I write the trailer :

  int writeTrailerResult = ffmpeg.av_write_trailer(formatContext);

  However, writeTrailerResult is always -2. I’m been looking into this problem for days and cannot figure out what the problem is.

  The DLLs used for the AutoGen library are :

  avcodec-56.dll
  
  avdevice-56.dll
  
  avfilter-5.dll
  
  avformat-56.dll
  
  avutil-54.dll
  
  postproc-53.dll
  
  swresample-1.dll
  
  swscale-3.dll

• ffmpeg : split mp3, encode aac and join produce artifacts and empty space

  18 juin 2016, par aganeiro

  Source mp3

      ffprobe -show_frames -select_streams a -print_format csv -show_entries  
  
   frame=index,pkt_dts_time ~/demo_files/000.orig.5352357791787324393.mp3
  
  frame,0.000000
  
  frame,0.026122
  
  frame,0.052245
  
  frame,0.078367

  every part I make with command, -ss position and -t time I got and calculate from previous ffprobe output

      /home/xxx/bin/ffmpeg -analyzeduration 50000000 -probesize 50000000  
  
  -ss 0.000000 -i /home/xxx/demo_files/000.orig.5352357791787324393.mp3  
  
  -s 0 -t 0.926276 -flags +global_header -c:a libfdk_aac -strict -2  
  
  -b:a 64k -ac 2 -ar 44100 -vn -f mpegts -y /tmp/p0.ts
  
  
  
      /home/xxx/bin/ffmpeg -analyzeduration 50000000 -probesize 50000000  
  
  -ss 1.018776 -i /home/xxx/demo_files/000.orig.5352357791787324393.mp 
  
  -s 0 -t 0.900153 -flags +global_header -c:a libfdk_aac -strict -2  
  
  -b:a 64k -ac 2 -ar 44100 -vn -f mpegts -y /tmp/p1.ts

  it’s produce

  [mp3 @ 0x39ca980] Estimating duration from bitrate, this may be inaccurate
  
      Input #0, mp3, from '/home/xxx/demo_files/000.orig.5352357791787324393.mp3':
  
      Duration: 00:05:17.20, start: 0.000000, bitrate: 320 kb/s
  
      Stream #0:0: Audio: mp3, 44100 Hz, stereo, s16p, 320 kb/s
  
      [mpegts @ 0x39ccea0] Using AVStream.codec to pass codec  
  
  parameters to muxers is deprecated, use AVStream.codecpar instead.
  
      [mpegts @ 0x39ccea0] frame size not set
  
      Output #0, mpegts, to '/tmp/p0.ts':
  
        Metadata:
  
          encoder         : Lavf57.38.100
  
          Stream #0:0: Audio: aac (libfdk_aac), 44100 Hz, stereo, s16, 64 kb/s
  
          Metadata:
  
            encoder         : Lavc57.46.100 libfdk_aac
  
      Stream mapping:
  
        Stream #0:0 -> #0:0 (mp3 (native) -> aac (libfdk_aac))
  
      Press [q] to stop, [?] for help
  
      size=      10kB time=00:00:00.92 bitrate=  92.3kbits/s speed=39.8x    
  
      video:0kB audio:8kB subtitle:0kB other streams:0kB global  
  
  headers:0kB muxing overhead: 24.619143%
  
        Duration: 00:00:00.63, start: 1.400000, bitrate: 127 kb/s

  Part info

      ffmpeg -hide_banner -i /tmp/p0.ts 2>&1 |grep -P 'Duration|Stream'
  
      Duration: 00:00:00.95, start: 1.400000, bitrate: 90 kb/s
  
      Stream #0:0[0x100]: Audio: aac (LC) ([15][0][0][0] / 0x000F),  
  
  44100 Hz, stereo, fltp, 68 kb/s

  Then I join all parts together with

      /home/xxx/bin/ffmpeg -i /tmp/p0.ts -i /tmp/p1.ts -i /tmp/p2.ts  
  
  -i /tmp/p3.ts -i /tmp/p4.ts -i /tmp/p5.ts -filter_complex  
  
  "[0:a]asetpts=PTS-STARTPTS[a0];[1:a]asetpts=PTS-STARTPTS[a1];  
  
  [2:a]asetpts=PTS-STARTPTS[a2];[3:a]asetpts=PTS-STARTPTS[a3];  
  
  [4:a]asetpts=PTS-STARTPTS[a4];[5:a]asetpts=PTS-STARTPTS[a5];  
  
  [a0][a1][a2][a3][a4][a5] concat=n=6:v=0:a=1 [a]"  
  
  -map [a] -strict experimental -fflags +genpts -flags +global_header  
  
  -c libfdk_aac -bsf:a aac_adtstoasc -y /tmp/res.m4a

  waveform of original and joined on the left
  

  So, as you can see joined have delays and waveforms starte later. Why ? maybe it depens that all encoded parts have start time 1.400000, ?? How to set start time to 0 on encode ?

  Also I tried to cut empty space on joining with filter_complex but result stil not good and contains artifacts because trim position looks different in every part.

      /home/xxx/bin/ffmpeg -i /tmp/p0.ts -i /tmp/p1.ts -i /tmp/p2.ts  
  
  -i /tmp/p3.ts -i /tmp/p4.ts -i /tmp/p5.ts -filter_complex  
  
  "[0:a]atrim=0.020000,asetpts=PTS-STARTPTS[a0];  
  
  [1:a]atrim=0.020000,asetpts=PTS-STARTPTS[a1];  
  
  [2:a]atrim=0.020000,asetpts=PTS-STARTPTS[a2];  
  
  [3:a]atrim=0.020000,asetpts=PTS-STARTPTS[a3];  
  
  [4:a]atrim=0.020000,asetpts=PTS-STARTPTS[a4];  
  
  [5:a]atrim=0.020000,asetpts=PTS-STARTPTS[a5];  
  
  [a0][a1][a2][a3][a4][a5] concat=n=6:v=0:a=1 [a]"  
  
  -map [a] -strict experimental -fflags +genpts  
  
  -flags +global_header -c libfdk_aac -bsf:a aac_adtstoasc  
  
  -y /tmp/res.m4a

  Whyyyy and how to solve it ?