vetCodec_MOV.cpp

Go to the documentation of this file.

#include "vetCodec_MOV.h"
#include "../vetUtility.h"

//extern "C" {
//      #include "../../support/quicktime4linux/quicktime.h"
//  }



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

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

        load( filename, stream );

 }

vetCodec_MOV::vetCodec_MOV( vetCodec_MOVParameters* initParams ) : vetCodec()
 {
        DEBUGMSG("vetCodec_MOV::vetCodec_MOV(vetCodec_MOVParameters* initParams) [CONTRUCTOR] ", *filename)

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

        reset();
 }

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

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

        if (file != NULL)
         {
                quicktime_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;
        lenghtFrames = 0;
        outFrameRate = 0;

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

        streamEOF = true;

        return VETRET_OK;
 }


bool vetCodec_MOV::EoF()        // buggy
 {
        if (file == NULL)

                return true;

        if ( myParams->frameIndex >= lenghtFrames)
                return true;

        return false;
 }


VETRESULT vetCodec_MOV::setParameters (vetCodec_MOVParameters* initParams)
 {

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

        return VETRET_OK;
 }

vetCodec_MOV::~vetCodec_MOV()
 {
        if (file != NULL)
                quicktime_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;
         }
 }

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

        if (file == NULL)
                return VETRET_ILLEGAL_USE;

        return VETRET_NOT_IMPLEMENTED;

 }

VETRESULT vetCodec_MOV::extractTo(vetFrameRGB24& img)
 {
        DEBUGMSG("VETRESULT vetCodec_MOV::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
        quicktime_decode_video(file, (unsigned char**)img.data, 0);

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

//BUG why not memcpy( (unsigned char*)img.data[0], buff, width * height * 3);

        myParams->frameIndex++;

        if(myParams->frameIndex > lenghtFrames)
                streamEOF = true;

        return VETRET_OK;
 }

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

        if (file == NULL)
                return VETRET_ILLEGAL_USE;

        return VETRET_NOT_IMPLEMENTED;
 }


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

        if (file == NULL)
                return VETRET_ILLEGAL_USE;

        return VETRET_NOT_IMPLEMENTED;

 }

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

        if (file == NULL)
                return VETRET_ILLEGAL_USE;

        PixelRGB24* rgb_ptr = img.data;

        unsigned char *buff_ptr = buff[0];

        for(unsigned int y_cnt=0 ; y_cnt < img.height ; y_cnt++)
         {
                buff_ptr = buff[y_cnt];

                for(unsigned int x_cnt=0 ; x_cnt < img.width ; x_cnt++, rgb_ptr++)
                 {
                        *(buff_ptr++) = (unsigned char)((*rgb_ptr)[0]);
                        *(buff_ptr++) = (unsigned char)((*rgb_ptr)[1]);
                        *(buff_ptr++) = (unsigned char)((*rgb_ptr)[2]);
                 }
         }

        myParams->frameIndex++;
        lenghtFrames++;

        //Encode the frame and write to file
        if ( quicktime_encode_video(file, buff, 0) )
                return VETRET_OK;
        else
                return VETRET_INTERNAL_ERR;

 }

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

        return VETRET_NOT_IMPLEMENTED;

 }



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

        // check the files signature is valid
        if (!quicktime_check_sig(myParams->fileName))
                return VETRET_ILLEGAL_USE;
//              throw "incompatible quicktime file";

        // open the QT file
        file = quicktime_open(myParams->fileName,1,0); //read access only!
        if (file == NULL)
                return VETRET_ILLEGAL_USE;
//              throw "error opening quicktime file";



        // check that it is a video QT file, with one track
        if (quicktime_video_tracks(file) != 1)
                throw "QT file does not only have one video track";
//        if (quicktime_audio_tracks(file) != 0)
//                throw "QT file has audio tracks";

//BUG CHECK STREAM RANGE


        width  = quicktime_video_width(file, myParams->stream);
        height = quicktime_video_height(file, myParams->stream);

        lenghtFrames = quicktime_video_length(file, myParams->stream);
        myParams->frameIndex = 0;
        streamEOF = false;

        //Check Depth: Only RGB allowed, RGBA not supported
        //Could be, but requires extra processing in this file
        if(quicktime_video_depth(file, 0) != 24)
                return VETRET_ILLEGAL_USE;
//              throw "Depth not 24 ie not RGBRGBRGB encoded QT";

//      comp_type = quicktime_video_compressor(file, 0);
        if (!quicktime_supported_video(file, 0))
                return VETRET_ILLEGAL_USE;

//              throw "QT data cannot be decoded";

        // allocate memory for rgb rows
        buff = new (unsigned char*)[height];
        for (unsigned int i = 0; i < height ; i++)
                buff[i] = new (unsigned char)[width*3];

        return VETRET_OK;
}

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

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

        return load();
 }


