Recherche avancée

Sur d’autres sites (8112)

• avcodec/hevc_sei : remove bugus debug message

  10 mai 2017, par James Almer

  avcodec/hevc_sei : remove bugus debug message
  Also Change the active_parameter_sets function name to one more in line
  
  with the rest of the file.
  Signed-off-by : James Almer <jamrial@gmail.com>
  

  • [DH] libavcodec/hevc_sei.c

• C++ ffmpeg and SDL2 video rendering memory leak

  10 avril 2017, par kj192

  I have made a small program what plays a video in SDL2.0 and FFmpeg.
  The software does work and do it is purpose.
  I have left the software running and I have faced a huge memory consumption and started to look online what can I do against it.
  I have used the following tutorials :
  http://www.developersite.org/906-59411-FFMPEG
  http://ardrone-ailab-u-tokyo.blogspot.co.uk/2012/07/212-ardrone-20-video-decording-ffmpeg.html

  I wonder if someone can give advice what do I do wrong. I have tried valgrind but I can’t find any information. I have did try to comment out sections and what I have seen even if I’m not rendering to the display the memory usage is growing and after delete something still not been freed up :

  if (av_read_frame(pFormatCtx, &packet) >= 0) 

  the whole source code is here :
  main :

  #include 
  
  #include <ios>
  
  #include <iostream>
  
  #include <fstream>
  
  #include 
  
  #include <sdl2></sdl2>SDL.h>
  
  #include "video.h"
  
  using namespace std;
  
  
  
  void memory()
  
  {
  
  using std::ios_base;
  
  using std::ifstream;
  
  using std::string;
  
  
  
  double vm_usage     = 0.0;
  
  double resident_set = 0.0;
  
  
  
  // 'file' stat seems to give the most reliable results
  
  //
  
  ifstream stat_stream("/proc/self/stat",ios_base::in);
  
  
  
  // dummy vars for leading entries in stat that we don't care about
  
  //
  
  string pid, comm, state, ppid, pgrp, session, tty_nr;
  
  string tpgid, flags, minflt, cminflt, majflt, cmajflt;
  
  string utime, stime, cutime, cstime, priority, nice;
  
  string O, itrealvalue, starttime;
  
  
  
  // the two fields we want
  
  //
  
  unsigned long vsize;
  
  long rss;
  
  
  
  stat_stream >> pid >> comm >> state >> ppid >> pgrp >> session >> tty_nr
  
              >> tpgid >> flags >> minflt >> cminflt >> majflt >> cmajflt
  
              >> utime >> stime >> cutime >> cstime >> priority >> nice
  
              >> O >> itrealvalue >> starttime >> vsize >> rss; // don't care about the rest
  
  
  
  stat_stream.close();
  
  
  
  long page_size_kb = sysconf(_SC_PAGE_SIZE) / 1024; // in case x86-64 is configured to use 2MB pages
  
  vm_usage     = vsize / 1024.0;
  
  resident_set = rss * page_size_kb;
  
  std::cout&lt;&lt;"VM: " &lt;&lt; vm_usage &lt;&lt; " RE:"&lt;&lt; resident_set &lt;&lt; std::endl;
  
  }
  
  
  
  
  
  int main()
  
  {
  
  //This example using 1280x800 video
  
  av_register_all();
  
  if( SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO | SDL_INIT_TIMER ))
  
  {
  
      fprintf(stderr, "Could not initialize SDL - %s\n", SDL_GetError());
  
      exit(1);
  
  }
  
  SDL_Window* sdlWindow = SDL_CreateWindow("Video Window", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 1280, 800, SDL_WINDOW_OPENGL);
  
  if( !sdlWindow )
  
  {
  
      fprintf(stderr, "SDL: could not set video mode - exiting\n");
  
      exit(1);
  
  }
  
  SDL_Renderer* sdlRenderer = SDL_CreateRenderer(sdlWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC | SDL_RENDERER_TARGETTEXTURE);
  
  SDL_Texture* sdlTexture = SDL_CreateTexture(sdlRenderer, SDL_PIXELFORMAT_YV12, SDL_TEXTUREACCESS_STREAMING, 1280, 800);
  
  if(!sdlTexture)
  
  {
  
      return -1;
  
  }
  
  SDL_SetTextureBlendMode(sdlTexture,SDL_BLENDMODE_BLEND );
  
  //VIDEO RESOLUTION
  
  SDL_Rect sdlRect;
  
  sdlRect.x = 0;
  
  sdlRect.y = 0;
  
  sdlRect.w = 1280;
  
  sdlRect.h = 800;    
  
  memory();
  
  for(int i = 1; i &lt; 6; i++)
  
  {
  
      memory();   
  
      video* vid = new video("vid.mp4");  
  
      while (!vid -> getFinished())
  
      {
  
          memory();
  
          vid -> Update(sdlTexture);
  
          SDL_RenderCopy(sdlRenderer,sdlTexture,&amp;sdlRect,&amp;sdlRect);
  
          SDL_RenderPresent(sdlRenderer);
  
      }
  
      delete vid;
  
      memory();
  
  }   
  
  SDL_DestroyTexture(sdlTexture);
  
  SDL_DestroyRenderer(sdlRenderer);
  
  SDL_DestroyWindow(sdlWindow);
  
  SDL_Quit();
  
  return 0;
  
  }
  
  </fstream></iostream></ios>

  video.cpp

  #include "video.h"
  
  
  
  video::video(const std::string& name) : _finished(false)
  
  {
  
  av_register_all();
  
  pFormatCtx = NULL;
  
  pCodecCtxOrig = NULL;
  
  pCodecCtx = NULL;
  
  pCodec = NULL;
  
  pFrame = NULL;
  
  sws_ctx = NULL;
  
  if (avformat_open_input(&pFormatCtx, name.c_str(), NULL, NULL) != 0)
  
  {
  
  _finished = true; // Couldn't open file
  
  }
  
  // Retrieve stream information
  
  if (avformat_find_stream_info(pFormatCtx, NULL) < 0)
  
  {
  
  _finished = true; // Couldn't find stream information
  
  }
  
  videoStream = -1;
  
  for (i = 0; i < pFormatCtx->nb_streams; i++)
  
  {
  
      if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) 
  
      {
  
          videoStream = i;
  
          break;
  
      }
  
  }
  
  if (videoStream == -1)
  
  {
  
      _finished = true; // Didn't find a video stream
  
  }
  
  // Get a pointer to the codec context for the video stream
  
  pCodecCtxOrig = pFormatCtx->streams[videoStream]->codec;
  
  // Find the decoder for the video stream
  
  pCodec = avcodec_find_decoder(pCodecCtxOrig->codec_id);
  
  if (pCodec == NULL) 
  
  {
  
      fprintf(stderr, "Unsupported codec!\n");
  
      _finished = true; // Codec not found
  
  }
  
  pCodecCtx = avcodec_alloc_context3(pCodec);
  
  if (avcodec_copy_context(pCodecCtx, pCodecCtxOrig) != 0) 
  
  {
  
      fprintf(stderr, "Couldn't copy codec context");
  
      _finished = true; // Error copying codec context
  
  }
  
  // Open codec
  
  if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0)
  
  {
  
      _finished = true; // Could not open codec
  
  }
  
  // Allocate video frame
  
  pFrame = av_frame_alloc();
  
  sws_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height,
  
  pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height,
  
  AV_PIX_FMT_YUV420P,
  
  SWS_BILINEAR,
  
  NULL,
  
  NULL,
  
  NULL);
  
  yPlaneSz = pCodecCtx->width * pCodecCtx->height;
  
  uvPlaneSz = pCodecCtx->width * pCodecCtx->height / 4;
  
  yPlane = (Uint8*)malloc(yPlaneSz);
  
  uPlane = (Uint8*)malloc(uvPlaneSz);
  
  vPlane = (Uint8*)malloc(uvPlaneSz);
  
  if (!yPlane || !uPlane || !vPlane) 
  
  {
  
      fprintf(stderr, "Could not allocate pixel buffers - exiting\n");
  
      exit(1);
  
  }
  
  uvPitch = pCodecCtx->width / 2;
  
  }
  
  void video::Update(SDL_Texture* texture)
  
  {
  
  if (av_read_frame(pFormatCtx, &packet) >= 0) 
  
  {
  
      // Is this a packet from the video stream?
  
      if (packet.stream_index == videoStream) 
  
      {
  
          avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
  
          // Did we get a video frame?
  
          if (frameFinished) 
  
          {
  
              AVPicture pict;
  
              pict.data[0] = yPlane;
  
              pict.data[1] = uPlane;
  
              pict.data[2] = vPlane;
  
              pict.linesize[0] = pCodecCtx->width;
  
              pict.linesize[1] = uvPitch;
  
              pict.linesize[2] = uvPitch;
  
              // Convert the image into YUV format that SDL uses
  
              sws_scale(sws_ctx, (uint8_t const * const *) pFrame->data,pFrame->linesize, 0, pCodecCtx->height, pict.data,pict.linesize);
  
              SDL_UpdateYUVTexture(texture,NULL,yPlane,pCodecCtx->width,uPlane,uvPitch,vPlane,uvPitch);
  
          }
  
      }
  
      // Free the packet that was allocated by av_read_frame
  
      av_packet_unref(&packet);
  
      av_freep(&packet);
  
  }
  
  else
  
  {
  
      av_packet_unref(&packet);
  
      av_freep(&packet);
  
      _finished = true;
  
  }
  
  }
  
  bool video::getFinished()
  
  {
  
  return _finished;
  
  }
  
  video::~video()
  
  {
  
  av_packet_unref(&packet);
  
  av_freep(&packet);
  
  av_frame_free(&pFrame);
  
  av_freep(&pFrame);
  
  free(yPlane);
  
  free(uPlane);
  
  free(vPlane);
  
  // Close the codec
  
  avcodec_close(pCodecCtx);
  
  avcodec_close(pCodecCtxOrig);
  
  sws_freeContext(sws_ctx);
  
  // Close the video file
  
  for (int i = 0; i < pFormatCtx->nb_streams; i++) 
  
  {
  
      AVStream *stream = pFormatCtx->streams[i];
  
      avcodec_close(stream->codec);
  
  }
  
  avformat_close_input(&pFormatCtx);
  
  /*av_dict_free(&optionsDict);   
  
  sws_freeContext(sws_ctx);
  
  av_free_packet(&packet);
  
  av_free(pFrameYUV);
  
  av_free(buffer);
  
  avcodec_close(pCodecCtx);
  
  avformat_close_input(&pFormatCtx);*/
  
  }

  video.h
  

  #include <string>
  
  #include <sdl2></sdl2>SDL.h>
  
  #ifdef __cplusplus
  
  extern "C" {
  
  #endif
  
  #include <libavcodec></libavcodec>avcodec.h> 
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libswscale></libswscale>swscale.h>
  
  #ifdef __cplusplus 
  
  }
  
  #endif
  
  
  
  class video
  
  {
  
     private:
  
      bool _finished;
  
      AVFormatContext *pFormatCtx;
  
      int videoStream;
  
      unsigned i;
  
      AVCodecContext *pCodecCtxOrig;
  
      AVCodecContext *pCodecCtx;
  
      AVCodec *pCodec;
  
      AVFrame *pFrame;
  
      AVPacket packet;
  
      int frameFinished;
  
      struct SwsContext *sws_ctx;
  
      Uint8 *yPlane, *uPlane, *vPlane;
  
      size_t yPlaneSz, uvPlaneSz;
  
      int uvPitch;
  
     public:
  
      video(const std::string&amp; name);
  
      ~video();
  
      void Update(SDL_Texture* texture);
  
      bool getFinished();
  
  };
  
  </string>

  I’m looking forward to your answers

• Is it possible to dynamically change video encoder parameters ?

  27 mars 2017, par Andi Domi

  I would like to know if I can dynamically change video encoder parameters for a given video ?
  For example I would like to start encoding a raw video in H.264/H.265 for the first 10s in 30fps and then, while the encoder is still working, change the fps to 20 for the rest of it.
  Thanks in advance for your help.