---

AVISource.cpp

Go to the documentation of this file.

/**************************************************************************
 *
 * Source code for Real Time Image Library (libRTImage)
 *
 * Leeds Vision Group give permission for this code to be copied, modified 
 * and distributed within the University of Leeds subject to the following 
 * conditions:-
 *
 * - The code is not to be used for commercial gain.
 * - The code and use thereof will be attributed to the author where
 *   appropriate (inluding demonstrations which rely on it's use).
 * - All modified, distributions of the source files will retain this header.
 *
 ****************************************************************************/
 
#include "ccvt/conv.h"
#include "AVISource.h"


AVISource::AVISource(char* path)
{

        // Register all formats and codecs
        av_register_all();
        
        // Open video file
        if(av_open_input_file(&pFormatCtx, path, NULL, 0, NULL)!=0)
                throw "couldn't open avi file";

        // Retrieve stream information
        if(av_find_stream_info(pFormatCtx)<0)
                throw "couldn't find avi stream information";

        // Dump information about file onto standard error
        dump_format(pFormatCtx, 0, path, false);
        
        // Find the first video stream
        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)
                throw "didn't find an avi video stream";

        // Get a pointer to the codec context for the video stream
        pCodecCtx=&pFormatCtx->streams[videoStream]->codec;

        // Find the decoder for the video stream
        pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
        if(pCodec==NULL)
                throw "avi codec not found";
                                                                                
        // Inform the codec that we can handle truncated bitstreams -- i.e.,
        // bitstreams where frame boundaries can fall in the middle of
        // packets
        if(pCodec->capabilities & CODEC_CAP_TRUNCATED)
                pCodecCtx->flags|=CODEC_FLAG_TRUNCATED;
                                                                                
        // Open codec
        if(avcodec_open(pCodecCtx, pCodec)<0)
                throw "could not open avi codec";
                                                                                
        // Hack to correct wrong frame rates that seem to be generated by
        // some codecs
        if(pCodecCtx->frame_rate>1000 && pCodecCtx->frame_rate_base==1)
                pCodecCtx->frame_rate_base=1000;
                                                                                
        // Allocate video frame 
        pFrame=avcodec_alloc_frame();

        // Allocate an AVFrame structure
        pFrameRGB=avcodec_alloc_frame();
        if(pFrameRGB==NULL)
                throw "cannot allocate aviframe structure";
                                                                                
        // Determine required buffer size and allocate buffer
        numBytes=avpicture_get_size(PIX_FMT_RGB24, 
                                    pCodecCtx->width, 
                                    pCodecCtx->height);
        buffer=new uint8_t[numBytes];
                                                                                
        // Assign appropriate parts of buffer to image planes in pFrameRGB
        avpicture_fill((AVPicture *)pFrameRGB, 
                        buffer, 
                        PIX_FMT_RGB24,
                        pCodecCtx->width, 
                        pCodecCtx->height);




        width  = pCodecCtx->width;
        height =  pCodecCtx->height; 
        frames = 0 ;
        framerate = pCodecCtx->frame_rate;

        // allocate memory for rgb rows
        buff = new (unsigned char*)[height];
        for (unsigned int i = 0; i < height - 1; i++)
                buff[i] = new (unsigned char)[width*3];
        
        // last row need space for mmx scratch area
        buff[height - 1] = new (unsigned char)[width*3 + 4];

        // default palette type for this ImageSource is colour 
        type = Image::COLOUR;
}

AVISource::~AVISource()
{
    // Free the RGB image
    delete [] 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);
        
        // free the memory for each of the rows
        for (unsigned int i = 0; i < height; i++)
                delete [] buff[i];
        
        // free the rest of the memory
        delete [] buff;
}


