title: FFmpeg H264 parsing
body: <p>I am using FFmpeg to decoding H.264 video, for the following program:</p>
  
  <pre><code>    #include &lt;stdlib.h&gt;
      #include &lt;stdio.h&gt;
      #include &lt;string.h&gt;
      #include &lt;signal.h&gt;
  
      #include &lt;sys/time.h&gt;
      #include &lt;time.h&gt;
  
  #include &lt;libavcodec/avcodec.h&gt;
  #include &lt;libavutil/mathematics.h&gt;
  
  #include &lt;SDL/SDL.h&gt;
  
  void sigint_handler(int signal) {
      printf("\n");
      exit(0);
  }
  
  const char *window_title;
  SDL_Surface *screen;
  SDL_Overlay *yuv_overlay;
  
  #define INBUF_SIZE 80000
  
  /*
   * Video decoding example
   */
  
  static long get_time_diff(struct timeval time_now) {
     struct timeval time_now2;
     gettimeofday(&amp;time_now2,0);
     return time_now2.tv_sec*1.e6 - time_now.tv_sec*1.e6 + time_now2.tv_usec - time_now.tv_usec;
  }
  
  int video_open(AVCodecContext *avctx, const char *filename){
      int flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
      int w,h;
  
      flags |= SDL_RESIZABLE;
  
      if (avctx-&gt;width){
          w = avctx-&gt;width;
          h = avctx-&gt;height;
      } else {
          w = 640;
          h = 480;
      }
  
      if(SDL_Init(SDL_INIT_VIDEO) &lt; 0) {
      fprintf(stderr, "SDL_INIT_VIDEO failed!\n");
      exit(1);
      }
  
      screen = SDL_SetVideoMode(w, h, 0, flags);
  
      if (!screen) {
          fprintf(stderr, "SDL: could not set video mode - exiting\n");
          return -1;
      }
      if (!window_title)
          window_title = filename;
      SDL_WM_SetCaption(window_title, window_title);
  
      yuv_overlay = SDL_CreateYUVOverlay(w, h, SDL_YV12_OVERLAY, screen);
  
      if (yuv_overlay-&gt;hw_overlay) {
      fprintf(stderr, "Using hardware overlay!\n");
      }
  
      return 0;
  }
  
  int main(int argc, char **argv) {
      AVCodec *codec;
      AVCodecContext *c= NULL;
      AVCodecParserContext *parser = NULL;
      int frame, got_picture, len2, len;
      const char *filename;
      FILE *f;
      AVFrame *picture;
      char *arghwtf = malloc(INBUF_SIZE);
      char *luma = NULL;
      char *chroma = NULL;
      int i=0;
      uint64_t in_len;
      int pts, dts;
      struct timeval t;
      float inv_fps = 1e6/23.98;
      AVPacket avpkt;
      SDL_Rect rect;
  
  
      /* register all the codecs */
      avcodec_register_all();
  
      filename = argv[1];
  
      av_init_packet(&amp;avpkt);
  
      printf("Decoding file %s...\n", filename);
  
      /* find the H.264 video decoder */
      codec = avcodec_find_decoder(CODEC_ID_H264);
      if (!codec) {
          fprintf(stderr, "codec not found\n");
          exit(1);
      }
  
      c = avcodec_alloc_context3(codec);
      picture = avcodec_alloc_frame();
  
      c-&gt;skip_loop_filter = 48; // skiploopfilter=all
  
      if (avcodec_open(c, codec) &lt; 0) {
          fprintf(stderr, "could not open codec\n");
          exit(1);
      }
  
      /* the codec gives us the frame size, in samples */
      parser = av_parser_init(c-&gt;codec_id);
      parser-&gt;flags |= PARSER_FLAG_ONCE;
  
      f = fopen(filename, "rb");
      if (!f) {
          fprintf(stderr, "could not open %s\n", filename);
          exit(1);
      }
  
      frame = 0;
      gettimeofday(&amp;t, 0);
      if(fread(arghwtf, 1, INBUF_SIZE, f) == 0) {
      exit(1);
      }
      in_len = 80000;
          while (in_len &gt; 0 &amp;&amp; !feof(f)) {
          len = av_parser_parse2(parser, c, &amp;avpkt.data, &amp;avpkt.size, arghwtf, in_len,
                                     pts, dts, AV_NOPTS_VALUE);
  
              len2 = avcodec_decode_video2(c, picture, &amp;got_picture, &amp;avpkt);
              if (len2 &lt; 0) {
                  fprintf(stderr, "Error while decoding frame %d\n", frame);
                  exit(1);
              }
              if (got_picture) {
          if(!screen) {
              video_open(c, filename);
  
              rect.x = 0;
              rect.y = 0;
              rect.w = c-&gt;width;
              rect.h = c-&gt;height;
              inv_fps = av_q2d(c-&gt;time_base);
              fprintf(stderr, "w:%i h:%i\n", rect.w, rect.h);
  
              luma = malloc(c-&gt;width*c-&gt;height);
              chroma = malloc(c-&gt;width*c-&gt;height/4);
  
              SDL_DisplayYUVOverlay(yuv_overlay, &amp;rect);
  
              signal(SIGINT, sigint_handler);
          }
                  fprintf(stderr, "\rDisplaying %c:frame %3d (%02d:%02d)...", av_get_pict_type_char(picture-&gt;pict_type), frame, frame/1440, (frame/24)%60);
                  fflush(stderr);
  
          SDL_LockYUVOverlay(yuv_overlay);
  
                  for(i=0;i&lt;c-&gt;height;i++) {
                    memcpy(luma + i * c-&gt;width, picture-&gt;data[0] + i * picture-&gt;linesize[0], c-&gt;width);
                  }
          memcpy(yuv_overlay-&gt;pixels[0], luma, c-&gt;width * c-&gt;height);
                  for(i=0;i&lt;c-&gt;height/2;i++) {
                    memcpy(chroma + i * c-&gt;width/2, picture-&gt;data[2] + i * picture-&gt;linesize[2], c-&gt;width/2);
                  }
          memcpy(yuv_overlay-&gt;pixels[1], chroma, c-&gt;width * c-&gt;height / 4);
                  for(i=0;i&lt;c-&gt;height/2;i++) {
                    memcpy(chroma + i * c-&gt;width/2, picture-&gt;data[1] + i * picture-&gt;linesize[1], c-&gt;width/2);
                  }
          memcpy(yuv_overlay-&gt;pixels[2], chroma, c-&gt;width * c-&gt;height / 4);
  
          SDL_UnlockYUVOverlay(yuv_overlay);
          SDL_DisplayYUVOverlay(yuv_overlay, &amp;rect);
  
          while(get_time_diff(t) &lt; inv_fps) {
              sleep(1000);
          }
                  frame++;
          gettimeofday(&amp;t, 0);
              }
          memcpy(arghwtf, arghwtf + len, 80000-len);
          fread(arghwtf + 80000 - len, 1, len, f);
          }
  
      /* some codecs, such as MPEG, transmit the I and P frame with a
         latency of one frame. You must do the following to have a
         chance to get the last frame of the video */
      avpkt.data = NULL;
      avpkt.size = 0;
      len = avcodec_decode_video2(c, picture, &amp;got_picture, &amp;avpkt);
      if (got_picture) {
          printf("saving last frame %3d\n", frame);
          fflush(stdout);
  
      /* Display last frame here, same code as in the decoding loop above. */
  
          frame++;
      }
  
      fclose(f);
  
      avcodec_close(c);
      av_free(c);
      av_free(picture);
      printf("\n");
  }
  </code></pre>
  
  <p>It gives error:</p>
  
  <pre><code>||=== H264_decoding, Debug ===|
  /home/yoohoo/codeblocks/Real-time video streaming/H264_decoding/main.cpp||In function ‘int main(int, char**)’:|
  /home/yoohoo/codeblocks/Real-time video streaming/H264_decoding/main.cpp|107|error: invalid conversion from ‘void*’ to ‘char*’ [-fpermissive]|
  /home/yoohoo/codeblocks/Real-time video streaming/H264_decoding/main.cpp|136|warning: ‘AVFrame* avcodec_alloc_frame()’ is deprecated (declared at /home/yoohoo/ffmpeg_build/include/libavcodec/avcodec.h:3629) [-Wdeprecated-declarations]|
  /home/yoohoo/codeblocks/Real-time video streaming/H264_decoding/main.cpp|136|warning: ‘AVFrame* avcodec_alloc_frame()’ is deprecated (declared at /home/yoohoo/ffmpeg_build/include/libavcodec/avcodec.h:3629) [-Wdeprecated-declarations]|
  /home/yoohoo/codeblocks/Real-time video streaming/H264_decoding/main.cpp|138|error: invalid conversion from ‘int’ to ‘AVDiscard’ [-fpermissive]|
  /home/yoohoo/codeblocks/Real-time video streaming/H264_decoding/main.cpp|140|error: ‘avcodec_open’ was not declared in this scope|
  /home/yoohoo/codeblocks/Real-time video streaming/H264_decoding/main.cpp|163|error: invalid conversion from ‘char*’ to ‘const uint8_t* {aka const unsigned char*}’ [-fpermissive]|
  /home/yoohoo/ffmpeg_build/include/libavcodec/avcodec.h|4465|error:   initializing argument 5 of ‘int av_parser_parse2(AVCodecParserContext*, AVCodecContext*, uint8_t**, int*, const uint8_t*, int, int64_t, int64_t, int64_t)’ [-fpermissive]|
  /home/yoohoo/codeblocks/Real-time video streaming/H264_decoding/main.cpp|181|error: invalid conversion from ‘void*’ to ‘char*’ [-fpermissive]|
  /home/yoohoo/codeblocks/Real-time video streaming/H264_decoding/main.cpp|182|error: invalid conversion from ‘void*’ to ‘char*’ [-fpermissive]|
  /home/yoohoo/codeblocks/Real-time video streaming/H264_decoding/main.cpp|188|error: ‘av_get_pict_type_char’ was not declared in this scope|
  /home/yoohoo/codeblocks/Real-time video streaming/H264_decoding/main.cpp|210|error: ‘sleep’ was not declared in this scope|
  ||=== Build finished: 9 errors, 2 warnings ===|
  </code></pre>
  
  <p>I am wondering it is an incompatible problem due to I move this C program to C++, but I finally need to use it in C++. How to solve these invalid conversion problem? Thanks in advance!</p>