Home    News    Components    Get ViTooKi    Documentation    Community    Developers    @sf.net  

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

MKContainerFile.cpp

#ifndef WIN32

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       MKContainerFile.cpp                                        *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 * ITEC institute of the University of Klagenfurt (Austria)             *
 * http://www.itec.uni-klu.ac.at                                        *
 *                                                                      *
 *                                                                      *
 * For more information visit the ViTooKi homepage:                     *
 * http://ViTooKi.sourceforge.net                                       *
 * vitooki-user@lists.sourceforge.net                                   *
 * vitooki-devel@lists.sourceforge.net                                  *
 *                                                                      *
 * This file is part of ViTooKi, a free video toolkit.                  *
 * ViTooKi is free software; you can redistribute it and/or             *
 * modify it under the terms of the GNU General Public License          *
 * as published by the Free Software Foundation; either version 2       *
 * of the License, or (at your option) any later version.               *
 *                                                                      *
 * This program is distributed in the hope that it will be useful,      *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of       *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the         *
 * GNU General Public License for more details.                         *
 *                                                                      *
 * You should have received a copy of the GNU General Public License    *
 * along with this program; if not, write to the Free Software          *
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston,               *
 * MA  02111-1307, USA.                                                 *
 *                                                                      *
 ***********************************************************************/

 /***********************************************************************
 *                                                                      *
 *  REVISION HISTORY:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <fcntl.h>

/* windows-specific */
#ifdef WIN32
#include <io.h>
#endif

#include "MatroskaParser.h"

#include "MKContainerFile.hpp"
#include "ContainerInfo.hpp"
#include "VideoESInfo.hpp"
#include "AudioESInfo.hpp"
#include "DataChannel.hpp"
#include "DataSink.hpp"
#include "Adaptor.hpp"
#include "AdaptorChain.hpp"
#include "MP3Parser.hpp"

#include "../adaptors/MP4Decoder.hpp"

#include "../io/DevNull.hpp"
#include "../io/MPGStreamIO.hpp"

#include "../net/Url.hpp"
#include "../net/SDP.hpp"

/* Matroska Codec definition*/
#define MATROSKA_CODEC_ID_VIDEO_VFW_FOURCC   "V_MS/VFW/FOURCC"
#define MATROSKA_CODEC_ID_VIDEO_UNCOMPRESSED "V_UNCOMPRESSED"
#define MATROSKA_CODEC_ID_VIDEO_MPEG4_SP     "V_MPEG4/ISO/SP"
#define MATROSKA_CODEC_ID_VIDEO_MPEG4_ASP    "V_MPEG4/ISO/ASP"
#define MATROSKA_CODEC_ID_VIDEO_MPEG4_AP     "V_MPEG4/ISO/AP"
#define MATROSKA_CODEC_ID_VIDEO_MPEG4_AVC    "V_MPEG4/ISO/AVC"
#define MATROSKA_CODEC_ID_VIDEO_MSMPEG4V3    "V_MPEG4/MS/V3"
#define MATROSKA_CODEC_ID_VIDEO_MPEG1        "V_MPEG1"
#define MATROSKA_CODEC_ID_VIDEO_MPEG2        "V_MPEG2"
#define MATROSKA_CODEC_ID_VIDEO_MJPEG        "V_MJPEG"
#define MATROSKA_CODEC_ID_VIDEO_THEORA       "V_THEORA"
/* TODO: Real/Quicktime */

#define MATROSKA_CODEC_ID_AUDIO_ACM          "A_MS/ACM"
#define MATROSKA_CODEC_ID_AUDIO_MPEG1_L1     "A_MPEG/L1"
#define MATROSKA_CODEC_ID_AUDIO_MPEG1_L2     "A_MPEG/L2"
#define MATROSKA_CODEC_ID_AUDIO_MPEG1_L3     "A_MPEG/L3"
#define MATROSKA_CODEC_ID_AUDIO_PCM_INT_BE   "A_PCM/INT/BIG"
#define MATROSKA_CODEC_ID_AUDIO_PCM_INT_LE   "A_PCM/INT/LIT"
#define MATROSKA_CODEC_ID_AUDIO_PCM_FLOAT    "A_PCM/FLOAT/IEEE"
#define MATROSKA_CODEC_ID_AUDIO_AC3          "A_AC3"
#define MATROSKA_CODEC_ID_AUDIO_DTS          "A_DTS"
#define MATROSKA_CODEC_ID_AUDIO_VORBIS       "A_VORBIS"
#define MATROSKA_CODEC_ID_AUDIO_ACM          "A_MS/ACM"
#define MATROSKA_CODEC_ID_AUDIO_MPEG2        "A_AAC/MPEG2/"
#define MATROSKA_CODEC_ID_AUDIO_MPEG4        "A_AAC/MPEG4/"
/* TODO: AC3-9/10 (?), Real, Musepack, Quicktime */

