qt.c

dm270 source code

/*-----------------------------------------------------------------------------\
@ModuleName  :: qt.c

@Description :: Quick Time Wrapper for MJPEG , H263, MPEG-4 bitstream

                For info about Quick Time File Format see QTFF reference at
                http://developer.apple.com/techpubs/quicktime/qtdevdocs/QTFF/qtff.html

@Copyright   :: Copyright 2001- Texas Instruments, Inc.

@History     ::
-------------------------------------------------------------------------------

    Dec.  26, 2001  Kedar C ([e-mail]) Start


\-----------------------------------------------------------------------------*/


/* include files    */

#include <string.h>
#include <qtff/qt.h>


/* Module Routines  */

/*-----------------------------------------------------------------------------\
@RoutineName :: QTInitParams

@Description ::
    Initialize the QTParams struct


@Parameters  ::
    QTParams *prmQT         ::  QT Configuration structure to be initialized
    Uint32 videoDataFormat   ::  Video Data Format .. H263 or MJPEG

@Return      ::
    E_PASS,     success
    E_DEVICE,  failure
\-----------------------------------------------------------------------------*/
STATUS QTInitParams(QTParams *prmQT, Uint32 videoDataFormat ) {
    prmQT->Timescale        = QT_TIMESCALE;
    prmQT->FrameRate        = GetMovieFrameRate(videoDataFormat );
    prmQT->Width            = GetMovieWidth( videoDataFormat );
    prmQT->Height           = GetMovieHeight(videoDataFormat );
    prmQT->MediaTime        = QT_MEDIA_TIME_START;
    prmQT->MediaRate        = QT_MEDIA_RATE_NORMAL;
    prmQT->GraphicsMode     = QT_GRAPHICS_MODE_DITHER_COPY;
    prmQT->Opcolor          = QT_OPCOLOR;
    prmQT->DataFormat       = videoDataFormat ;
    prmQT->TemporalQuality  = QT_TEMPORAL_QUALITY;
    prmQT->SpatialQuality   = QT_SPATIAL_QUALITY;
    prmQT->Hres             = QT_H_RES;                     /* pixels per inch  */
    prmQT->Vres             = QT_V_RES;                     /* pixels per inch  */
    prmQT->FramePerSample   = QT_FRAMES_PER_SAMPLE;
    prmQT->ColorDepth       = QT_COLOR_DEPTH_24BIT;
    prmQT->FieldCount       = QT_SINGLE_FIELD;
    prmQT->FieldOrdering    = QT_FIELD_ORDER_UNKNOWN;
    prmQT->SampleDuration   = prmQT->Timescale / prmQT->FrameRate;
	prmQT->Timescale		= prmQT->SampleDuration*prmQT->FrameRate;
    prmQT->KeyFrameInterval = GetMovieKeyFrameInterval( videoDataFormat );
    prmQT->ChunkOffset      = 0;
    prmQT->SsizeConst       = FALSE;
    prmQT->Videosize        = 0;
    prmQT->Duration         = 0;
    prmQT->Scount           = 0;
	
	memset(prmQT->ESDSAtomInfo, 0, QT_ESDS_ATOM_MAX_SIZE); /* this field needs to be set by user for MPEG4 bitstream */
    prmQT->audioPrmQT.IncludeAudio  = 0;
    prmQT->audioPrmQT.SamplingRate  = 8000;
    prmQT->audioPrmQT.AudioChannels = 2;
    prmQT->audioPrmQT.AudioDataSize = 0;
    return E_PASS;
}


/*-----------------------------------------------------------------------------\

    QT Header Constructor Routines

\-----------------------------------------------------------------------------*/

