vetCodec_MPEG.cpp

Go to the documentation of this file.

#include "vetCodec_MPEG.h"
#include "../vetUtility.h"

// #include "../../support/libmpeg3/libmpeg3.h"

vetCodec_MPEG::vetCodec_MPEG(char *filename, int stream) : vetCodec()
 {
        DEBUGMSG("vetCodec_MPEG::vetCodec_MPEG(char *filename, FileFormat format) [CONTRUCTOR] ", *filename)

        buff = NULL;
        file = NULL;
        setParameters(NULL);
        reset();

        load( filename, stream );

 }

vetCodec_MPEG::vetCodec_MPEG( vetCodec_MPEGParameters* initParams ) : vetCodec()
 {
        DEBUGMSG("vetCodec_MPEG::vetCodec_MPEG(vetCodec_MPEGParameters* initParams) [CONTRUCTOR] ", *filename)

        buff = NULL;
        file = NULL;

        setParameters(initParams);
        reset();
 }

VETRESULT vetCodec_MPEG::reset()
 {
        INFO("VETRESULT vetCodec_MPEG::reset() [SET DEFAULT PARAMETERS]")

        setName("MPEG Coder");
        setDescription("Read or write video stream.");
        setVersion(1.0);

        if (file != NULL)
         {
                mpeg3_close(file);
                file = NULL;
         }

        if (buff != NULL)
         {
                // 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;
         }

        width  = 0;
        height = 0;

        if (myParams != NULL)
                myParams->reset();

        return VETRET_OK;
 }


VETRESULT vetCodec_MPEG::setParameters (vetCodec_MPEGParameters* initParams)
 {

        if ( initParams == NULL )
                myParams = new vetCodec_MPEGParameters();
        else
                myParams = initParams;

        return VETRET_OK;
 }

vetCodec_MPEG::~vetCodec_MPEG()
 {
        if (file != NULL)
                mpeg3_close(file);

        if (buff != NULL)
         {
                // 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;
         }
 }

bool vetCodec_MPEG::EoF()       // buggy
 {
        if (file == NULL)
                return true;

        return false;
 }


VETRESULT vetCodec_MPEG::extractTo(vetFrameYUV420& img)
 {
        DEBUGMSG("VETRESULT vetCodec_MPEG::extractTo(vetFrameYUV420& img) [pushing data]", doBuffering)

        if (file == NULL)
                return VETRET_ILLEGAL_USE;

        if (width != img.width || height != img.height)
                img.reAllocCanvas(width, height);

        // read the frame to a temporary buffer
        mpeg3_read_yuvframe(file,
                                                (char*)img.Y,
                                                (char*)img.U,
                                                (char*)img.V,
                                                0, 0,
                                                width, height,
                                                0);

/* Supported color models for mpeg3_read_yuvframe */
//#define MPEG3_YUV420P 12
//#define MPEG3_YUV422P 13

        return VETRET_NOT_IMPLEMENTED;
 }


VETRESULT vetCodec_MPEG::extractTo(vetFrameRGB24& img)
 {
        DEBUGMSG("VETRESULT vetCodec_MPEG::extractTo(vetFrameRGB24& img) [pushing data]", doBuffering)

        if (file == NULL)
                return VETRET_ILLEGAL_USE;

        if (width != img.width || height != img.height)
                img.reAllocCanvas(width, height);

        // read the frame to a temporary buffer
        mpeg3_read_frame(file, buff,
                                         0, 0,
                                         width, height,
                                         width, height,
                                         MPEG3_RGB888, 0);


        vetUtility::conv_rgb24_rgb96(buff, (unsigned char*)img.data[0], width, height);
//non va        memcpy((unsigned char*)img.data[0], buff, width*height*3);

        return VETRET_OK;

 }


VETRESULT vetCodec_MPEG::extractTo(vetFrameT<unsigned char>& img)
 {
        DEBUGMSG("VETRESULT vetCodec_MPEG::extractTo(vetFrameT& img) [pushing data]", doBuffering)

//#define MPEG3_RGB565 2
//#define MPEG3_BGR888 0
//#define MPEG3_BGRA8888 1
//#define MPEG3_RGB888 3
//#define MPEG3_RGBA8888 4
//#define MPEG3_RGBA16161616 5


        return VETRET_NOT_IMPLEMENTED;


 }


VETRESULT vetCodec_MPEG::importFrom(vetFrameYUV420& img)
 {
        DEBUGMSG("VETRESULT vetCodec_MPEG::importFrom(vetFrameYUV420& img) [reading data]", doBuffering)

        return VETRET_NOT_IMPLEMENTED;


 }

