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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

OGGContainerFile.cpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       OGGContainerFile.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:                                                   *
 *                                                                      *
 *                                                                      *
 *                                                                      *
 ***********************************************************************/

#ifdef ENABLE_OGG

#include "OGGContainerFile.hpp"
#include "ContainerInfo.hpp"
#include "VideoESInfo.hpp"
#include "AudioESInfo.hpp"
#include "DataChannel.hpp"

#include "io/UnbufferedFileByteStream.hpp"
#include "io/HttpByteStream.hpp"
#include "io/OGGMuxDemuxIO.hpp"

ContainerInfo *ci = NULL;
OGGHandler *ogh = NULL;

VMutex *oggMutex;
bool initialized = false;

OGGStreamInfo::OGGStreamInfo(){
  dprintf_full("OGGStreamInfo::OGGStreamInfo()\n");
  setNext(NULL);
  setStreamID(-1);
  setStreamState(NULL);
  setCodecInfo(NULL);
  setCodecComment(NULL);
  setStreamType(OGG_UNKNOWN);
}

OGGStreamInfo::~OGGStreamInfo(){
  dprintf_full("OGGStreamInfo::~OGGStreamInfo()\n");
  if(getNext() != NULL)
    delete getNext();
  next=NULL;
        
  if(getStreamState() != NULL)
    delete oss;
  oss=NULL;

  if(getCodecInfo() != NULL){
    if(getStreamType() == OGG_THEORA){
      theora_info_clear((theora_info*)&codec_info);
      delete (theora_info*)&codec_info;
    } else if(getStreamType() == OGG_VORBIS){
      vorbis_info_clear((vorbis_info*)&codec_info);
      delete (vorbis_info*)&codec_info;
    }
  }
  
  codec_info=NULL;

  if(getCodecComment() != NULL){
    if(getStreamType() == OGG_THEORA){
      theora_comment_clear((theora_comment*)&codec_comment);
      delete(theora_comment*)&codec_comment;
    } else if(getStreamType() == OGG_VORBIS){
      vorbis_comment_clear((vorbis_comment*)&codec_comment);
      delete(vorbis_comment*)&codec_comment;
    }
  }
  codec_comment=NULL;
}


void OGGStreamInfo::append(OGGStreamInfo *osi){
  dprintf_full("OGGStreamInfo::append()\n");
  // if first OGGStreamInfo, copy
  if(getStreamID() == -1){
    dprintf_full("OGGStreamInfo::append(): inserting...\n");
    setStreamID(osi->getStreamID());
    setStreamState(osi->getStreamState());
    setCodecInfo(osi->getCodecInfo());
    setCodecComment(osi->getCodecComment());
    setStreamType(osi->getStreamType());
  }
  // else append
  else{
    dprintf_full("OGGStreamInfo::append(): appending...\n");
    OGGStreamInfo *tmp = this;
    while(tmp->getNext() != NULL) tmp = tmp->getNext();
    tmp->setNext(osi);
  }
}


void OGGStreamInfo::setNext(OGGStreamInfo *osi){
  //  dprintf_full("OGGStreamInfo::setNext()\n");
  next = osi;
}


OGGStreamInfo* OGGStreamInfo::getNext(){
  dprintf_full("OGGStreamInfo::getNext()\n");
  return next;
}


void OGGStreamInfo::setStreamID(long id){
  //  dprintf_full("OGGStreamInfo::setStreamID(%li)\n",id);
  streamid = id;
}


long OGGStreamInfo::getStreamID(){
  //  dprintf_full("OGGStreamInfo::getStreamID() = %li\n",streamid);
  return streamid;
}


void OGGStreamInfo::setStreamState(ogg_stream_state *o){
  //  dprintf_full("OGGStreamInfo::setStreamState()\n");
  oss = o;
}


ogg_stream_state* OGGStreamInfo::getStreamState(){
  //  dprintf_full("OGGStreamInfo::getStreamState()\n");
  return oss;
}