/*-----------------------------------------------------------------------------\
@RoutineName :: QTMakeMovieAtom

@Description ::
    Constructs a QT Movie Atom

@Parameters  ::
    QTParams *prmQT     ::  Pointer to QT configuration structure
    Uint8 *atomBuff     ::  Memory Pointer where the Movie Atom will be stored

@Return      ::
    Atom size in bytes

\-----------------------------------------------------------------------------*/
Uint32 QTMakeMovieAtom(QTParams *prmQT, Uint8 *atomBuff) {
    Bytestream  STREAM, *stream;
    Uint32       count_moov, count_end;

    if( atomBuff == NULL || prmQT == NULL )
        return 0;

    prmQT->Duration  = prmQT->SampleDuration * prmQT->Scount;

    stream = &STREAM;
    stream->ptr8    = 0;
    stream->databuf = (Uint8*)atomBuff;

    {
        count_moov = stream->ptr8;
        stream->ptr8+=4;
        put_bytes(stream, 4, ('m'<<24)+('o'<<16)+('o'<<8)+'v');

        MovieHeaderAtom(stream, prmQT->Timescale, prmQT->Duration);

        if(prmQT->audioPrmQT.IncludeAudio)
            QTMakeAudioTrakAtom(stream, prmQT);
        QTMakeVideoTrakAtom(stream, prmQT);

        TrackUserDataAtom(stream);

        count_end = stream->ptr8;
        stream->ptr8 = count_moov;
        put_bytes(stream, 4, (count_end-count_moov));
    }
    return count_end;       /* atom size in bytes   */
}


void QTMakeVideoTrakAtom(Bytestream *stream, QTParams *prmQT) {
    Uint32 count_trak, count_media, count_minf,count_stbl, count_end;
    /* Video Track atom         */
    count_trak = stream->ptr8;
    stream->ptr8+=4;
    put_bytes(stream, 4, ('t'<<24)+('r'<<16)+('a'<<8)+'k');

    TrackHeaderAtom(stream, QT_VIDEO_TRACK_ID, prmQT->Duration,prmQT->Width, prmQT->Height);
    TrackEditAtom(stream, prmQT->Duration, prmQT->MediaTime, prmQT->MediaRate);
    TrackUserDataAtom(stream);
    {

        count_media = stream->ptr8;
        stream->ptr8+=4;
        put_bytes(stream, 4, ('m'<<24)+('d'<<16)+('i'<<8)+'a');

        TrackMediaHeaderAtom(stream, prmQT->Timescale, prmQT->Duration);
        TrackMediaHeaderReferenceAtom(stream, 0, 1, 0, 0);
        {

            count_minf = stream->ptr8;
            stream->ptr8+=4;
            put_bytes(stream, 4, ('m'<<24)+('i'<<16)+('n'<<8)+'f');

            TrackMediaHeaderReferenceAtom(stream, 1, 1, 0, 0);
            TrackMediaDataInformationAtom(stream);
            TrackMediaVideoMediaInfoHeaderAtom(stream, prmQT->GraphicsMode, prmQT->Opcolor);
            {

                count_stbl = stream->ptr8;
                stream->ptr8+=4;
                put_bytes(stream, 4, ('s'<<24)+('t'<<16)+('b'<<8)+'l');

                TrackMediaVideoSampleDescriptionAtom(stream,
                    prmQT->Width,           prmQT->Height,          prmQT->DataFormat,
                    prmQT->TemporalQuality, prmQT->SpatialQuality,  prmQT->Hres,
                    prmQT->Vres,            prmQT->FramePerSample,  prmQT->ColorDepth,
                    prmQT->FieldCount,      prmQT->FieldOrdering, prmQT->ChunkOffset,
					prmQT->ESDSAtomInfo
                    );

                TrackMediaTimetoSampleAtom(stream, prmQT->Scount, prmQT->SampleDuration);
                TrackMediaSampleSizeAtom(stream, 0, prmQT->Scount, prmQT->Ssize);
                TrackMediaSampletoChunkAtom(stream, prmQT->Scount);
                TrackMediaChunkOffsetAtom(stream, 1, prmQT->ChunkOffset+QT_CHUNK_OFFSET, NULL);
                TrackMediaSampleSyncAtom( stream, prmQT->Scount, prmQT->DataFormat, prmQT->KeyFrameInterval );

                count_end = stream->ptr8;
                stream->ptr8 = count_stbl;
                put_bytes(stream, 4, (count_end-count_stbl));

            }

            stream->ptr8 = count_minf;
            put_bytes(stream, 4, (count_end-count_minf));

        }

        stream->ptr8 = count_media;
        put_bytes(stream, 4, (count_end-count_media));
    }

    stream->ptr8 = count_trak;
    put_bytes(stream, 4, (count_end-count_trak));

    stream->ptr8 = count_end;
}