/* first we need to create an I/O object that the parser will use to read the
 * source file
 */
struct StdIoStream {
  struct InputStream  base;
  FILE                *fp;
  int                 error;
};
typedef struct StdIoStream StdIoStream;

#define CACHESIZE     65536

/* StdIoStream methods */

/* read count bytes into buffer starting at file position pos
 * return the number of bytes read, -1 on error or 0 on EOF
 */
int   StdIoRead(StdIoStream *st, ulonglong pos, void *buffer, int count) {
  size_t  rd;
  if (fseek(st->fp, pos, SEEK_SET)) {
    st->error = errno;
    return -1;
  }
  rd = fread(buffer, 1, count, st->fp);
  if (rd == 0) {
    if (feof(st->fp))
      return 0;
    st->error = errno;
    return -1;
  }
  return rd;
}

/* scan for a signature sig(big-endian) starting at file position pos
 * return position of the first byte of signature or -1 if error/not found
 */
longlong StdIoScan(StdIoStream *st, ulonglong start, unsigned signature) {
  int         c;
  unsigned    cmp = 0;
  FILE        *fp = st->fp;

  if (fseek(fp, start, SEEK_SET))
    return -1;

  while ((c = getc(fp)) != EOF) {
    cmp = ((cmp << 8) | c) & 0xffffffff;
    if (cmp == signature)
      return ftell(fp) - 4;
  }

  return -1;
}

/* return cache size, this is used to limit readahead */
unsigned StdIoGetCacheSize(StdIoStream *st) {
  return CACHESIZE;
}

/* return last error message */
const char *StdIoGetLastError(StdIoStream *st) {
  return strerror(st->error);
}

/* memory allocation, this is done via stdlib */
void  *StdIoMalloc(StdIoStream *st, size_t size) {
  return malloc(size);
}

void  *StdIoRealloc(StdIoStream *st, void *mem, size_t size) {
  return realloc(mem,size);
}

void  StdIoFree(StdIoStream *st, void *mem) {
  free(mem);
}

/* progress report handler for lengthy operations
 * returns 0 to abort operation, nonzero to continue
 */
int   StdIoProgress(StdIoStream *st, ulonglong cur, ulonglong max) {
  return 1;
}