ImageSource& AVISource::operator >> (ImageRGB& img) 
{
    static AVPacket packet;
    static int      bytesRemaining=0;
    static uint8_t  *rawData;
    static bool     fFirstTime=true;
    int             bytesDecoded;
    int             frameFinished;

    // First time we're called, set packet.data to NULL to indicate it
    // doesn't have to be freed
    if(fFirstTime)
    {
        fFirstTime=false;
        packet.data=NULL;
    }

    // Decode packets until we have decoded a complete frame
    while(true)
    {
        // Work on the current packet until we have decoded all of it
        while(bytesRemaining > 0)
        {
            // Decode the next chunk of data
            bytesDecoded=avcodec_decode_video(pCodecCtx, pFrame,
                &frameFinished, rawData, bytesRemaining);

            // Was there an error?
            if(bytesDecoded < 0)
            {
                 throw "Error while decoding frame";
                 //return false;
                 return *this ;
            }

            bytesRemaining-=bytesDecoded;
            rawData+=bytesDecoded;

            // Did we finish the current frame? Then we can return
            if(frameFinished)
                //return true;
                //cerr << "DEBUG: frameFinished == true" << endl;
                //return *this;
                goto conv_img;
        }

        // Read the next packet, skipping all packets that aren't for this
        // stream
        do
        {
            // Free old packet
            if(packet.data!=NULL)
                av_free_packet(&packet);

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

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

loop_exit:

    // Decode the rest of the last frame
    bytesDecoded=avcodec_decode_video(pCodecCtx, pFrame, &frameFinished, 
        rawData, bytesRemaining);

    // Free last packet
    if(packet.data!=NULL)
        av_free_packet(&packet);

    //return frameFinished!=0;

conv_img:

//start option B
        
//    img_convert((AVPicture *)pFrameRGB, PIX_FMT_RGB24, (AVPicture*)pFrame,
//            pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);
 

//      unsigned char** rows = NULL;
//      rows = new (unsigned char*)[height];
//      for(unsigned int y=0; y<height; y++){
//            rows[y] = pFrameRGB->data[0]+y*pFrameRGB->linesize[0];
//      }
//      conv_rgb24_rgb96(width, height, rows, img.data[0]);
//      delete [] rows;

//end option B

//    AVPicture* curr_pframe = (AVPicture*) pFrameRGB;
//    for (unsigned int i = 0; i < height; i++){
//        for(unsigned int j = 0; j < width; j++){
//                buff[i][j] = (unsigned char) curr_pframe->data[i*pFrame->linesize[0]+j];
//        }
//    }

  
//start option A

        //This stores buffer in img.data
        //buffer appears to be *part* of the current frame, viz
        //compression stuff, think AVPicture* pFrameRGB contains image!

        uint8_t* s = buffer; 
        int*   d = (int*) img.data[0];
                                                                                                                                      
        for (unsigned int j = 0; j < height; j++) {
                for (unsigned int i = 0; i < width; i++) {
                        *(d++) = (int) *(s++);
                        *(d++) = (int) *(s++);
                        *(d++) = (int) *(s++);
                }
        }

//end option A

//    convert the frame to rgb96
//    conv_rgb24_rgb96(width, height, buff, img.data[0]);

    return *this;
}


ImageSource& AVISource::operator >> (ImageGrey& img)
{
        Image tmp((Image&)img);
        //SLOW HACK
        *this >> (ImageRGB&)tmp;
        tmp.update_brightness();
        img.copy((ImageGrey&)tmp);
        return *this;
}

ImageSource& AVISource::operator >> (Image& img) 
{
        (type == Image::COLOUR) ? *this >> (ImageRGB&)img
                                : *this >> (ImageGrey&)img;
                
        return *this;
}

int  AVISource::get_no_frames()
{
return (int) frames;
}

void AVISource::get_size(unsigned int& w, unsigned int& h)
{
        w = width; 
        h = height;
}

int AVISource::set_frame(long frame_no)
{
//    return mpeg3_set_frame(file, frame_no, 0) ;
        cerr << "NOT YET IMPLEMENTED AVISource::set_frame(long frame_no)" << endl;
        return false;
}

void AVISource::get_framerate(float& fr_rate)
{
    fr_rate = framerate;
}

bool AVISource::eof() const
{
    //return (bool)(mpeg3_end_of_video(file, 0));
    cerr << "NOT YET IMPLEMENTED AVISource::eof() const" << endl;
    return false;
}

---