void QTMakeAudioTrakAtom(Bytestream *stream, QTParams *prmQT) {
    Uint32 count_trak, count_media, count_end, count_minf, count_stbl;

    count_trak = stream->ptr8;

    stream->ptr8+=4;
    put_bytes(stream, 4, ('t'<<24)+('r'<<16)+('a'<<8)+'k');

    TrackHeaderAtom(stream, QT_AUDIO_TRACK_ID, prmQT->Duration, 0, 0 );
    TrackEditAtom(stream, prmQT->Duration, prmQT->MediaTime, prmQT->MediaRate );
    TrackUserDataAtom(stream);
    {

      count_media = stream->ptr8;

      stream->ptr8 += 4;
      put_bytes(stream, 4, ('m'<<24)+('d'<<16)+('i'<<8)+'a');
      TrackMediaHeaderAtom(stream, prmQT->audioPrmQT.SamplingRate, prmQT->audioPrmQT.AudioDataSize);
      TrackMediaHeaderReferenceAtom(stream, 0, 0, 0, 0x00010177);
      {

        count_minf = stream->ptr8;

        stream->ptr8+=4;
        put_bytes(stream, 4, ('m'<<24)+('i'<<16)+('n'<<8)+'f');

        TrackMediaHeaderReferenceAtom(stream, 1, 0, 0x40000001, 0x0001004b);
        TrackMediaDataInformationAtom(stream);
        TrackMediaSoundMediaInfoHeaderAtom(stream);

        {

          count_stbl = stream->ptr8;
          stream->ptr8+=4;

          put_bytes(stream, 4, ('s'<<24)+('t'<<16)+('b'<<8)+'l');
          TrackMediaSoundSampleDescriptionAtom(stream, prmQT->audioPrmQT.AudioChannels, 16, prmQT->audioPrmQT.SamplingRate<<16);

          TrackMediaTimetoSampleAtom(stream, prmQT->audioPrmQT.AudioDataSize, 1);
          TrackMediaSampleSizeAtom(stream, 1, prmQT->audioPrmQT.AudioDataSize, NULL);
          TrackMediaSampletoChunkAtom(stream, prmQT->audioPrmQT.AudioDataSize);
          TrackMediaChunkOffsetAtom(stream, 1, QT_CHUNK_OFFSET + prmQT->Videosize, NULL);
          count_end = stream->ptr8;
          stream->ptr8 = count_stbl;
          put_bytes(stream, 4, (count_end-count_stbl));
        }

        stream->ptr8 = count_minf;
        put_bytes(stream, 4, (count_end-count_minf));

       }

       stream->ptr8 = count_media;
       put_bytes(stream, 4, (count_end-count_media));
     }

     stream->ptr8 = count_trak;
     put_bytes(stream, 4, (count_end-count_trak));


     stream->ptr8 = count_end;
}

/*-----------------------------------------------------------------------------\
@RoutineName :: put_bytes

@Description ::
    Utility routine to put a 4-byte word into a byte stream in big endian format

@Parameters  ::
    Bytestream *stream      ::  Pointer to the byte stream
    short nbytes            ::  number of bytes to put into the byte stream
    Uint32 code              ::  The 4-byte word to put into the byte stream

@Return      ::
    NONE

\-----------------------------------------------------------------------------*/
void put_bytes(Bytestream *stream, short nbytes, Uint32 code) {
     int ptr8, i;

     ptr8  = stream->ptr8;

     if(nbytes==0)
         return;

     if(nbytes>4)
        nbytes=4;

     for(i=0;i<nbytes;i++) {
        stream->databuf[ptr8+i] = ( code >> ( 8*(nbytes-i-1)) ) & 0xFF;
     }
     stream->ptr8 += nbytes;
}