VETRESULT vetCodec_MOV::newVideo(char* filename, unsigned int w, unsigned int h, float frame_rate, int quality)
 {
        if (file != NULL)
                reset();

        //open the a file for the quicktime movie
        file = quicktime_open(filename,0,1);

        if (file == NULL)
                return VETRET_INTERNAL_ERR; // throw "error opening file to write quicktime to";

        width = w;
        height = h;
        outFrameRate = frame_rate;
        streamEOF = true;

        //Set video parameters - Using Interlaced Even Motion JPEG A compression
        quicktime_set_video(file, 1, width, height, outFrameRate, "mjpa");

        //Set the JPEG quality factor 1=low 75=normal 90=high 100=best
        quicktime_set_jpeg(file, quality, 0);

        //Check compression scheme is supported
        if( !quicktime_supported_video(file, 0) )
                return VETRET_INTERNAL_ERR; // throw "QT Compression scheme not supported" ;

        //Check colour model is supported - using RGB888
        if( !quicktime_writes_cmodel(file, 9, 0) )
                return VETRET_INTERNAL_ERR; // throw "QT Color Model not supported" ;

        //Set colourmodel to RGB888 format
        quicktime_set_cmodel(file, 9);

        // allocate memory for rgb rows
        buff = new (unsigned char*)[height];
        for (unsigned int i = 0; i < height ; i++)
                buff[i] = new (unsigned char)[width*3];

        return VETRET_OK;
 }


VETRESULT vetCodec_MOV::save()
 {
        INFO("VETRESULT vetCodec_MOV::save() [saving buffered data]")

        if ( file == NULL)
                return VETRET_ILLEGAL_USE;

        quicktime_close(file);

        file = NULL;

        reset();

        return VETRET_OK;
 }




VETRESULT vetCodec_MOV::goToStart()
 {
        if ( file == NULL)
                return VETRET_ILLEGAL_USE;

        return quicktime_seek_start(file);
 }

VETRESULT vetCodec_MOV::goToEnd()
 {
        if ( file == NULL)
                return VETRET_ILLEGAL_USE;

        return quicktime_seek_end(file);
 }



long vetCodec_MOV::getAudioFrameIndex(int stream)
 {
        if ( hasAudio() && stream == -1  )
                return quicktime_audio_position(file, myParams->stream);

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

    return quicktime_audio_position(file, stream);
 }

long vetCodec_MOV::getVideoFrameIndex(int stream)
 {
        if ( hasVideo() && stream == -1  )
                return quicktime_video_position(file, myParams->stream);

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

    return quicktime_video_position(file, stream);
 }

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

    myParams->frameIndex = index;

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

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

    return quicktime_set_video_position(file, index, stream) ;
 }


int vetCodec_MOV::getVideoDepth(int stream)
 {
        if ( hasVideo() && stream == -1  )
                return quicktime_video_depth(file, myParams->stream);

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

        return quicktime_video_depth(file, stream);
 }

char* vetCodec_MOV::getVideoCompressor(int stream)
 {
        if ( hasVideo() && stream == -1  )
                return quicktime_video_compressor(file, myParams->stream);

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

        return quicktime_video_compressor(file, stream);
 }

char* vetCodec_MOV::getAudioCompressor(int stream)
 {
        if ( hasVideo() && stream == -1  )
                return quicktime_audio_compressor(file, myParams->stream);

        if ( !hasVideo() ||  stream < 0 || stream >= getAudioStreamCount())
                return NULL;

        return quicktime_audio_compressor(file, stream);
 }


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

        if ( file == NULL || stream < 0 || stream >= getVideoStreamCount() )
                return -1;

        return quicktime_frame_rate(file, stream);
 }



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

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

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

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

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

        return quicktime_video_tracks(file);
 }

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

        return quicktime_audio_tracks(file);
 }

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

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

        return quicktime_audio_length(file, stream);
 }

long vetCodec_MOV::getVideoStreamLength(int stream)
 {
        if ( hasAudio() && stream == -1  )
                return quicktime_video_length(file, myParams->stream);

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

        return quicktime_video_length(file, stream);
 }

long vetCodec_MOV::getAudioSampleRate(int stream)
 {
        if ( hasAudio() && stream == -1  )
                return quicktime_sample_rate(file, myParams->stream);

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

        return quicktime_sample_rate(file, stream);
 }

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

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

        return quicktime_track_channels(file, stream);
 }









VETRESULT vetCodec_MOV::setName(char *string)
 {
        if (file == NULL)
                return VETRET_ILLEGAL_USE;

        quicktime_set_name(file, string);

        return VETRET_OK;
 }

VETRESULT vetCodec_MOV::setInfo(char *string)
 {
        if (file == NULL)
                return VETRET_ILLEGAL_USE;

        quicktime_set_info(file, string);

        return VETRET_OK;
 }

VETRESULT vetCodec_MOV::setCopyRight(char *string)
 {
        if (file == NULL)
                return VETRET_ILLEGAL_USE;

        quicktime_set_copyright(file, string);

        return VETRET_OK;
 }

char* vetCodec_MOV::getName()
 {
        if (file == NULL)
                return NULL;

        return quicktime_get_name(file);
 }

char* vetCodec_MOV::getInfo()
 {
        if (file == NULL)
                return NULL;

        return quicktime_get_info(file);
 }

char* vetCodec_MOV::getCopyRight()
 {
        if (file == NULL)
                return NULL;

        return quicktime_get_copyright(file);
 }















vetCodec_MOVParameters::vetCodec_MOVParameters()
 {
        reset();
 }

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

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


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

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

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


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

        if( fprintf(fp, "<vetCodec_MOVParameters>\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_MOVParameters::loadFromStreamXML(FILE *fp)
 {
        if ( fscanf(fp, "<vetCodec_MOVParameters>\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;
 }

---