Recherche avancée

Sur d’autres sites (8427)

• Converting cv::Mat image from BGR to YUV using ffmpeg

  10 mars 2016, par bot1131357

  I am trying to convert BGR image into YUV420P, but when I try to view each of the YUV planes separately, this is what I see.

  Shouldn’t cv::Mat::data and AVFrame::data[0] be packed in the same way ? I should be able to do a direct memcpy. Am I missing something ?

  Any ideas ?

  Mat frame;
  
  VideoCapture cap;
  
  if(!cap.open(0)){
  
      return 0;
  
  }
  
  
  
  // capture a frame
  
  cap >> frame;
  
  if( frame.empty() ) return 0;
  
  
  
  cv::Size s = frame.size();
  
  int height = s.height;
  
  int width = s.width;
  
  
  
  // Creating two frames for conversion
  
  AVFrame *pFrameYUV =av_frame_alloc();
  
  AVFrame *pFrameBGR =av_frame_alloc();
  
  
  
  // Determine required buffer size and allocate buffer for YUV frame 
  
  int numBytesYUV=av_image_get_buffer_size(AV_PIX_FMT_YUV420P, width,
  
                  height,1);          
  
  
  
  // Assign image buffers
  
  avpicture_fill((AVPicture *)pFrameBGR, frame.data,      AV_PIX_FMT_BGR24,
  
      width, height);
  
  
  
  uint8_t* bufferYUV=(uint8_t *)av_malloc(numBytesYUV*sizeof(uint8_t));
  
  avpicture_fill((AVPicture *)pFrameYUV, bufferYUV, AV_PIX_FMT_YUV420P,
  
          width, height);
  
  
  
  // Initialise Software scaling context
  
  struct SwsContext *sws_ctx = sws_getContext(width,
  
      height,
  
      AV_PIX_FMT_BGR24,
  
      width,
  
      height,
  
      AV_PIX_FMT_YUV420P,
  
      SWS_BILINEAR,
  
      NULL,
  
      NULL,
  
      NULL
  
      );
  
  
  
  // Convert the image from its BGR to YUV
  
  sws_scale(sws_ctx, (uint8_t const * const *)pFrameBGR->data,
  
        pFrameYUV->linesize, 0, height,
  
        pFrameYUV->data, pFrameYUV->linesize);
  
  
  
  
  
  
  
  // Trying to see the different planes of YUV
  
  Mat MY = Mat(height, width, CV_8UC1);
  
  memcpy(MY.data,pFrameYUV->data[0], height*width);
  
    imshow("Test1", MY); // fail
  
  Mat MU = Mat(height/2, width/2, CV_8UC1);
  
  memcpy(MU.data,pFrameYUV->data[1], height*width/4);
  
    imshow("Test2", MU); // fail
  
  Mat MV = Mat(height/2, width/2, CV_8UC1);
  
  memcpy(MV.data,pFrameYUV->data[2], height*width/4);
  
    imshow("Test3", MV); // fail  
  
  
  
  waitKey(0); // Wait for a keystroke in the window