VETRESULT vetCodec_MPEG::importFrom(vetFrameRGB24& img)
 {
        DEBUGMSG("VETRESULT vetCodec_MPEG::importFrom(vetFrameRGB24& img) [reading data]", doBuffering)

        return VETRET_NOT_IMPLEMENTED;


 }

VETRESULT vetCodec_MPEG::importFrom(vetFrameT<unsigned char>& img)
 {
        DEBUGMSG("VETRESULT vetCodec_MPEG::importFrom(vetFrameYUV420& img) [reading data]", doBuffering)

        return VETRET_NOT_IMPLEMENTED;


 }



VETRESULT vetCodec_MPEG::load()
 {
        INFO("VETRESULT vetCodec_MPEG::load() [loading data to buffer]")

        // check the files signature is valid
        if ( !mpeg3_check_sig(myParams->fileName) )
                return VETRET_ILLEGAL_USE;

        file = mpeg3_open(myParams->fileName);

        if (file == NULL)
                return VETRET_ILLEGAL_USE;


        // check that it is a video MPEG file
        if (!mpeg3_has_video(file))
                return VETRET_ILLEGAL_USE;//non-video MPEG file";

//BUG CHECK STREAM RANGE

        width  = mpeg3_video_width(file, myParams->stream);
        height = mpeg3_video_height(file, myParams->stream);

        // 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];

        // Allocate memory for YUV data
        Y = new char[width*height] ;
        U = new char[width*height/4] ;
        V = new char[width*height/4] ;

        return VETRET_OK;
}

VETRESULT vetCodec_MPEG::load(char *filename, int stream)
 {
        DEBUGMSG("VETRESULT vetCodec_MPEG::load(char *filename, FileFormat format) [loading data to buffer]", filename)

        myParams->setFileName(filename);
        myParams->setStream(stream);

        return load();
 }



VETRESULT vetCodec_MPEG::goToPreviousFrame(int stream)
 {
        if ( file == NULL)
                return VETRET_ILLEGAL_USE;

        if ( stream == -1  )
                return mpeg3_previous_frame(file, myParams->stream);

        if ( stream < 0 || stream >= getVideoStreamCount() )
                return VETRET_PARAM_ERR;

        return mpeg3_previous_frame(file, stream);
 }

VETRESULT vetCodec_MPEG::goToVideoEnd(int stream)
 {
        if ( file == NULL)
                return VETRET_ILLEGAL_USE;

        if ( stream == -1  )
                return mpeg3_end_of_video(file, myParams->stream);

        if ( stream < 0 || stream >= getVideoStreamCount() )
                return VETRET_PARAM_ERR;

        return mpeg3_end_of_video(file, stream);
 }

VETRESULT vetCodec_MPEG::goToAudioEnd(int stream)
 {
        if ( file == NULL)
                return VETRET_ILLEGAL_USE;

        if ( stream == -1  )
                return mpeg3_end_of_audio(file, myParams->stream);

        if ( stream < 0 || stream >= getAudioStreamCount() )
                return VETRET_PARAM_ERR;

        return mpeg3_end_of_audio(file, stream);
 }


double vetCodec_MPEG::getLastPacketTime()
 {
        if ( file == NULL)
                return -1;

        return mpeg3_get_time(file);
 }



bool vetCodec_MPEG::hasVideo()
 {
        if ( file == NULL)
                return false;

        if ( mpeg3_has_video(file) )
                return true;
        else
                return false;
 }

int vetCodec_MPEG::getVideoStreamCount()
 {
        if ( file == NULL)
                return -1;

        return mpeg3_total_vstreams(file);
 }

bool vetCodec_MPEG::hasAudio()
 {
        if ( file == NULL)
                return false;

        if ( mpeg3_has_audio(file) )
                return true;
        else
                return false;
 }

int vetCodec_MPEG::getAudioStreamCount()
 {
        if ( file == NULL)
                return -1;

        return mpeg3_total_astreams(file);
 }

long vetCodec_MPEG::getAudioStreamLength(int stream)
 {
        if ( hasAudio() && stream == -1  )
                return mpeg3_audio_samples(file, myParams->stream);

        if ( !hasAudio() || stream < 0 || stream >= getAudioStreamCount() )
                return -1;

        return mpeg3_audio_samples(file, stream);
 }

long vetCodec_MPEG::getVideoStreamLength(int stream)
 {
        if ( hasVideo() && stream == -1  )
                return mpeg3_video_frames(file, myParams->stream);

        if ( !hasVideo() || stream < 0 || stream >= getVideoStreamCount() )
                return -1;

        return mpeg3_video_frames(file, stream);
 }