ogg_stream_state* OGGStreamInfo::getStreamState(int serial){
  dprintf_full("OGGSTREAMINFO::getStreamState(%i)\n",serial);
  if(getStreamID() == serial){
    dprintf_full("OGGStreamInfo::getStreamState(%i): returning Stream with serialno %i\n",
                 serial, serial);
    return getStreamState();
  }
  if(!getNext()){
    dprintf_err("OGGStreamInfo::getStreamState(%i): no Stream with Serialno %i found\n",
                serial, serial);
    return NULL;
  }
  return
    getNext()->getStreamState(serial);
}


void OGGStreamInfo::setCodecInfo(void* ci){
  //  dprintf_full("OGGStreamInfo::setCodecInfo()\n");
  codec_info = ci;
}


void* OGGStreamInfo::getCodecInfo(){
  //  dprintf_full("OGGStreamInfo::getCodecInfo()\n");
  return codec_info;
}


void OGGStreamInfo::setCodecComment(void* cc){
  //  dprintf_full("OGGStreamInfo::setCodecComment()\n");
  codec_comment = cc;
}


void* OGGStreamInfo::getCodecComment(){
  //  dprintf_full("OGGStreamInfo::getCodecComment()\n");
  return codec_comment;
}


void OGGStreamInfo::setStreamType(OGGStreamType ost){
  dprintf_full("OGGStreamInfo::setStreamType(%i)\n",ost);
  streamtype = ost;
}


OGGStreamType OGGStreamInfo::getStreamType(){
  dprintf_full("OGGStreamInfo::getStreamType() = %i\n",streamtype);
  return streamtype;
}


OGGHandler* OGGContainerFile::getOGGHandler(){
  return ogh;
}


#define SIZE 4096
int OGGContainerFile::bufferData(ByteStream *stream, ogg_sync_state *oy) {
  int bytes = 0;
  char * buffer = ogg_sync_buffer(oy, SIZE);
  bytes = stream->read(buffer, SIZE);
  if(ogg_sync_wrote(oy, bytes)==-1){
    dprintf_err("OGGContainerFile::bufferData: Buffer overflow in ogg_sync_state!");
    ::exit(0);
  }
  dprintf_full("OGGContainerFile::bufferData: read %i bytes\n", bytes);
  // if(bytes==-1)::exit(0);
  return bytes;
}

void OGGContainerFile::initialize(){
  dprintf_full("OGGContainerFile::initialize()\n");
  oggMutex = new VMutex("oggMutex");
}

void OGGContainerFile::oggMutexLock(const char *s){
  /*
  dprintf_full("OGGContainerFile::oggMutexLock(): %s request...\n",s);
  oggMutex->lock();
  dprintf_full("OGGContainerFile::oggMutexLock(): %s got lock...\n",s);
  */
}

void OGGContainerFile::oggMutexRelease(const char *s){
  /*
  oggMutex->release();
  dprintf_full("OGGContainerFile::oggMutexRelease(): %s released...\n",s);
  */
}

void OGGContainerFile::printOggData(const char* c, const Frame* f){
  ogg_packet *op;
  if(f){
    op = (ogg_packet*)f->getAU()->payload;
    if(op){
#if 0
      dprintf_full("OggData in %s (packetno: %li) [ogg_packet_p: %p]\n",c, (long)op->packetno, op);
      int ret;
      for(ret=0; ret<op->bytes; ret++)
        printf("%02x ",op->packet[ret]);
      printf("\n");
#endif
    }else{
      dprintf_full("OggData in %s contains no data!\n",c);
    }
  }
}