ContainerInfo *MKContainerFile::loadContainerInfo(const char *fileName, const Url* uri) {
        
        dprintf_full("MKContainerFile: :loadContainerInfo: Init...\n");
        
        StdIoStream     st;
        MatroskaFile    *mf;
        char            err_msg[256];
        unsigned        i;
        //int           track;
        int             streamcnt;
        //FILE          *out = stdout;


        /* fill in I/O object */
        memset(&st,0,sizeof(st));
        st.base.read = reinterpret_cast<int(*)(InputStream*, long long unsigned int,void*,int)>(StdIoRead);
        st.base.scan = reinterpret_cast<long long(*)(InputStream*,long long unsigned int, unsigned int)>(StdIoScan);
        st.base.getcachesize = reinterpret_cast<unsigned int(*)(InputStream*)>(StdIoGetCacheSize);
        st.base.geterror = reinterpret_cast<const char*(*)(InputStream*)>(StdIoGetLastError);
        st.base.memalloc = reinterpret_cast<void*(*)(InputStream*,unsigned int)>(StdIoMalloc);
        st.base.memrealloc = reinterpret_cast<void*(*)(InputStream*,void*,unsigned int)>(StdIoRealloc);
        st.base.memfree = reinterpret_cast<void(*)(InputStream*,void*)>(StdIoFree);
        st.base.progress = reinterpret_cast<int(*)(InputStream*,long long unsigned int,long long unsigned int)>(StdIoProgress);
                
        dprintf_full("MKContainerFile::loadContainerInfo: Opening Video...\n");
        /* open source file */
        st.fp = fopen(fileName,"rb");
        if (st.fp == NULL) {
                dprintf_full("MKContainerFile::loadContainerInfo: Can't open '%s'\n", fileName);
                exit(1);
        }
        setvbuf(st.fp, NULL, _IOFBF, CACHESIZE);

        /* initialize matroska parser */
        mf = mkv_OpenEx(&st.base, /* pointer to I/O object */
        0, /* starting position in the file */
        0, /* flags, you can set MKVF_AVOID_SEEKS if this is a non-seekable stream */
        err_msg, sizeof(err_msg)); /* error message is returned here */
        if (mf == NULL) {
                fclose(st.fp);
                dprintf_full("MKContainerFile::loadContainerInfo: Can't parse Matroska file: %s\n", err_msg);
                exit(1);
        }

        dprintf_full("MKContainerFile::loadContainerInfo: Init Matroska-parser done!\n");       

        const char* pUri=NULL;
        if(uri){
                pUri=uri->toString();
        }

        ContainerInfo * result = new ContainerInfo(pUri,fileName, ContainerInfo::MATROSKA);
        
        /* count streams, min. 1 stream required, optimally a video stream*/
        streamcnt = mkv_GetNumTracks(mf);
        if(streamcnt < 0) {
                dprintf_full("MKContainerFile::loadContainerInfo: couldn't find any ElemStreams in container!\n");
                return NULL;
        }

        // get file-information
        SegmentInfo *si = mkv_GetFileInfo(mf);
        
        //duration of video
        double duration = double(si->Duration)*(si->TimecodeScale/ 1000000.0)/ 1000000000.0;
        printf("MKContainerFile: %f\n",duration);
        double hours = duration / 3600;

        int minutes = (int(duration) % 3600)/60;

                                

        dprintf_full("MKContainerFile::loadContainerInfo: (f): Duration: %.3fs (%dh:%dm:%ds)\n",duration, int(hours), minutes, int(duration)%60);
        dprintf_full("MKContainerFile::loadContainerInfo: (f): Muxingapp: %s\n", si->MuxingApp);
        dprintf_full("MKContainerFile::loadContainerInfo: (f): Muxingapp: %s\n", si->WritingApp);
        
        /* list available streams, for debugging only? */
        dprintf_full("\n\tMKContainerFile::loadContainerInfo:### stream-info ###\n");
        for (i = 0; i < mkv_GetNumTracks(mf); ++i) {
                TrackInfo       *ti = mkv_GetTrackInfo(mf, i);
                switch(ti->Type) {
                        //Video with track# and codec
                        case TT_VIDEO: dprintf_full("\nMKContainerFile::loadContainerInfo: Track %u(#%u): %s, type: video\n", i,ti->Number, ti->CodecID);
                        dprintf_full("MKContainerFile::loadContainerInfo: (v):id: %u, Pixel width: %u, height: %u\n",int(ti->UID), ti->Video.PixelWidth, ti->Video.PixelHeight);
                        break;
                        case TT_AUDIO: dprintf_full("\nMKContainerFile::loadContainerInfo: Track %u(#%u): %s, type: audio\n", i,ti->Number, ti->CodecID);
                        dprintf_full("MKContainerFile::loadContainerInfo: (a):id: %u, SampleRate: %d\n",int(ti->UID),ti->Audio.OutputSamplingFreq);
                        break;
                        // subtitle
                        case TT_SUB: dprintf_full("\nMKContainerFile::loadContainerInfo: Track %u(#%u): %s, type: subtitle\n", i, ti->Number,ti->CodecID);
                        break;
                        default: dprintf_full("\nMKContainerFile::loadContainerInfo: Track %u(#%u): %s, type: unknown\n", i, ti->Number,ti->CodecID);break;
                }
        }       
        dprintf_full("\n\tMKContainerFile::loadContainerInfo:####################\n\n");

        char *mkvFile = new char[strlen(fileName) + 1];
        strcpy(mkvFile, fileName);      
        
        unsigned int size = 0;  
        for (int streamIndex = 0; streamIndex < streamcnt; streamIndex++) 
        {
                ESInfo *es = MKContainerFile::loadESInfo(result, streamIndex, mf);
                /*if (!es) {
                        delete es;
                        delete result;
                        delete[] mkvFile;
                        return NULL;
                }*/
                
                dprintf_full("MKContainerFile::loadContainerInfo: creating ES %i\r\n", streamIndex);
                
                //es->setInput(mkvFile);
                result->addESInfo(es);
                //size += es->getOrigMediaSize();
        }
        
        QualityInfo *qi = result->getQualityInfo();
        qi->steps[0]->size = size;
                
        delete[] mkvFile;




        return result;

}

