Recherche avancée

Sur d’autres sites (11432)

• FFmpeg using Intel quicksync

  3 mars 2016, par KevinA

  I’m trying to use FFmpeg with Intel QuickSync(qsv)

  Finding the codec works, but when I go to open the codec I get a -40

  I’ve traced it to :
  ret = MFXVideoENCODE_GetVideoParam(q->session, &q->param) ;

  Below in my initialzation code :

  AVCodec* m_codec = ::avcodec_find_encoder_by_name("h264_qsv");
  
  if (!m_codec){
  
      DBGPRINTF("Could not find encoder");
  
      return E_INVALIDARG;
  
  }
  
  
  
  AVCodecContext* m_context = ::avcodec_alloc_context3(m_codec);
  
  if (!m_context){
  
      DBGPRINTF("Could not alloc AV context");
  
      return E_INVALIDARG;
  
  }
  
  
  
  mfxIMPL impl = MFX_IMPL_AUTO;
  
  mfxVersion ver = { { 1, 1 } };
  
  
  
  MFXInit(impl, &ver, &m_qsvContext->session);
  
  
  
  m_qsvContext->iopattern             = MFX_IOPATTERN_IN_OPAQUE_MEMORY;
  
  m_qsvContext->opaque_alloc          = 1;
  
  m_qsvContext->nb_opaque_surfaces    = 16;
  
  
  
  m_context->hwaccel_context          = m_qsvContext;    
  
  m_context->profile                  = FF_PROFILE_H264_BASELINE;
  
  
  
  AVRational fps;
  
  AVRational sar;
  
  fps.num                             = static_cast(m_targetFPS);
  
  fps.den                             = 1;
  
  sar.num                             = m_iHeightOut;
  
  sar.den                             = m_iWidthOut;
  
  //m_context->bit_rate               = 400000;
  
  m_context->width                    = m_iWidthOut;
  
  m_context->height                   = m_iHeightOut;
  
  m_context->has_b_frames             = 0;
  
  m_context->sample_aspect_ratio      = sar;
  
  m_context->time_base                = fps;
  
  
  
  m_context->gop_size                 = s_keyFramesMax;
  
  m_context->pix_fmt                  = AV_PIX_FMT_QSV;
  
  m_context->flags                   |= AV_CODEC_FLAG_QSCALE;
  
  m_context->flags                   |= CODEC_FLAG_PASS1;
  
  m_context->thread_count             = 1;
  
  m_context->codec_type               = AVMEDIA_TYPE_VIDEO;
  
  
  
  ::av_opt_set(m_context->priv_data, "preset", "fast", 0);
  
  ::av_opt_set(m_context->priv_data, "look_ahead", "0", 0);
  
  
  
  int ret = avcodec_open2(context, codec, nullptr);
  
  if (ret < 0) {
  
      DBGPRINTF("Could not open codec h264_qsv with code %d", ret);
  
      return ret;
  
  }

  I’m obviously missing something, but i’m not sure what. Can someone help point me in the correct direction ?

