Recherche avancée

Sur d’autres sites (10494)

• Setting ffmpeg properly in ubuntu 16.04

  22 août 2017, par pro neon

  I am following this website for ffmpeg tutorial : http://dranger.com
  I tried to compile the programs after setting up ffmpeg in ubuntu by looking on some online videos but none of them worked. Some times GCC gives me undefined reference error and sometimes header not found error. I looked on some of the answers on SO that said that we need to do some change in the code as the new api is not backwards compatible but still GCC gives me undefined reference error.
  Here is the code that I am trying to compile :

      // tutorial01.c
  
  // Code based on a tutorial by Martin Bohme (boehme@inb.uni-luebeckREMOVETHIS.de)
  
  // Tested on Gentoo, CVS version 5/01/07 compiled with GCC 4.1.1
  
  // With updates from https://github.com/chelyaev/ffmpeg-tutorial
  
  // Updates tested on:
  
  // LAVC 54.59.100, LAVF 54.29.104, LSWS 2.1.101 
  
  // on GCC 4.7.2 in Debian February 2015
  
  
  
  // A small sample program that shows how to use libavformat and libavcodec to
  
  // read video from a file.
  
  //
  
  // Use
  
  //
  
  // gcc -o tutorial01 tutorial01.c -lavformat -lavcodec -lswscale -lz
  
  //
  
  // to build (assuming libavformat and libavcodec are correctly installed
  
  // your system).
  
  //
  
  // Run using
  
  //
  
  // tutorial01 myvideofile.mpg
  
  //
  
  // to write the first five frames from "myvideofile.mpg" to disk in PPM
  
  // format.
  
  
  
  #include <libavcodec></libavcodec>avcodec.h>
  
  #include <libavformat></libavformat>avformat.h>
  
  #include <libswscale></libswscale>swscale.h>
  
  
  
  #include 
  
  
  
  // compatibility with newer API
  
  #if LIBAVCODEC_VERSION_INT &lt; AV_VERSION_INT(55,28,1)
  
  #define av_frame_alloc avcodec_alloc_frame
  
  #define av_frame_free avcodec_free_frame
  
  #endif
  
  
  
  void SaveFrame(AVFrame *pFrame, int width, int height, int iFrame) {
  
    FILE *pFile;
  
    char szFilename[32];
  
    int  y;
  
  
  
    // Open file
  
    sprintf(szFilename, "frame%d.ppm", iFrame);
  
    pFile=fopen(szFilename, "wb");
  
    if(pFile==NULL)
  
      return;
  
  
  
    // Write header
  
    fprintf(pFile, "P6\n%d %d\n255\n", width, height);
  
  
  
    // Write pixel data
  
    for(y=0; ydata[0]+y*pFrame->linesize[0], 1, width*3, pFile);
  
  
  
    // Close file
  
    fclose(pFile);
  
  }
  
  
  
  int main(int argc, char *argv[]) {
  
    // Initalizing these to NULL prevents segfaults!
  
    AVFormatContext   *pFormatCtx = NULL;
  
    int               i, videoStream;
  
    AVCodecContext    *pCodecCtxOrig = NULL;
  
    AVCodecContext    *pCodecCtx = NULL;
  
    AVCodec           *pCodec = NULL;
  
    AVFrame           *pFrame = NULL;
  
    AVFrame           *pFrameRGB = NULL;
  
    AVPacket          packet;
  
    int               frameFinished;
  
    int               numBytes;
  
    uint8_t           *buffer = NULL;
  
    struct SwsContext *sws_ctx = NULL;
  
  
  
    if(argc &lt; 2) {
  
      printf("Please provide a movie file\n");
  
      return -1;
  
    }
  
    // Register all formats and codecs
  
    av_register_all();
  
  
  
    // Open video file
  
    if(avformat_open_input(&amp;pFormatCtx, argv[1], NULL, NULL)!=0)
  
      return -1; // Couldn't open file
  
  
  
    // Retrieve stream information
  
    if(avformat_find_stream_info(pFormatCtx, NULL)&lt;0)
  
      return -1; // Couldn't find stream information
  
  
  
    // Dump information about file onto standard error
  
    av_dump_format(pFormatCtx, 0, argv[1], 0);
  
  
  
    // Find the first video stream
  
    videoStream=-1;
  
    for(i=0; inb_streams; i++)
  
      if(pFormatCtx->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO) {
  
        videoStream=i;
  
        break;
  
      }
  
    if(videoStream==-1)
  
      return -1; // 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");
  
      return -1; // Codec not found
  
    }
  
    // Copy context
  
    pCodecCtx = avcodec_alloc_context3(pCodec);
  
    if(avcodec_copy_context(pCodecCtx, pCodecCtxOrig) != 0) {
  
      fprintf(stderr, "Couldn't copy codec context");
  
      return -1; // Error copying codec context
  
    }
  
  
  
    // Open codec
  
    if(avcodec_open2(pCodecCtx, pCodec, NULL)&lt;0)
  
      return -1; // Could not open codec
  
  
  
    // Allocate video frame
  
    pFrame=av_frame_alloc();
  
  
  
    // Allocate an AVFrame structure
  
    pFrameRGB=av_frame_alloc();
  
    if(pFrameRGB==NULL)
  
      return -1;
  
  
  
    // Determine required buffer size and allocate buffer
  
    numBytes=avpicture_get_size(PIX_FMT_RGB24, pCodecCtx->width,
  
                    pCodecCtx->height);
  
    buffer=(uint8_t *)av_malloc(numBytes*sizeof(uint8_t));
  
  
  
    // 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, PIX_FMT_RGB24,
  
           pCodecCtx->width, pCodecCtx->height);
  
  
  
    // initialize SWS context for software scaling
  
    sws_ctx = sws_getContext(pCodecCtx->width,
  
                 pCodecCtx->height,
  
                 pCodecCtx->pix_fmt,
  
                 pCodecCtx->width,
  
                 pCodecCtx->height,
  
                 PIX_FMT_RGB24,
  
                 SWS_BILINEAR,
  
                 NULL,
  
                 NULL,
  
                 NULL
  
                 );
  
  
  
    // Read frames and save first five frames to disk
  
    i=0;
  
    while(av_read_frame(pFormatCtx, &amp;packet)>=0) {
  
      // Is this a packet from the video stream?
  
      if(packet.stream_index==videoStream) {
  
        // Decode video frame
  
        avcodec_decode_video2(pCodecCtx, pFrame, &amp;frameFinished, &amp;packet);
  
  
  
        // Did we get a video frame?
  
        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);
  
  
  
      // Save the frame to disk
  
      if(++i&lt;=5)
  
        SaveFrame(pFrameRGB, pCodecCtx->width, pCodecCtx->height, 
  
              i);
  
        }
  
      }
  
  
  
      // Free the packet that was allocated by av_read_frame
  
      av_free_packet(&amp;packet);
  
    }
  
  
  
    // Free the RGB image
  
    av_free(buffer);
  
    av_frame_free(&amp;pFrameRGB);
  
  
  
    // Free the YUV frame
  
    av_frame_free(&amp;pFrame);
  
  
  
    // Close the codecs
  
    avcodec_close(pCodecCtx);
  
    avcodec_close(pCodecCtxOrig);
  
  
  
    // Close the video file
  
    avformat_close_input(&amp;pFormatCtx);
  
  
  
    return 0;
  
  }

  This is the command I use to compile :

  gcc -o tutorial01 tutorial01.c -lavformat -lavcodec -lswscale -lz