float vetCodec_MPEG::getAudioSampleRate(int stream)
 {
        if ( hasAudio() && stream == -1  )
                return  mpeg3_sample_rate(file, myParams->stream);

        if ( !hasAudio() || stream < 0 || stream >= getAudioStreamCount() )
                return -1;

        return mpeg3_sample_rate(file, stream);
 }

int vetCodec_MPEG::getAudioChannels(int stream)
 {
        if ( hasAudio() && stream == -1  )
                return  mpeg3_audio_channels(file, myParams->stream);

        if ( !hasAudio() || stream < 0 || stream >= getAudioStreamCount() )
                return -1;

        return mpeg3_audio_channels(file, stream);
 }

float vetCodec_MPEG::getVideoFrameRate(int stream)
 {
        if ( hasVideo() && stream == -1  )
                return  mpeg3_frame_rate(file, myParams->stream);

        if ( !hasVideo() || stream < 0 || stream >= getVideoStreamCount() )
                return -1;

        return mpeg3_frame_rate(file, stream);
 }

int vetCodec_MPEG::getColorModel(int stream)
 {
        if ( !hasVideo() || stream < 0 || stream >= getVideoStreamCount() )
                return -1;

        return mpeg3_colormodel(file, stream);
 }






VETRESULT vetCodec_MPEG::setFrameIndex(long index, int stream)
 {
        if ( file == NULL)
                return VETRET_ILLEGAL_USE;

        if ( hasVideo() && stream == -1  )
                return  mpeg3_set_frame(file, index, myParams->stream);

        if ( !hasVideo() || stream < 0 || stream >= getVideoStreamCount() )
                return VETRET_ILLEGAL_USE;

        myParams->setFrameIndex(index);

    return mpeg3_set_frame(file, index, stream);
 }

bool vetCodec_MPEG::eof(int stream) const
 {
        if ( file == NULL)
                return true;

        if ( stream == -1  )
                if ( mpeg3_end_of_video(file, myParams->stream) == 0 )
                        return false;
                else
                        return true;

        if ( mpeg3_end_of_video(file, stream) == 0 )
                return false;
        else
                return true;
 }






int vetCodec_MPEG::getMPEG3_Version_major() { return mpeg3_major(); };
int vetCodec_MPEG::getMPEG3_Version_minor() { return mpeg3_minor(); };
int vetCodec_MPEG::getMPEG3_Version_release() { return mpeg3_release(); };























vetCodec_MPEGParameters::vetCodec_MPEGParameters()
 {
        reset();
 }

vetCodec_MPEGParameters::vetCodec_MPEGParameters(const char* filename, int stream, long frameIndex)
 {
        reset();
        setFileName(filename);
        setStream(stream);
        setFrameIndex(frameIndex);
 }

void vetCodec_MPEGParameters::reset()
 {
        strcpy(fileName, (const char*)"input.mpg\0");
        frameIndex = 0;
        stream = 0;
 }


void vetCodec_MPEGParameters::setFileName(const char *filename)
 {
        strncpy(fileName, filename, 64);
 }

void vetCodec_MPEGParameters::setFrameIndex(long index)
 {
        frameIndex = index;
 }

void vetCodec_MPEGParameters::setStream(int s)
 {
        stream = s;
 }


int vetCodec_MPEGParameters::saveToStreamXML(FILE *fp)
 {
        if ( fp == NULL )
                return VETRET_PARAM_ERR;

        if( fprintf(fp, "<vetCodec_MPEGParameters>\n") == EOF )
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <filename value=\"%s\" />\n", fileName) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <stream value=\"%d\" />\n", stream) == EOF)
                return VETRET_INTERNAL_ERR;

        if ( fprintf(fp, "  <frameIndex value=\"%ld\" />\n", frameIndex) == EOF)
                return VETRET_INTERNAL_ERR;

        if( fprintf(fp, "</vetCodec_MOVParameters>\n") == EOF )
                return VETRET_INTERNAL_ERR;

        return VETRET_OK;
 }


int vetCodec_MPEGParameters::loadFromStreamXML(FILE *fp)
 {
        if ( fscanf(fp, "<vetCodec_MPEGParameters>\n") == EOF )
                throw "error in XML file, unable to import data.";

        if ( fscanf(fp, "  <filename value=\"%s\" />\n", fileName) == EOF )
                throw "error in XML file, unable to import data.";

        if ( fscanf(fp, "  <stream value=\"%d\" />\n", &stream) == EOF )
                throw "error in XML file, unable to import data.";

        if ( fscanf(fp, "  <frameIndex value=\"%ld\" />\n", &frameIndex) == EOF )
                throw "error in XML file, unable to import data.";

        return VETRET_OK;
 }

---