• Increase Duration of a video FFMPEG C++

  9 avril 2015, par Shahroz Tariq

  I am using the code from the samples of FFmpeg which encodes a picture into a video. All I want to do is to give it a series of pictures and it gives me a video with each picture is taking one second`Code below is just taking one picture from my file system & creating video from it

  AVCodec *codec;
  
  AVCodecContext *c = NULL;
  
  int i, ret, x, y, got_output;
  
  FILE *f;
  
  
  
  AVPacket pkt;
  
  uint8_t endcode[] = { 0, 0, 1, 0xb7 };
  
  
  
  printf("Encode video file %s\n", filename);
  
  
  
  /* find the mpeg1 video encoder */
  
  codec = avcodec_find_encoder((AVCodecID)codec_id);
  
  if (!codec)
  
  {
  
      fprintf(stderr, "Codec not found\n");
  
      exit(1);
  
  }
  
  
  
  c = avcodec_alloc_context3(codec);
  
  if (!c)
  
  {
  
      fprintf(stderr, "Could not allocate video codec context\n");
  
      exit(1);
  
  }
  
  
  
  /* put sample parameters */
  
  c->bit_rate = 400000;
  
  /* resolution must be a multiple of two */
  
  c->width = 200;
  
  c->height = 200;
  
  /* frames per second */
  
  AVRational rational;
  
  rational.num = 1;
  
  rational.den = 25;
  
  c->time_base = rational;
  
  /* emit one intra frame every ten frames
  
  * check frame pict_type before passing frame
  
  * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
  
  * then gop_size is ignored and the output of encoder
  
  * will always be I frame irrespective to gop_size
  
  */
  
  c->gop_size = 10;
  
  c->max_b_frames = 1;
  
  c->pix_fmt = AV_PIX_FMT_YUV420P;
  
  
  
  if (codec_id == AV_CODEC_ID_H264)
  
      av_opt_set(c->priv_data, "preset", "slow", 0);
  
  
  
  /* open it */
  
  if (avcodec_open2(c, codec, NULL) < 0)
  
  {
  
      fprintf(stderr, "Could not open codec\n");
  
      exit(1);
  
  }
  
  
  
  fopen_s(&f, filename, "wb");
  
  if (!f)
  
  {
  
      fprintf(stderr, "Could not open %s\n", filename);
  
      exit(1);
  
  }
  
  AVFrame *frame = OpenImage("..\\..\\..\\..\\..\\..\\1.jpg");
  
  //frame = av_frame_alloc();
  
  if (!frame)
  
  {
  
      fprintf(stderr, "Could not allocate video frame\n");
  
      exit(1);
  
  }
  
  
  
  frame->format = c->pix_fmt;
  
  frame->width = c->width;
  
  frame->height = c->height;
  
  /* the image can be allocated by any means and av_image_alloc() is
  
  * just the most convenient way if av_malloc() is to be used */
  
  
  
  int screenHeight = 200;
  
  int screenWidth = 200;
  
  for (i = 0; i < 25; i++)
  
  {
  
      av_init_packet(&pkt);
  
      pkt.data = NULL;    // packet data will be allocated by the encoder
  
      pkt.size = 0;
  
  
  
      fflush(stdout);
  
  
  
  
  
  
  
      frame->pts = i;
  
  
  
      /* encode the image */
  
      ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
  
      if (ret < 0)
  
      {
  
          fprintf(stderr, "Error encoding frame\n");
  
          exit(1);
  
      }
  
  
  
      if (got_output)
  
      {
  
          printf("Write frame %3d (size=%5d)\n", i, pkt.size);
  
          fwrite(pkt.data, 1, pkt.size, f);
  
          av_free_packet(&pkt);
  
      }
  
  }
  
  
  
  /* get the delayed frames */
  
  for (got_output = 1; got_output; i++)
  
  {
  
      fflush(stdout);
  
  
  
      ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
  
      if (ret < 0)
  
      {
  
          fprintf(stderr, "Error encoding frame\n");
  
          exit(1);
  
      }
  
  
  
      if (got_output)
  
      {
  
          printf("Write frame %3d (size=%5d)\n", i, pkt.size);
  
          fwrite(pkt.data, 1, pkt.size, f);
  
          av_free_packet(&pkt);
  
      }
  
  }
  
  
  
  /* add sequence end code to have a real mpeg file */
  
  fwrite(endcode, 1, sizeof(endcode), f);
  
  fclose(f);
  
  
  
  avcodec_close(c);
  
  av_free(c);
  
  av_freep(&frame->data[0]);
  
  av_frame_free(&frame);
  
  printf("\n");`