ContainerInfo *OGGContainerFile::loadContainerInfo(const Url* uri, ByteStream *stream ) {
  if(!initialized){
    initialize();
  }

  // OGGHandler related  
  OGGStreamInfo *osi = new OGGStreamInfo();
  ogh = new OGGHandler();
  ogh->osi = osi;
  
  // OGG related
  ogg_page og;
  ogg_packet op;

  // THEORA related
  theora_info *ti;
  theora_comment *tc;
  ogg_stream_state *to;
  int theora_found = 0;
  int theora_stream_id = 0;
  tc = new theora_comment;
  ti = new theora_info;
  to = new ogg_stream_state;

  // VORBIS related
  vorbis_info *vi;
  vorbis_comment *vc;
  ogg_stream_state *vo;
  int vorbis_found = 0;
  int vorbis_stream_id = 0;
  vc = new vorbis_comment;
  vi = new vorbis_info;
  vo = new ogg_stream_state;

  const char* pUri=NULL;
  if(uri)
    pUri=uri->toString();
                
        if (stream == NULL) { //reopen the byteStream
                if (strstr(uri->getProtocol(), "file"))
                        stream = new UnbufferedFileByteStream(uri->getPath(), true /* forReading */);
                else if (strstr(uri->getProtocol(), "http"))
                        stream = new HttpByteStream(uri->toString(), true /* forReading */);
        }

        if (!stream->open()) {
    dprintf_err("OGGContainerFile::loadContainerInfo: file not found: %s!\n", pUri);
    return NULL;
  }
        
  dprintf_full("OGGContainerFile::loadContainerInfo: Init... url %s\n",pUri);

  ci = new ContainerInfo(pUri, uri->getPath(), ContainerInfo::OGG);
  assert(ci);
  ci->setMuxDemuxIO(new OGGMuxDemuxIO(stream));

  /* init ogg sync state */
  ogg_sync_init(&(ogh->oy));

  /* init Theora structures */
  theora_comment_init(tc);
  theora_info_init(ti);

  /* init Vorbis structures */
  vorbis_comment_init(vc);
  vorbis_info_init(vi);

  /* open Ogg file and headers
   * I'm only interested in Theora and Vorbis streams right now
   */
  bool bosFinished = false;
  while(!bosFinished){
    int ret = bufferData(stream, &(ogh->oy));
    // FIXME: what to do @ error?
    if(ret==0){
      dprintf_err("OGGContainerFile::loadContainerInfo: ERROR! bufferData returned 0!!!\n");
      exit(0);
    }

    /*
     * grep pages which indicate 
     * 'beginning of stream' (bos)
     * out of ogg_sync_state
     */
    while(ogg_sync_pageout(&(ogh->oy), &og) > 0){
      /* stream state to get info on a specific stream */
      ogg_stream_state *test;
      test = new ogg_stream_state;
                        
      /* is this page still a header page
       * indicating Beginning Of (logical) Stream?
       */
      if(!ogg_page_bos(&og)){
        dprintf_err("OGGContainerFile::loadContainerInfo: EO_BOS\n");
        // save page into stream
        // stream will only accept page with equal serial#
        dprintf_full("OGGContainerFile::loadContainerInfo: PageSerial was %i\n",ogg_page_serialno(&og));
        ogg_stream_pagein(osi->getStreamState(ogg_page_serialno(&og)),&og);

        // finished header parsing...
        dprintf_full("OGGContainerFile::loadContainerInfo: bosFinished\n");
        bosFinished = true;
        break;
      }

      /* initialize a test ogg stream with serial# from page */
      ogg_stream_init(test, ogg_page_serialno(&og));
      /* hand page over to stream */
      ogg_stream_pagein(test, &og);
      /* grep packet from page in ogg stream */
      ogg_stream_packetout(test, &op);

      /* now identify the stream 
       * for now we only search for THEORA and VORBIS
       * FIXME: maybe also other formats???
       */
      int ret;
      // check if it is theora
      if((ret = theora_decode_header(ti, tc, &op)) >= 0){
        dprintf_full("OGGContainerFile::loadContainerInfo: stream %i is THEORA\n",
                    ogg_page_serialno(&og));
        // save stream state for further processing
        theora_stream_id = ogg_page_serialno(&og);
        OGGStreamInfo *tmp = new OGGStreamInfo();
        tmp->setStreamID(ogg_page_serialno(&og));
        tmp->setStreamState(test);
        tmp->setCodecInfo(ti);
        tmp->setCodecComment(tc);
        tmp->setStreamType(OGG_THEORA);
        osi->append(tmp);
        
        theora_found = 1;
      } 
      // check if it is vorbis
      else if ((ret = vorbis_synthesis_headerin(vi, vc, &op)) >= 0){
        dprintf_full("OGGContainerFile::loadContainerInfo: stream %i is VORBIS\n",
                     ogg_page_serialno(&og));
        // save stream state for further processing
        vorbis_stream_id = ogg_page_serialno(&og);
        OGGStreamInfo *tmp = new OGGStreamInfo();
        tmp->setStreamID(ogg_page_serialno(&og));
        tmp->setStreamState(test);
        tmp->setCodecInfo(vi);
        tmp->setCodecComment(vc);
        tmp->setStreamType(OGG_VORBIS);
        osi->append(tmp);

        vorbis_found = 1;
      } else {
        // for now we throw away other streams ;)
        dprintf_full("OGGContainerFile::loadContainerInfo: stream %i is of unknown TYPE...\
                     throwing away!\n",
                    ogg_page_serialno(&og));
        ogg_stream_clear(test);
        delete test;
        test = NULL;
      }
    }
  }

  // if first streamID is -1, no appropriate Stream has been found :(
  if(osi->getStreamID() == -1){
    dprintf_err("OGGContainerFile::loadContainerInfo: \
                        NO APPROPRIATE STREAM FOUND :( ... ABORTING.");
    exit(0);
  } else {
    dprintf_full("OGGContainerFile::loadContainerInfo: Found Stream(s) in OGG-Container...\n");
  }

  /*
   * now we got ogg_streams...
   * try further header parsing
   * there should be 3 (still 2 more)
   * theora and/or vorbis header packets
   */

  //  bool finished = false;
  while((theora_found && theora_found < 3) ||
        (vorbis_found && vorbis_found < 3)){
    int ret = -1;

    // do we have theora and haven't got three header packets
    // AND we still get packets out of the theora ogg stream state
    if(theora_found){
      to = osi->getStreamState(theora_stream_id);
      while((theora_found && theora_found < 3) &&
            (ret=ogg_stream_packetout(to, &op)) >= 0){
        if(ret < 0){
          dprintf_err("OGGContainerFile::loadContainerInfo: theora packetout: "
                      "Error parsing Theora stream headers; "
                      "corrupt stream???\n");
          exit(1);
        }
        if(theora_decode_header(ti, tc, &op)){
          dprintf_err("OGGContainerFile::loadContainerInfo: theora decode header: "
                      "Error parsing Theora stream headers; "
                      "corrupt stream???\n");
          exit(1);
        }
        dprintf_full("further THEORA-Header found (%i)\n",theora_found);
        theora_found++;
      } // while
      dprintf_full("THEORA RET = %i, theora_found = %i\n",ret,theora_found);
    } // if

    // parse further vorbis headers
    if(vorbis_found){
      vo = osi->getStreamState(vorbis_stream_id);
      while((vorbis_found && vorbis_found < 3) &&
            (ret=ogg_stream_packetout(vo, &op)) > 0){
        if(ret < 0){
          dprintf_err("OGGContainerFile::loadContainerInfo: vorbis packetout: "
                      "Error parsing Vorbis stream headers; "
                      "corrupt stream???\n");
          exit(1);
        }
        if(vorbis_synthesis_headerin(vi,vc,&op)){
          dprintf_err("OGGContainerFile::loadContainerInfo: vorbis headerin: "
                      "Error parsing Vorbis stream headers; "
                      "corrupt stream???\n");
          exit(1);
        }
        dprintf_full("further VORBIS-Header found (%i) (granulepos: %i)\n",vorbis_found,(uint)op.granulepos);
        vorbis_found++;
      }
      dprintf_full("VORBIS RET = %i, vorbis_found = %i\n",ret,vorbis_found);
    }
      
    /*
     * header is before anything else..
     * so get next page and check if it's 
     * a header page in next loop
     */
    if(ogg_sync_pageout(&(ogh->oy), &og) > 0){
      ogg_stream_pagein(osi->getStreamState(ogg_page_serialno(&og)), &og);
    } else {
      // if there is no page in sync get next one
      if(bufferData(stream, &(ogh->oy)) == 0){
        dprintf_full("OGGContainerFile::loadContainerInfo: EOF while searching for codec headers.\n");
        exit(1);
      }
      
      {
        // now try a pageout
        int ret = 0;
        while((ret=ogg_sync_pageout(&(ogh->oy), &og))>0){
          // queue page in appropriate stream
          // search for appropriate stream and buffer page
          if(osi->getStreamState(ogg_page_serialno(&og)))
            ogg_stream_pagein(osi->getStreamState(ogg_page_serialno(&og)), &og);
        }
      }
    } // if(pageout)
  } // while theora && / || vorbis < 3
  

  if(theora_found==3){
    dprintf_full(" **************** THEORA ***************\n");
    int i, len;
    char *value;
    //FILE *out=stdout;

    dprintf_full("Encoded By %s\n",tc->vendor);
    if(tc->comments){
      dprintf_full("Theora Comment Header:\n");
      for(i=0;i<tc->comments;i++){
        if(tc->user_comments[i]){
          len=tc->comment_lengths[i];
          value=(char*)malloc(len+1);
          memcpy(value,tc->user_comments[i],len);
          value[len]='\0';
          dprintf_full("\t%s\n", value);
          free(value);
        }
      }
    }
    dprintf_full("width:              %i\n",ti->width);
    dprintf_full("height:             %i\n",ti->height);
    dprintf_full("frame_Width:        %i\n",ti->frame_width);
    dprintf_full("frame_Height:       %i\n",ti->frame_height);
    dprintf_full("offset_X:           %i\n",ti->offset_x);
    dprintf_full("offset_Y:           %i\n",ti->offset_y);
    dprintf_full("fps_Numerator:      %i\n",ti->fps_numerator);
    dprintf_full("fps_Denominator:    %i\n",ti->fps_denominator);
    dprintf_full("aspect_Numerator:   %i\n",ti->aspect_numerator);
    dprintf_full("aspect_Denominator: %i\n",ti->aspect_denominator);
    dprintf_full("colorspace:         %s\n",
                (ti->colorspace == OC_CS_UNSPECIFIED ? "Oc_Cs_Unspecified" :
                 ti->colorspace == OC_CS_ITU_REC_470M ? "Oc_Cs_Itu_Rec_470m" :
                 ti->colorspace == OC_CS_ITU_REC_470BG ? "Oc_Cs_Itu_Rec_470bg" :
                 "Oc_Cs_Nspaces")
                );
    dprintf_full("target_Bitrate:     %i\n",ti->target_bitrate);
    dprintf_full("quality:            %i\n",ti->quality);
    dprintf_full("quick_P:            %i\n",ti->quick_p);
    dprintf_full("version_major:      %s\n",&ti->version_major);
    dprintf_full("version_minor:      %s\n",&ti->version_minor);
    dprintf_full("version_subminor:   %s\n",&ti->version_subminor);
    dprintf_full(" ***************************************\n");
  }
  if(vorbis_found==3){
    dprintf_full(" **************** VORBIS ***************\n");
    int i, len;
    char *value;
    dprintf_full("Encoded By %s\n",vc->vendor);
    if(vc->comments){
      dprintf_full("Vorbis Comment Header:\n");
      for(i=0;i<vc->comments;i++){
        if(vc->user_comments[i]){
          len=vc->comment_lengths[i];
          value=(char*)malloc(len+1);
          memcpy(value,vc->user_comments[i],len);
          value[len]='\0';
          dprintf_full("\t%s\n", value);
          free(value);
        }
      }
    }
    dprintf_full("version:         %i\n",vi->version);
    dprintf_full("channels:        %i\n",vi->channels);
    dprintf_full("rate:            %li\n",vi->rate);
    dprintf_full("bitrate_upper:   %li\n",vi->bitrate_upper);
    dprintf_full("bitrate_nominal: %li\n",vi->bitrate_nominal);
    dprintf_full("bitrate_lower:   %li\n",vi->bitrate_lower);
    dprintf_full("bitrate_window:  %li\n",vi->bitrate_window);
    dprintf_full(" ***************************************\n");
  }

  /*
   * create the ESInfo-Object
   */
  if(vorbis_found){
    ESInfo *esi;
    int time_increment = (int)((1024.0/(float)vi->rate)*90000.0); //(int)(1024.0*(90000.0/vi->rate)); //576/vi->rate/2;
    int bits_per_sample = 16;//(36864)/(576*vi->channels*2);
    dprintf_full("OGGContainerFile::loadContainerInfo: BLA Vorbis_time_increment = %i, BPS = %i, %liHz, %i Channels\n",
                 time_increment, bits_per_sample, vi->rate, vi->channels);
    esi = new AudioESInfo(
                          vo->serialno,
                          OGG_VORBIS,
                          ci,
                          time_increment,      // time increment
                          NULL,                // encodeddecoderconfig
                          0, 
                          0,
                          vi->bitrate_nominal,
                          vi->bitrate_nominal,
                          90000,
                          0,                   // duration
                          0,                   // mediaSize
                          vi->rate,            // sampleRate
                          vi->channels,        // channels
                          true,
                          CODEC_ID_VORBIS,     // CodecID
                          1.0,                 // Quality
                          bits_per_sample      // bits_per_sample
                          );
    ((AudioESInfo*)esi)->setChannelMod(vi->channels);
    assert(ci);
    ci->addESInfo(esi);
    dprintf_full("OGGContainerFile::loadContainerInfo: DescriptionText = %s\n", esi->getDescriptionText());
  }
  if(theora_found){
    ESInfo *esi;
    float aspectRatio = 1;
    int time_increment = (int)(90000.0/((float)(ti->fps_numerator / ti->fps_denominator)));

    if((ti->aspect_numerator == 1 && ti->aspect_denominator == 1) ||
       (ti->aspect_numerator == 0 && ti->aspect_denominator == 0))
      aspectRatio = (float)ti->width / ti->height;
    else
      aspectRatio = (float)ti->aspect_numerator / ti->aspect_denominator;
    esi = new VideoESInfo(
                          to->serialno,          // streamID
                          OGG_THEORA,            // streamtype
                          ci,                    // ContainerInfo
                          time_increment, // 3600,                       // time Increment
                          NULL,                  // encodedDecoderConfig
                          0,                     // objtype
                          0,                     // bufsize
                          ti->target_bitrate,    // avgBW
                          ti->target_bitrate,    // maxBW
                          90000,                 // timescale
                          0,                     // duration
                          0,                     // mediaSize
                          ti->width,             // width
                          ti->height,            // height
                          true,                  // colorVideo
                          true,                  // complete
                          CODEC_ID_THEORA,       // CodecID
                          1.0,                   // Quality
                          aspectRatio            // aspectratio
                          );
    
    //float fps = (float)(((float)ti->fps_numerator) / ((float)ti->fps_denominator));
    //dprintf_full("OGGContainerFile::loadContainerInfo: esi->FPS = %f = ( %i / %i )\n",fps, ti->fps_numerator, ti->fps_denominator);
    //((VideoESInfo*)esi)->setFPS((float)((float)ti->fps_numerator / (float)ti->fps_denominator));
    esi->setInput( uri->toString());
    assert(ci);
    ci->addESInfo(esi);
    
    
    //fclose(io);
    //exit(0);
  }
  return ci;
  
}

#endif // WINCE

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