// avcodec.cpp

// Pequeño progroma que muestra el uso de libavcodec y libavformat
// para leer video de un archivo
//
// para compilar
//
// g++ -o avcodec avcodec.cpp -lavformat -lavcodec -lz
//
// las librerias deben estar instaladas para compilar
// son parte del paquete ffmepg-dev
//
// uso: avcodec video.ext
//
// ext: puede ser cualquier formato de video soportado por las librerias
// los mas comunes .avi o .mpg

#include <ffmpeg/avcodec.h>
#include <ffmpeg/avformat.h>

#include <stdio.h>

bool GetNextFrame(AVFormatContext *pFormatCtx, AVCodecContext *pCodecCtx, 
    int videoStream, AVFrame *pFrame)
{
    static AVPacket packet;
    static int      bytesRemaining=0;
    static uint8_t  *rawData;
    static bool     fFirstTime=true;
    int             bytesDecoded;
    int             frameFinished;

    // La priemra vez que se llama packet.data=NULL para indicar que se
    // necesita liberar
    if(fFirstTime)
    {
        fFirstTime=false;
        packet.data=NULL;
    }

    // Decodificar paquetes hasta completar un frame
    while(true)
    {
        // trabajar en el paquete hasta completarlo
        while(bytesRemaining > 0)
        {
            // decodificar el siguiente grupo de datos
            bytesDecoded=avcodec_decode_video(pCodecCtx, pFrame,
                &frameFinished, rawData, bytesRemaining);

            if(bytesDecoded < 0)
            {
                fprintf(stderr, "Error while decoding frame\n");
                return false;
            }

            bytesRemaining-=bytesDecoded;
            rawData+=bytesDecoded;

            // acuando se complete el frame se peude retornar
            if(frameFinished)
                return true;
        }

        // leer el siguiente paquete omitiendo los que no corresponden
		  // a esta secuencia , ene l caso de un video con secuencias multiples
        do
        {
            // liberar paquete antiguo
            if(packet.data!=NULL)
                av_free_packet(&packet);

            // leer neuvo paquete
            if(av_read_packet(pFormatCtx, &packet)<0)
                goto loop_exit;
        } while(packet.stream_index!=videoStream);

        bytesRemaining=packet.size;
        rawData=packet.data;
    }

loop_exit:

    // decodificar el resto de ultimo cuadro
    bytesDecoded=avcodec_decode_video(pCodecCtx, pFrame, &frameFinished, 
        rawData, bytesRemaining);

    // liberar el ultimo paquete
    if(packet.data!=NULL)
        av_free_packet(&packet);

    return frameFinished!=0;
}

void SaveFrame(AVFrame *pFrame, int width, int height, int iFrame)
{
    FILE *pFile;
    char szFilename[32];
    int  y;

    // para guardar en formato de imagen ppm
    sprintf(szFilename, "frame%d.ppm", iFrame);
    pFile=fopen(szFilename, "wb");
    if(pFile==NULL)
        return;

    // escribir cabecera
    fprintf(pFile, "P6\n%d %d\n255\n", width, height);

    // escribir datos
    for(y=0; y<height; y++)
        fwrite(pFrame->data[0]+y*pFrame->linesize[0], 1, width*3, pFile);

    // cerrar
    fclose(pFile);
}

int main(int argc, char *argv[])
{
    AVFormatContext *pFormatCtx;
    int             i, videoStream;
    AVCodecContext  *pCodecCtx;
    AVCodec         *pCodec;
    AVFrame         *pFrame; 
    AVFrame         *pFrameRGB;
    int             numBytes;
    uint8_t         *buffer;

    // registrar codecs y formatos soportados
    av_register_all();

    // abrir arhcivo de video
    if(av_open_input_file(&pFormatCtx, argv[1], NULL, 0, NULL)!=0)
        return -1; // Couldn't open file

    // obtener informacion del video
    if(av_find_stream_info(pFormatCtx)<0)
        return -1;

    // escribir informacio en la slaida estandar
    dump_format(pFormatCtx, 0, argv[1], false);

    // encontrar la priemra secuencia (en caso de que el video
	 // tenga varias solo se trabajara con la primera)
    videoStream=-1;
    for(i=0; i<pFormatCtx->nb_streams; i++)
        if(pFormatCtx->streams[i]->codec.codec_type==CODEC_TYPE_VIDEO)
        {
            videoStream=i;
            break;
        }
    if(videoStream==-1)
        return -1; 

    // obtener un puntero al "contexto" de codec de la secuencia
    pCodecCtx=&pFormatCtx->streams[videoStream]->codec;

    // encontrar el decodificador
    pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
    if(pCodec==NULL)
        return -1; 

    // informarle al codec que se pueden manejar secuencias truncadas
    if(pCodec->capabilities & CODEC_CAP_TRUNCATED)
        pCodecCtx->flags|=CODEC_FLAG_TRUNCATED;

    // abrir codec
    if(avcodec_open(pCodecCtx, pCodec)<0)
        return -1;

    // rutina para corregir frame rates incorrectos
    if(pCodecCtx->frame_rate>1000 && pCodecCtx->frame_rate_base==1)
        pCodecCtx->frame_rate_base=1000;

    // asignar cuadro de video
    pFrame=avcodec_alloc_frame();

    // asignar una estructura AVFrame
    pFrameRGB=avcodec_alloc_frame();
    if(pFrameRGB==NULL)
        return -1;

    // determinar y asignar tamaño del buffer requerido
    numBytes=avpicture_get_size(PIX_FMT_RGB24, pCodecCtx->width,
        pCodecCtx->height);
    buffer=new uint8_t[numBytes];

    // asignar partes del buffer a planos de imagen en pFrameRGB
    avpicture_fill((AVPicture *)pFrameRGB, buffer, PIX_FMT_RGB24,
        pCodecCtx->width, pCodecCtx->height);

    // leer y salvar los primeros 5 cuadros
    i=0;
    while(GetNextFrame(pFormatCtx, pCodecCtx, videoStream, pFrame))
    {
        img_convert((AVPicture *)pFrameRGB, PIX_FMT_RGB24, (AVPicture*)pFrame, 
            pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);

        // guardar cuadro
        if(++i<=5)
            SaveFrame(pFrameRGB, pCodecCtx->width, pCodecCtx->height, i);
		  if(i>5)
		      break;//terminar a los 5 frames no procesaremos mas
			
    }

    // liberar la imagen rgb
    delete [] buffer;
    av_free(pFrameRGB);

    // liberar el cuadro YUV
    av_free(pFrame);

    // cerrar codec
    avcodec_close(pCodecCtx);

    // cerrar video
    av_close_input_file(pFormatCtx);

    return 0;
}