• Memory leak when using ffmpeg

  21 janvier 2017, par se210

  I have implemented a class which spawns a thread for reading and queuing frames, and the main thread displays these frames via OpenGL. I try to free the allocated memory after binding the image data to a OpenGL texture, but it seems some memory is not freed properly. The memory usage keeps growing until the system runs out of memory and eventually the frame reader thread cannot grab new frames due to memory allocation failure. Would someone please help me on what I might have missed ? Thank you.

  This is the code for the frame reader thread :

  void AVIReader::frameReaderThreadFunc()
  
  {
  
      AVPacket packet;
  
  
  
      while (readFrames) {
  
          // Allocate necessary memory
  
          AVFrame* pFrame = av_frame_alloc();
  
          if (pFrame == nullptr)
  
          {
  
              continue;
  
          }
  
  
  
          AVFrame* pFrameRGB = av_frame_alloc();
  
          if (pFrameRGB == nullptr)
  
          {
  
              av_frame_free(&pFrame);
  
              continue;
  
          }
  
  
  
          // Determine required buffer size and allocate buffer
  
          int numBytes = avpicture_get_size(AV_PIX_FMT_RGB24, pCodecCtx->width,
  
              pCodecCtx->height);
  
          uint8_t* buffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));
  
  
  
          if (buffer == nullptr)
  
          {
  
              av_frame_free(&pFrame);
  
              av_frame_free(&pFrameRGB);
  
              continue;
  
          }
  
  
  
          // Assign appropriate parts of buffer to image planes in pFrameRGB
  
          // Note that pFrameRGB is an AVFrame, but AVFrame is a superset
  
          // of AVPicture
  
          avpicture_fill((AVPicture *)pFrameRGB, buffer, AV_PIX_FMT_RGB24,
  
              pCodecCtx->width, pCodecCtx->height);
  
  
  
          if (av_read_frame(pFormatCtx, &packet) >= 0) {
  
              // Is this a packet from the video stream?
  
              if (packet.stream_index == videoStream) {
  
                  // Decode video frame
  
                  int frameFinished;
  
                  avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
  
  
  
                  if (frameFinished) {
  
                      // Convert the image from its native format to RGB
  
                      sws_scale(sws_ctx, (uint8_t const * const *)pFrame->data,
  
                          pFrame->linesize, 0, pCodecCtx->height,
  
                          pFrameRGB->data, pFrameRGB->linesize);
  
  
  
                      VideoFrame vf;
  
                      vf.frame = pFrameRGB;
  
                      vf.pts = av_frame_get_best_effort_timestamp(pFrame) * time_base;
  
                      frameQueue.enqueue(vf);
  
  
  
                      av_frame_unref(pFrame);
  
                      av_frame_free(&pFrame);
  
                  }
  
              }
  
              //av_packet_unref(&packet);
  
              av_free_packet(&packet);
  
          }
  
      }
  
  }

  This is the code that grabs the queued frames and binds it to an OpenGL texture. I explicitly save the previous frame until I switch it out with the next frame. Otherwise, it seems to cause a segfault.

  void AVIReader::GrabAVIFrame()
  
  {
  
      if (curFrame.pts >= clock_pts)
  
      {
  
          return;
  
      }
  
  
  
      if (frameQueue.empty())
  
          return;
  
  
  
      // Get a packet from the queue
  
      VideoFrame videoFrame = frameQueue.top();
  
      while (!frameQueue.empty() && frameQueue.top().pts < clock_pts)
  
      {
  
          videoFrame = frameQueue.dequeue();
  
      }
  
  
  
      glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, videoFrame.frame->data[0]);
  
  
  
      // release previous frame
  
      if (curFrame.frame)
  
      {
  
          av_free(curFrame.frame->data[0]);
  
      }
  
      av_frame_unref(curFrame.frame);
  
  
  
      // set current frame to new frame
  
      curFrame = videoFrame;
  
  }

  The frameQueue is a thread-safe priority queue that holds VideoFrame defined as :

  class VideoFrame {
  
  public:
  
      AVFrame* frame;
  
      double pts;
  
  };

  Update : There was a silly error in the ordering of setting current frame to new frame. I forgot to switch it back after trying some things out. I also incorporated @ivan_onys’s suggestion, but that does not seem to fix the problem.

  ---

  Update 2 : I adopted @Al Bundy’s suggestion to release pFrame and packet unconditionally, but the issue still persists.

  Since buffer is what contains the actual image data which needs to be used in glTexSubImage2D(), I cannot release it until I am done displaying it on the screen (otherwise I get a segfault). avpicture_fill() assigns frame->data[0] = buffer, so I think calling av_free(curFrame.frame->data[0]) ; on the previous frame after texture mapping the new frame should release the allocated buffer.

  Here is the updated frame reader thread code :

  void AVIReader::frameReaderThreadFunc()
  
  {
  
      AVPacket packet;
  
  
  
      while (readFrames) {
  
          // Allocate necessary memory
  
          AVFrame* pFrame = av_frame_alloc();
  
          if (pFrame == nullptr)
  
          {
  
              continue;
  
          }
  
  
  
          AVFrame* pFrameRGB = av_frame_alloc();
  
          if (pFrameRGB == nullptr)
  
          {
  
              av_frame_free(&pFrame);
  
              continue;
  
          }
  
  
  
          // Determine required buffer size and allocate buffer
  
          int numBytes = avpicture_get_size(AV_PIX_FMT_RGB24, pCodecCtx->width,
  
              pCodecCtx->height);
  
          uint8_t* buffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));
  
  
  
          if (buffer == nullptr)
  
          {
  
              av_frame_free(&pFrame);
  
              av_frame_free(&pFrameRGB);
  
              continue;
  
          }
  
  
  
          // Assign appropriate parts of buffer to image planes in pFrameRGB
  
          // Note that pFrameRGB is an AVFrame, but AVFrame is a superset
  
          // of AVPicture
  
          avpicture_fill((AVPicture *)pFrameRGB, buffer, AV_PIX_FMT_RGB24,
  
              pCodecCtx->width, pCodecCtx->height);
  
  
  
          if (av_read_frame(pFormatCtx, &packet) >= 0) {
  
              // Is this a packet from the video stream?
  
              if (packet.stream_index == videoStream) {
  
                  // Decode video frame
  
                  int frameFinished;
  
                  avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
  
  
  
                  if (frameFinished) {
  
                      // Convert the image from its native format to RGB
  
                      sws_scale(sws_ctx, (uint8_t const * const *)pFrame->data,
  
                          pFrame->linesize, 0, pCodecCtx->height,
  
                          pFrameRGB->data, pFrameRGB->linesize);
  
  
  
                      VideoFrame vf;
  
                      vf.frame = pFrameRGB;
  
                      vf.pts = av_frame_get_best_effort_timestamp(pFrame) * time_base;
  
                      frameQueue.enqueue(vf);
  
                  }
  
              }
  
          }
  
          av_frame_unref(pFrame);
  
          av_frame_free(&pFrame);
  
          av_packet_unref(&packet);
  
          av_free_packet(&packet);
  
      }
  
  }

  ---

  Solved : It turned out the leaks were happening when the packet was from a non-video stream (e.g. audio). I also needed to free resources on frames that are skipped in the while-loop of GrabAVIFrame().