• FFmpeg c++ H264 decoding error

  12 avril 2015, par Yoohoo

  I have a program which capture video from webcam, encode with ffmpeg, encoded packet then write to buffer. At the receiver side, read from buffer decode with ffmpeg and play.

  Now I merge sender and receiver in one program for testing. It works fine with AV_CODEC_ID_MPEG1VIDEO, but when I change the ffmpeg codec to AV_CODEC_ID_H264, at the decoding progress, it shows error :

  

  The whole program is here FYI, I made a loop to let the whole progress run twice.

  What is the cause of the error, is there anything special for H264 ? Thanks in advance !

  #include 
  
  
  
  extern "C" {
  
  
  
  #include <libavutil></libavutil>opt.h>
  
  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libavutil></libavutil>channel_layout.h>
  
  #include <libavutil></libavutil>common.h>
  
  #include <libavutil></libavutil>imgutils.h>
  
  #include <libavutil></libavutil>mathematics.h>
  
  #include <libavutil></libavutil>samplefmt.h>
  
  #include <libswscale></libswscale>swscale.h>
  
  #include "v4l2.h"
  
  }
  
  #include "opencv2/highgui/highgui.hpp"
  
  #include <iostream>
  
  
  
  using namespace cv;
  
  using namespace std;
  
  #define INBUF_SIZE 4096
  
  static uint8_t inbuf[INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE];
  
  
  
  
  
  
  
  static AVCodec *codec;
  
  static AVCodecContext *c= NULL;
  
  static int  ret,   got_output;
  
  static int frame_count;
  
  static FILE *f;
  
  
  
  static AVPacket pkt;
  
  static AVFrame *frame;
  
  static AVFrame *frameDecode;
  
  static AVFrame *framergb;
  
  static uint8_t endcode[] = { 0, 0, 1, 0xb7 };
  
  static AVPacket avpkt;
  
  int totalSize=0;
  
  
  
  #define SUBSITY     3
  
  
  
  
  
  
  
  static int decode_write_frame(AVCodecContext *avctx,
  
                            AVFrame *frame, int *frame_count, AVPacket *pkt, int last)
  
  {
  
  int len, got_frame;
  
  char buf[1024];
  
  struct SwsContext *convert_ctx;
  
  Mat m;
  
  AVFrame dst;
  
  
  
  len = avcodec_decode_video2(avctx, frame, &amp;got_frame, pkt);
  
  if (len &lt; 0) {
  
      fprintf(stderr, "Error while decoding frame %d\n", *frame_count);
  
      return len;
  
  }
  
  if (got_frame) {
  
      printf("Saving %s frame %3d\n", last ? "last " : "", *frame_count);
  
      fflush(stdout);
  
  
  
  int w = avctx->width;
  
  int h = avctx->height;
  
  
  
  /*convert AVFrame to opencv Mat frame*/
  
  
  
  m = cv::Mat(h, w, CV_8UC3);
  
  dst.data[0] = (uint8_t *)m.data;
  
  avpicture_fill( (AVPicture *)&amp;dst, dst.data[0], PIX_FMT_BGR24, w, h);
  
  
  
  enum PixelFormat src_pixfmt = (enum PixelFormat)frame->format;
  
  enum PixelFormat dst_pixfmt = PIX_FMT_BGR24;
  
  convert_ctx = sws_getContext(w, h, src_pixfmt, w, h, dst_pixfmt,
  
                      SWS_FAST_BILINEAR, NULL, NULL, NULL);
  
  
  
  if(convert_ctx == NULL) {
  
      fprintf(stderr, "Cannot initialize the conversion context!\n");
  
      exit(1);
  
  }
  
  
  
  sws_scale(convert_ctx, frame->data, frame->linesize, 0, h,
  
                      dst.data, dst.linesize);
  
  
  
  
  
      imshow("MyVideo", m);
  
      //video.write(m);
  
      waitKey(10); //wait next frame time
  
  
  
  
  
      (*frame_count)++;
  
  }
  
  if (pkt->data) {
  
      pkt->size -= len;
  
      pkt->data += len;
  
  }
  
  return 0;
  
  }
  
  
  
  
  
  static void video_decode_example(char *inbufout)
  
  {
  
  int bytes;
  
  uint8_t *buffer;
  
  
  
  av_init_packet(&amp;avpkt);
  
  
  
  
  
  memset(inbuf + INBUF_SIZE, 0, FF_INPUT_BUFFER_PADDING_SIZE);
  
  
  
  
  
  codec = avcodec_find_decoder(AV_CODEC_ID_H264);
  
  if (!codec) {
  
      fprintf(stderr, "Codec not found\n");
  
      exit(1);
  
  }
  
  
  
  c = avcodec_alloc_context3(codec);
  
  if (!c) {
  
      fprintf(stderr, "Could not allocate video codec context\n");
  
      exit(1);
  
  }
  
  
  
  if(codec->capabilities&amp;CODEC_CAP_TRUNCATED)
  
      c->flags|= CODEC_FLAG_TRUNCATED; /* we do not send complete frames */
  
  
  
  
  
  /* open it */
  
  if (avcodec_open2(c, codec, NULL) &lt; 0) {
  
      fprintf(stderr, "Could not open codec\n");
  
      exit(1);
  
  }
  
  
  
  
  
  frameDecode = avcodec_alloc_frame();
  
  if (!frameDecode) {
  
      fprintf(stderr, "Could not allocate video frame\n");
  
      exit(1);
  
  }
  
  
  
  
  
  bytes=avpicture_get_size(PIX_FMT_RGB24, CAMER_WIDTH, CAMER_HEIGHT);
  
  buffer=(uint8_t *)av_malloc(bytes*sizeof(uint8_t));
  
  avpicture_fill((AVPicture *)framergb, buffer, PIX_FMT_RGB24,
  
                  CAMER_WIDTH, CAMER_HEIGHT);*/
  
  
  
  frame_count = 0;
  
  
  
  namedWindow("MyVideo",CV_WINDOW_AUTOSIZE); //create a window called "MyVideo"
  
  
  
  
  
  int size1=0;
  
  for(;;) {
  
  
  
      memcpy(inbuf,inbufout+size1,INBUF_SIZE);
  
      size1+=INBUF_SIZE;
  
      if (size1>(totalSize-INBUF_SIZE))
  
          break;
  
      avpkt.size=INBUF_SIZE;
  
  
  
  
  
      avpkt.data = inbuf;
  
  
  
      /*frame by frame process*/
  
  
  
      while (avpkt.size > 0)
  
          if (decode_write_frame(c, frameDecode, &amp;frame_count, &amp;avpkt, 0) &lt; 0)
  
              exit(1);
  
  }
  
  avpkt.data = NULL;
  
  avpkt.size = 0;
  
  decode_write_frame(c, frameDecode, &amp;frame_count, &amp;avpkt, 1);
  
  }
  
  static void init_video_encode(const char *filename, AVCodecID codec_id, int max_f)
  
  {
  
  
  
  printf("Encode video file %s\n", filename);
  
  
  
  /* find the mpeg1 video encoder */
  
  codec = avcodec_find_encoder(codec_id);
  
  if (!codec) {
  
      fprintf(stderr, "Codec not found\n");
  
      exit(1);
  
  }
  
  
  
  c = avcodec_alloc_context3(codec);
  
  if (!c) {
  
      fprintf(stderr, "Could not allocate video codec context\n");
  
      exit(1);
  
  }
  
  
  
  /* put sample parameters */
  
  c->bit_rate = 400000;
  
  /* resolution must be a multiple of two */
  
  c->width = 640;
  
  c->height = 480;
  
  /* frames per second */
  
  c->time_base= (AVRational){1,25};
  
  c->gop_size = 10; /* emit one intra frame every ten frames */
  
  c->max_b_frames=max_f;
  
  c->pix_fmt = AV_PIX_FMT_YUV420P;
  
  
  
  if(codec_id == AV_CODEC_ID_H264)
  
      av_opt_set(c->priv_data, "preset", "slow", 0);
  
  
  
  /* open it */
  
  if (avcodec_open2(c, codec, NULL) &lt; 0) {
  
      fprintf(stderr, "Could not open codec\n");
  
      exit(1);
  
  }
  
  
  
  frame = avcodec_alloc_frame();
  
  if (!frame) {
  
      fprintf(stderr, "Could not allocate video frame\n");
  
      exit(1);
  
  }
  
  frame->format = c->pix_fmt;
  
  frame->width  = c->width;
  
  frame->height = c->height;
  
  
  
  
  
  ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
  
                       c->pix_fmt, 32);
  
  
  
  /* get the delayed frames */
  
  if (ret &lt; 0) {
  
      fprintf(stderr, "Could not allocate raw picture buffer\n");
  
      exit(1);
  
  }
  
  
  
  printf("\n");
  
  }
  
  
  
  int video_encode(int frameNo,char *inbufout)
  
  {
  
  static int count = 0;
  
  static int i = 0;
  
  
  
  /* encode 1 frame of video */
  
  av_init_packet(&amp;pkt);
  
  pkt.data = NULL;    // packet data will be allocated by the encoder
  
  pkt.size = 0;
  
  //cout&lt;&lt;"\nBefore YUV\n";
  
  if(count == 0)
  
  read_yuv420(frame->data[0]);
  
  count ++;
  
  
  
  if(count == SUBSITY) {
  
  count = 0;
  
  }
  
  
  
  frame->pts = i++;
  
  
  
  /* encode the image */
  
  ret = avcodec_encode_video2(c, &amp;pkt, frame, &amp;got_output);
  
  if (ret &lt; 0) {
  
       fprintf(stderr, "Error encoding frame\n");
  
       return -1;
  
  }
  
  
  
  if (got_output) {
  
       printf("Write frame %3d (size=%5d)\n", i, pkt.size);
  
       memcpy(inbufout+totalSize,pkt.data,pkt.size);
  
       totalSize+=pkt.size;
  
       fwrite(pkt.data, 1, pkt.size, f);
  
  
  
       av_free_packet(&amp;pkt);
  
  }
  
  return 0;
  
  }
  
  
  
  void cancle_encode(void)
  
  {
  
  fclose(f);
  
  avcodec_close(c);
  
  av_free(c);
  
  av_freep(&amp;frame->data[0]);
  
  avcodec_free_frame(&amp;frame);
  
  }
  
  
  
  
  
  int main(int argc, char **argv)
  
  {
  
  int i;
  
  
  
  
  
  char inbufout[25*50*(INBUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE)];
  
  if(init_v4l2() &lt; 0) {
  
  printf("can't open camera\n");
  
  return 0;
  
  }
  
  
  
  /* register all the codecs */
  
  avcodec_register_all();
  
  
  
  
  
  
  
  for(int j=0;j&lt;2;j++){
  
      //init_video_encode("test.mpg", AV_CODEC_ID_MPEG1VIDEO, 15);
  
      init_video_encode("test.mpg", AV_CODEC_ID_H264, 15);
  
      //for(i = 0;i&lt; 10*15;i++ ) {
  
      for(i = 0;i&lt; 25*10;i++ ) {
  
      if(video_encode(i,inbufout) &lt; 0)
  
          return 0;
  
      }
  
      cout&lt;&lt;"\n"&lt;code></iostream>