• FFmpeg : Jpeg file to AVFrame

  1er janvier 2020, 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 ?

• AV_PIX_FMT_YUVJ422P to jpeg conversion

  4 mars 2019, par user3743908

  i am able to convert image from AV_PIX_FMT_YUVJ422P to jpeg format (below Code) but the resultant image having green shade on complete bottom half plz suggest where i am doing wrong.
  Following step i have taken

  1. Initially i have AV_PIX_FMT_UYVY422 image from camera, i have convert it in AV_PIX_FMT_YUVJ422P format and able to see this image on http://rawpixels.net/ the parameters shown by website is size 2448X2050, Bpp1= 8,Bpp2 = 8 and Bpp3 = 8,alignment 1, SubSampling H =2, and SubSampling V = 1, format : YUV422P
     so input image is Correct AV_PIX_FMT_YUVJ422P format. & also able to see on "YUV image viewer Software" using YUV422 format.

  2. Now i am trying to convert it in jpeg format using below Code and attached is the resultant Image having green shade on complete bottom half.

         AVFormatContext*    pFormatCtx;
     
         AVOutputFormat*     fmt;
     
         AVStream*           video_st;
     
         AVCodecContext*     pCodecCtx;
     
         AVCodec*            pCodec;
     
     
     
         uint8_t*            picture_buf;
     
         AVFrame*            picture;
     
         AVPacket            pkt;
     
         int                 y_size;
     
         int                 size;
     
         int                 got_picture=0;  
     
         int                 ret=0;
     
     
     
     int main( int argc, char* argv[] )
     
     {
     
     
     
         FILE *in_file                       =   NULL;   
     
         unsigned int        in_width        =   2448;    
     
         unsigned int        in_height       =   2050;   
     
         const char* out_file                =   "encoded_pic.jpg";    
     
     
     
     
     
             in_file =   fopen("c:\\test_Planar.yuv","rb");
     
             if(in_file == NULL) { printf("\n\tFile Opening error...!!"); exit(1); }
     
             else printf("\n\tYUV File Open Sucessfully...!!\n\n");
     
     
     
             av_register_all();  // Loads the whole database of available codecs and formats.
     
     
     
             pFormatCtx          =   avformat_alloc_context();           
     
             fmt             =   NULL;
     
             fmt             =   av_guess_format("mjpeg",NULL,NULL);
     
             pFormatCtx->oformat     =   fmt;
     
     
     
     //------Output URL-------------------------
     
     if (avio_open(&pFormatCtx->pb,out_file, AVIO_FLAG_READ_WRITE) < 0)
     
     {
     
         printf("Couldn't open output file.");
     
         return -1;
     
     }
     
     
     
     video_st = avformat_new_stream(pFormatCtx, 0);    
     
     if (video_st==NULL)        return -1;
     
     
     
     
     
     pCodecCtx               =   video_st->codec;
     
     pCodecCtx->codec_id     =   fmt->video_codec;
     
     pCodecCtx->codec_type   =   AVMEDIA_TYPE_VIDEO;
     
     pCodecCtx->pix_fmt      =   AV_PIX_FMT_YUVJ422P;
     
     
     
     //--------------------------MY SOURCE PIXEL FORMAT--------------
     
     
     
     pCodecCtx->width        =   in_width;
     
     pCodecCtx->height       =   in_height;
     
     
     
     pCodecCtx->time_base.num = 1;
     
     pCodecCtx->time_base.den = 1;//25;
     
     
     
     //Output some information
     
     av_dump_format(pFormatCtx, 0, out_file, 1);
     
     
     
     // Determine if desired video encoder is installed 
     
     pCodec = avcodec_find_encoder(pCodecCtx->codec_id);
     
     
     
     if (!pCodec)
     
     {
     
         printf("Codec not found.");
     
         return -1;
     
     }
     
     
     
     printf("\nCodec Identified done\n");
     
     
     
     if (avcodec_open2(pCodecCtx, pCodec,NULL) < 0){
     
         printf("Could not open codec.\n");
     
         return -1;
     
     }
     
     picture     =   av_frame_alloc();
     
     size            =   avpicture_get_size(pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);
     
     picture_buf     =   (uint8_t *)av_malloc(size);
     
     if (!picture_buf)    return -1;
     
     
     
     avpicture_fill((AVPicture *)picture, picture_buf, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);
     
     
     
     printf("\t\nWrite Header..");
     
     avformat_write_header(pFormatCtx,NULL);
     
     y_size = pCodecCtx->width * pCodecCtx->height;
     
     av_new_packet(&pkt,y_size*3);
     
     
     
     
     
     //Read YUV
     
     if (fread(picture_buf, 1, y_size*3/2, in_file) <=0)
     
     {
     
         printf("Could not read input file.");
     
         return -1;
     
     }
     
      //--------------------------------------------input image format UYVY
     
     picture->data[0] = picture_buf;             // Y
     
     picture->data[1] = picture_buf+ y_size;         // U
     
     picture->data[2] = picture_buf+ y_size*5/4;     // V
     
     //-----------------------------------------------
     
     
     
     printf("\t\n Encode the image..\n");
     
     ret = avcodec_encode_video2(pCodecCtx, &pkt,picture, &got_picture);
     
     if(ret < 0)
     
     {
     
         printf("Encode Error.\n");
     
         return -1;
     
     }
     
     
     
     if (got_picture==1)
     
     {
     
         pkt.stream_index = video_st->index;
     
         ret = av_write_frame(pFormatCtx, &pkt);
     
     }
     
     
     
     av_free_packet(&pkt);
     
     //Write Trailer
     
     av_write_trailer(pFormatCtx);    
     
     printf("Encode Successful.\n");
     
     
     
     if (video_st)
     
     {
     
         avcodec_close(video_st->codec);
     
         av_free(picture);
     
         av_free(picture_buf);
     
     }
     
     
     
     avio_close(pFormatCtx->pb);
     
     avformat_free_context(pFormatCtx);    
     
     
     
         fclose(in_file);
     
         printf("\n\tYUV File Close Sucessfully...!!");    
     
     }

  Resultant output jpeg encoded image from yuvj422p image having green shade