bool saveToContainerFile(const char *fileName, ContainerInfo *ci){


        return false;
}

ESInfo *MKContainerFile::loadESInfo(ContainerInfo *vob, int streamIndex, MatroskaFile *mf)
{
        unsigned int streamId, handlerType, width, height, mediaTimeScale, totalSamples, mediaSize;
        unsigned int objectType=0, streamType=0, bufferSize=0, avgbit = 0, maxbit = 0; 
        double duration = 0;              
        float aspect_ratio = -1;
        float fps = 0.0;
        float quality = 1.0;
        unsigned int sampling_freq = 0;
        CodecID codec_video;
        CodecID codec_audio;
        unsigned int bps = 0;

        
        TrackInfo *ti = mkv_GetTrackInfo(mf, streamIndex);
        dprintf_full("MKContainerFile::loadContainerInfo: track #%u, codec: %s, type: %u\n",ti->Number, ti->CodecID, ti->Type);

        dprintf_full("MKContainerFile::loadContainerInfo: checking if video or audio\n");

        mediaTimeScale = 90000; //FIXME: quickhack for divx
        //convert time base of duration from secs to 90000 timebase
        // get file-information
        SegmentInfo *si = mkv_GetFileInfo(mf);
        
        //duration of video
        duration = double(si->Duration)/ 1000000000.0;
        //dprintf_full("MKContainerFile: duration: %.f\n", duration);
        duration = (int)ceil(duration*mediaTimeScale);
        //dprintf_full("MKContainerFile: duration: %.f\n", duration);   

        
        switch(ti->Type){
                //Video with track# and codec
                case TT_VIDEO: {
                        dprintf_full("\nMKContainerFile::loadContainerInfo: type: video\n");
                        dprintf_full("MKContainerFile::loadContainerInfo: (v):id: %u, Pixel width: %u, height: %u\n",int(ti->UID), ti->Video.PixelWidth, ti->Video.PixelHeight);
                        
                        //streamId = ti->UID; //Unique ID
                        streamId = ti->Number -1;
                        streamType = 0;//type of stream, video=0 audio=1
                        fps = 1000000000.0 / ti->DefaultDuration;       

                        totalSamples = fps * double(si->Duration)/ 1000000000.0;

                        avgbit = 0;
        
                        maxbit = 0; 

                        mediaSize = 0;

                        width = ti->Video.PixelWidth;
                        height = ti->Video.PixelHeight;

                        /* dummy value for ffmpeg */
                        //codec_video = CODEC_ID_MPEG4;

                        /* mapping from Matroska codec_ids to FFMPEG codec_ids */
                        if (!strcmp(ti->CodecID,MATROSKA_CODEC_ID_VIDEO_MPEG4_SP) ||
                                !strcmp(ti->CodecID,MATROSKA_CODEC_ID_VIDEO_MPEG4_ASP) ||
                                !strcmp(ti->CodecID,MATROSKA_CODEC_ID_VIDEO_MPEG4_AP))
                        {
                                codec_video = CODEC_ID_MPEG4;
                        }
                        else if (!strcmp(ti->CodecID,MATROSKA_CODEC_ID_VIDEO_MPEG4_AVC))
                        {
                                codec_video = CODEC_ID_H264;
                        }
                        else if (!strcmp(ti->CodecID,MATROSKA_CODEC_ID_VIDEO_MSMPEG4V3))
                        {
                                codec_video = CODEC_ID_MSMPEG4V3;
                        }
                        else if (!strcmp(ti->CodecID,MATROSKA_CODEC_ID_VIDEO_THEORA))
                        {
                                codec_video = CODEC_ID_THEORA;
                        }
                        else if (!strcmp(ti->CodecID,MATROSKA_CODEC_ID_VIDEO_MPEG1) ||
                                !strcmp(ti->CodecID,MATROSKA_CODEC_ID_VIDEO_MPEG2))
                        {
                                codec_video = CODEC_ID_MPEG2VIDEO;
                        }
                        else
                                codec_video = CODEC_ID_MPEG4;



                        aspect_ratio = (float)width/ (float)height;

                        dprintf_full("\nMKContainerFile::loadContainerInfo: (v): %.3f fps", fps);
                        dprintf_full("\nMKContainerFile::loadContainerInfo: (v): %d samples\n\n", totalSamples);
                        
                        return new VideoESInfo(streamId, streamType, vob, duration/totalSamples, NULL, objectType, bufferSize, avgbit, maxbit, mediaTimeScale, duration, 
                         mediaSize, width, height, true, true,  codec_video, quality, aspect_ratio);
                        
                        
                        break;
                }
                // Audio
                case TT_AUDIO: {
                        dprintf_full("\nMKContainerFile::loadContainerInfo: type: audio\n");
                        dprintf_full("MKContainerFile::loadContainerInfo: (a):id: %u, SampleRate: %.2f\n",int(ti->UID),ti->Audio.OutputSamplingFreq);

                        int channels =  int(ti->Audio.Channels);
                        dprintf_full("MKContainerFile::loadContainerInfo: (a): %d Channels\n", channels);
#ifdef BUILD_ARCH_ARM
                        if (channels < 2) {
                                dprintf_full("MKContainerFile::loadContainerInfo: iPAQ hack: simulating stereo audio!\n");
                                channels=2; //always set to stereo on ipaq... else --> mickey mouse
                        }
#endif

                        //streamId = ti->UID; //Unique ID
                        streamId = ti->Number -1;
                        streamType = 1;//type of stream, video=0 audio=1

                        fps = 1000000000.0 / ti->DefaultDuration;       

                        totalSamples = fps * double(si->Duration)/ 1000000000.0;

                        avgbit = 0;
        
                        maxbit = 0; 

                        mediaSize = 0;

                        sampling_freq = ti->Audio.OutputSamplingFreq;

                        /* dummy value for ffmpeg */
                        codec_audio = CODEC_ID_MP3;

                        /* mapping from Matroska codec_ids to FFMPEG codec_ids */
                        if (!strcmp(ti->CodecID,MATROSKA_CODEC_ID_AUDIO_MPEG1_L1) ||
                        !strcmp(ti->CodecID,MATROSKA_CODEC_ID_AUDIO_MPEG1_L2) ||
                        !strcmp(ti->CodecID,MATROSKA_CODEC_ID_AUDIO_MPEG1_L3))
                        {
                                codec_audio = CODEC_ID_MP3;
                        }
                        else if (!strcmp(ti->CodecID,MATROSKA_CODEC_ID_AUDIO_PCM_INT_BE))
                        {
                                codec_audio = CODEC_ID_PCM_U16BE;
                        }
                        else if (!strcmp(ti->CodecID,MATROSKA_CODEC_ID_AUDIO_PCM_INT_LE))
                        {
                                codec_audio = CODEC_ID_PCM_U16LE;
                        }
                        else if (!strcmp(ti->CodecID,MATROSKA_CODEC_ID_AUDIO_AC3))
                        {
                                codec_audio = CODEC_ID_AC3;
                        }
                        else if (!strcmp(ti->CodecID,MATROSKA_CODEC_ID_AUDIO_DTS))
                        {
                                codec_audio = CODEC_ID_DTS;
                        }
                        else if (!strcmp(ti->CodecID,MATROSKA_CODEC_ID_AUDIO_VORBIS)) 
                        {                               
                                codec_audio = CODEC_ID_VORBIS;
                        }
                        else if (!strcmp(ti->CodecID,MATROSKA_CODEC_ID_AUDIO_MPEG2) ||
                                !strcmp(ti->CodecID,MATROSKA_CODEC_ID_AUDIO_MPEG4))
                        {
                                codec_audio = CODEC_ID_AAC;
                        } 
                        else
                                codec_audio = CODEC_ID_MP3;
                        


                        // FIXME: read BitsPerSecond from mkv file
                        //bps = ti->Audio.BitDepth;
                        bps = 128000;


                        dprintf_full("\nMKContainerFile::loadContainerInfo: (a): %u bps freq\n\n", bps);

                        return new AudioESInfo(streamId, streamType, vob, 2351, NULL, objectType, bufferSize, avgbit, maxbit, mediaTimeScale, duration, mediaSize, sampling_freq, channels, true, codec_audio, quality, bps);


                        break;
                }

                // subtitle
                case TT_SUB: {
                        dprintf_full("\nMKContainerFile::loadContainerInfo: type: subtitle\n");
                        break;
                }

                // unknown stream type
                default: dprintf_full("\nMKContainerFile::loadContainerInfo: type: unknown\n");break;
        }


        return NULL;
}


#endif

© ViTooKi 2003 :: [Lite version] Created with Doxygen