• FFmpeg : Jpeg file to AVFrame

  24 octobre 2012, par darja

  I need to join several jpg files into video using FFmpeg library. But I have a problem with reading this files. Here is a function which reads image file and makes AVFrame :

  AVFrame* OpenImage(const char* imageFileName)
  
  {
  
      AVFormatContext *pFormatCtx;
  
  
  
      if(av_open_input_file(&pFormatCtx, imageFileName, NULL, 0, NULL)!=0)
  
      {
  
          printf("Can't open image file '%s'\n", imageFileName);
  
          return NULL;
  
      }       
  
  
  
      dump_format(pFormatCtx, 0, imageFileName, false);
  
  
  
      AVCodecContext *pCodecCtx;
  
  
  
      pCodecCtx = pFormatCtx->streams[0]->codec;
  
      pCodecCtx->width = W_VIDEO;
  
      pCodecCtx->height = H_VIDEO;
  
      pCodecCtx->pix_fmt = PIX_FMT_YUV420P;
  
  
  
      // Find the decoder for the video stream
  
      AVCodec *pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
  
      if (!pCodec)
  
      {
  
          printf("Codec not found\n");
  
          return NULL;
  
      }
  
  
  
      // Open codec
  
      if(avcodec_open(pCodecCtx, pCodec)<0)
  
      {
  
          printf("Could not open codec\n");
  
          return NULL;
  
      }
  
  
  
      // 
  
      AVFrame *pFrame;
  
  
  
      pFrame = avcodec_alloc_frame();
  
  
  
      if (!pFrame)
  
      {
  
          printf("Can't allocate memory for AVFrame\n");
  
          return NULL;
  
      }
  
  
  
      int frameFinished;
  
      int numBytes;
  
  
  
      // Determine required buffer size and allocate buffer
  
      numBytes = avpicture_get_size(PIX_FMT_YUVJ420P, pCodecCtx->width, pCodecCtx->height);
  
      uint8_t *buffer = (uint8_t *) av_malloc(numBytes * sizeof(uint8_t));
  
  
  
      avpicture_fill((AVPicture *) pFrame, buffer, PIX_FMT_YUVJ420P, pCodecCtx->width, pCodecCtx->height);
  
  
  
      // Read frame
  
  
  
      AVPacket packet;
  
  
  
      int framesNumber = 0;
  
      while (av_read_frame(pFormatCtx, &packet) >= 0)
  
      {
  
          if(packet.stream_index != 0)
  
              continue;
  
  
  
          int ret = avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
  
          if (ret > 0)
  
          {
  
              printf("Frame is decoded, size %d\n", ret);
  
              pFrame->quality = 4;
  
              return pFrame;
  
          }
  
          else
  
              printf("Error [%d] while decoding frame: %s\n", ret, strerror(AVERROR(ret)));
  
      }
  
  }

  This causes no error but creates only black frame, no image. What is wrong ?