title: using ffmpeg headers with a c program
body: <p>i'm trying to learn ffmpeg from drangers guide (for school), i have a mac so the first thing i did was to use Macports and get ffmpeg and sdl...</p>
  
  <p>now when i'm tried to compile drangers code, the compiler didnt recognize the headers...
  so i used -I on gnu when compiling, and also gave the "whole/path/name..." to the headers, 
  but i always get an error on some header missing...</p>
  
  <p>below i will put the code with my corrections.</p>
  
  <p>i also tried including all the headers that i get an error about but there is always another header the compiler can't find</p>
  
  <p>i tried both gnu (on console) and on xcode.</p>
  
  <pre><code>// 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
  
  // 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 -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 "/opt/local/include/libavcodec/avcodec.h"
  #include "/opt/local/include/libavformat/avformat.h"
  
  #include &lt;stdio.h&gt;
  
  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; y&lt;height; y++)
      fwrite(pFrame-&gt;data[0]+y*pFrame-&gt;linesize[0], 1, width*3, pFile);
  
    // Close file
    fclose(pFile);
  }
  
  int main(int argc, char *argv[]) {
    AVFormatContext *pFormatCtx;
    int             i, videoStream;
    AVCodecContext  *pCodecCtx;
    AVCodec         *pCodec;
    AVFrame         *pFrame; 
    AVFrame         *pFrameRGB;
    AVPacket        packet;
    int             frameFinished;
    int             numBytes;
    uint8_t         *buffer;
  
    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(av_open_input_file(&amp;pFormatCtx, argv[1], NULL, 0, NULL)!=0)
      return -1; // Couldn't open file
  
    // Retrieve stream information
    if(av_find_stream_info(pFormatCtx)&lt;0)
      return -1; // Couldn't find stream information
  
    // Dump information about file onto standard error
    dump_format(pFormatCtx, 0, argv[1], 0);
  
    // Find the first video stream
    videoStream=-1;
    for(i=0; i&lt;pFormatCtx-&gt;nb_streams; i++)
      if(pFormatCtx-&gt;streams[i]-&gt;codec-&gt;codec_type==CODEC_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
    pCodecCtx=pFormatCtx-&gt;streams[videoStream]-&gt;codec;
  
    // Find the decoder for the video stream
    pCodec=avcodec_find_decoder(pCodecCtx-&gt;codec_id);
    if(pCodec==NULL) {
      fprintf(stderr, "Unsupported codec!\n");
      return -1; // Codec not found
    }
    // Open codec
    if(avcodec_open(pCodecCtx, pCodec)&lt;0)
      return -1; // Could not open codec
  
    // Allocate video frame
    pFrame=avcodec_alloc_frame();
  
    // Allocate an AVFrame structure
    pFrameRGB=avcodec_alloc_frame();
    if(pFrameRGB==NULL)
      return -1;
  
    // Determine required buffer size and allocate buffer
    numBytes=avpicture_get_size(PIX_FMT_RGB24, pCodecCtx-&gt;width,
                    pCodecCtx-&gt;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-&gt;width, pCodecCtx-&gt;height);
  
    // Read frames and save first five frames to disk
    i=0;
    while(av_read_frame(pFormatCtx, &amp;packet)&gt;=0) {
      // Is this a packet from the video stream?
      if(packet.stream_index==videoStream) {
        // Decode video frame
        avcodec_decode_video(pCodecCtx, pFrame, &amp;frameFinished, 
                 packet.data, packet.size);
  
        // Did we get a video frame?
        if(frameFinished) {
      // Convert the image from its native format to RGB
      img_convert((AVPicture *)pFrameRGB, PIX_FMT_RGB24, 
                      (AVPicture*)pFrame, pCodecCtx-&gt;pix_fmt, pCodecCtx-&gt;width, 
                      pCodecCtx-&gt;height);
  
      // Save the frame to disk
      if(++i&lt;=5)
        SaveFrame(pFrameRGB, pCodecCtx-&gt;width, pCodecCtx-&gt;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_free(pFrameRGB);
  
    // Free the YUV frame
    av_free(pFrame);
  
    // Close the codec
    avcodec_close(pCodecCtx);
  
    // Close the video file
    av_close_input_file(pFormatCtx);
  
    return 0;
  }
  </code></pre>