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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

OGGMuxDemuxIO.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       OGGMuxDemuxIO.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 "OGGMuxDemuxIO.hpp"
#include "VideoESInfo.hpp"
#include "AudioESInfo.hpp"
#include "container/OGGContainerFile.hpp"

// redeclaration of static variables
theora_info *OGGMuxDemuxIO::ti;
theora_state *OGGMuxDemuxIO::ts;
vorbis_info *OGGMuxDemuxIO::vi;
vorbis_comment *OGGMuxDemuxIO::vc;
vorbis_dsp_state *OGGMuxDemuxIO::vd;
vorbis_block *OGGMuxDemuxIO::vb;

int OGGMuxDemuxIO::theorainitialized;
int OGGMuxDemuxIO::vorbisinitialized;

vorbis_info* OGGMuxDemuxIO::getVorbisInfo(){
  return vi;
}
vorbis_dsp_state* OGGMuxDemuxIO::getVorbisDspState(){
  return vd;
}
vorbis_block* OGGMuxDemuxIO::getVorbisBlock(){
  return vb;
}

theora_state* OGGMuxDemuxIO::getTheoraState(){
  return ts;
}
theora_info* OGGMuxDemuxIO::getTheoraInfo(){
  return ti;
}

void OGGMuxDemuxIO::initTheora(ESInfo *esi){
  /* set up Theora encoder */
  dprintf_full("OGGMuxDemuxIO::initTheora: entering...\n");
  if(!theorainitialized){
    dprintf_full("OGGMuxDemuxIO::initTheora: initializing\n");
    int frame_x, frame_y,
      video_x, video_y,
      frame_x_offset, frame_y_offset;
    
    ti = new theora_info;
    ts = new theora_state;

    frame_x = ((VideoESInfo*)esi)->getWidth();
    frame_y = ((VideoESInfo*)esi)->getHeight();
    
    // Theora has a divisible-by-sixteen restriction for the encoded video size
    // scale the frame size up to the nearest /16 and calculate offsets
    video_x = ((frame_x + 15) >>4) <<4;
    video_y = ((frame_y + 15) >>4) <<4;
    
    // force offset to be even
    // this ensures that the chroma samples align properly with the luna samples
    frame_x_offset = ((video_x-frame_x)/2) & ~1;
    frame_y_offset = ((video_y-frame_y)/2) & ~1;
    
    theora_info_init(ti);
    ti->width = video_x;
    ti->height = video_y;
    ti->frame_width = frame_x;
    ti->frame_height = frame_y;
    ti->offset_x = frame_x_offset;
    ti->offset_y = frame_y_offset;
    ti->fps_numerator = (int)((((VideoESInfo*)esi)->getFPS()) * 1000);
    ti->fps_denominator = 1000;
    ti->aspect_numerator = 1;
    ti->aspect_denominator = 1;
    ti->colorspace = OC_CS_UNSPECIFIED;
//    ti->pixelformat = OC_PF_420;
    ti->target_bitrate = esi->getAvgBandwidth(); // FIXME: 600 kbps
    dprintf_full("THEORA_ENC_SETUP: esi->getAvgBandwidth() == %u\n", esi->getAvgBandwidth());
    ti->quality = 0; // 'cause target bitrate is set
    
    ti->dropframes_p = 0;
    ti->quick_p = 1;
    ti->keyframe_auto_p = 1;
    ti->keyframe_frequency = 64;
    ti->keyframe_frequency_force = 64;
    ti->keyframe_data_target_bitrate = (ogg_uint32_t)(ti->target_bitrate * 1.5);
    ti->keyframe_auto_threshold = 80;
    ti->keyframe_mindistance = 8;
    ti->noise_sensitivity = 1;
    
    theora_encode_init(ts, ti);
  }
  
  theorainitialized=1;
}

void OGGMuxDemuxIO::initVorbis(ESInfo *esi){
  /* set up Vorbis encoder */
  dprintf_full("OGGMuxDemuxIO::initVorbis: entering...\n");
  if(!vorbisinitialized){
    dprintf_full("OGGMuxDemuxIO::initVorbis: initializing\n");

    int audio_r,
      ret,
      samplerate;

    samplerate = ((AudioESInfo*)esi)->getSampleRate();

    /*
     * audio-quality
     * int vorbis_encode_init(vorbis_info *vi,
     *                        long channels,
     *                        long rate,
     *
     *                        long max_bitrate,
     *                        long nominal_bitrate,
     *                        long min_bitrate);
     *
     * vi
     *   pointer to an initialized vorbis_info struct.
     * channels
     *   the number of channels to be encoded.
     * rate
     *   the sampling rate of the source audio.
     * max_bitrate
     *   desired maximum bitrate (limit). -1 indicates unset.
     * nominal_bitrate
     *   desired average, or central, bitrate. -1 indicates unset.
     * min_bitrate
     *   desired minimum bitrate. -1 indicates unset.
     */
    // FIXME: hardcoded 128 kbps
    audio_r = 80*1000;
    dprintf_full("OGGMuxDemuxIO::initVorbis: avgBW: %i\n",esi->getAvgBandwidth());
    audio_r = esi->getAvgBandwidth();

    vi = new vorbis_info;
    vc = new vorbis_comment;
    vd = new vorbis_dsp_state;
    vb = new vorbis_block;

    vorbis_info_init(vi);
    ret = vorbis_encode_init(vi, 2, 44100, -1, audio_r, -1);
    if(ret){
      dprintf_err("The Vorbis encoder could not set up a mode according to the requested bitrate.\n\n");
      ::exit(1);
    }
    vorbis_comment_init(vc);
    vorbis_analysis_init(vd, vi);
    vorbis_block_init(vd, vb);
  }
  vorbisinitialized = 1;
}

OGGMuxDemuxIO::OGGMuxDemuxIO(ByteStream *stream) : MuxDemuxIO(stream) {
  theorainitialized=0;
  vorbisinitialized=0;
}


OGGMuxDemuxIO::~OGGMuxDemuxIO() {
  if(vb){
    vorbis_block_clear(vb);
    delete vb;
    vb=NULL;
  }
  if(vd){
    vorbis_dsp_clear(vd);
    delete vd;
    vd=NULL;
  }
  if(vc){
    vorbis_comment_clear(vc);
    delete vc;
    vc=NULL;
  }
  if(vi){
    vorbis_info_clear(vi);
    delete vi;
    vi=NULL;
  }
    
}

int OGGMuxDemuxIO::writeFrame(Frame * frm, ESInfo *out_es) {

  if (state != OPEN)
    this->open();

  if (state != OPEN || readOnly) {
    dprintf_err("OGGMuxDemuxIO::writeFrame: Stream not open (for writing?)!\n");
    return 0;
  }

  if (firstFrame) {             //write Container Header to file
    // create new ogghandler
    osh_w = new OGGHandler();
    firstFrame=false;
    srand(time(NULL));
    {
      /* need two inequal serial numbers */
      serialtheora = rand();
      serialvorbis = rand();
      if(serialtheora==serialvorbis) serialvorbis++;
      dprintf_full("OGGMuxDemuxIO::writeFrame: serialvorbis = %i, serialtheora = %i\n",serialvorbis,serialtheora);
    }
    osi = new OGGStreamInfo();

    OGGStreamInfo *vorbis_stream, *theora_stream;
    vorbis_stream = NULL; theora_stream = NULL;


    //write list of streamID and CODEC_ID
    map < int, BufferedIO* >::iterator currIO;
    for(currIO=ioList.begin(); currIO != ioList.end(); currIO++) {
      ESInfo *esi = currIO->second->getESInfo();
      dprintf_full("OGGMuxDemuxIO::writeFrame: ESI = %p, %p == %p ??? %i\n", esi, &ioList.begin(), &ioList.end(), ioList.size());
      // ti.vopinc = esi->getVOPTimeIncrement();
      ogg_stream_state *tmp = new ogg_stream_state;

      if (esi->isVisualStream()) {
        dprintf_full("OGGMuxDemuxIO::writeFrame: found visual stream\n");
        ogg_stream_init(tmp, serialtheora);
        
        theora_stream = new OGGStreamInfo();

        theora_stream->setStreamType(OGG_THEORA);
        theora_stream->setStreamID(serialtheora);
        theora_stream->setStreamState(tmp);
        dprintf_full("OGGMuxDemuxIO::writeframe: FPS: %f\n",((VideoESInfo*)esi)->getFPS());

        // ti.esi.vi.fps = (u32)ceil(((VideoESInfo*)esi)->getFPS());
        // ti.esi.vi.width = (u32)((VideoESInfo*)esi)->getWidth();
        // ti.esi.vi.height = (u32)((VideoESInfo*)esi)->getHeight();
        // ti.esi.vi.aspectRatio = (float)((VideoESInfo*)esi)->getAspectRatio();

        initTheora(esi);
        
      } else if (esi->isAudioStream()) {
        dprintf_full("OGGMuxDemuxIO::writeFrame: found audio stream\n");
        ogg_stream_init(tmp, serialvorbis);

        vorbis_stream = new OGGStreamInfo();

        vorbis_stream->setStreamType(OGG_VORBIS);
        vorbis_stream->setStreamID(serialvorbis);
        vorbis_stream->setStreamState(tmp);

        // ti.esi.ai.sampleRate = ((AudioESInfo*)esi)->getSampleRate();
        // ti.esi.ai.channels = ((AudioESInfo*)esi)->getAudioChannels();
        // //copy first two characters
        // ti.esi.ai.language[1] = ((AudioESInfo*)esi)->getLanguage()[1];
        // ti.esi.ai.language[2] = ((AudioESInfo*)esi)->getLanguage()[2];

        initVorbis(esi);
      }
    }

    ogg_packet *op;
    ogg_page *og;
    og = new ogg_page;
    op = new ogg_packet;

    // theora stream has to be first
    if(theora_stream != NULL){
      // insert ogg-stream-info to ogg-stream-handler
      // if not present
      if(osh_w->osi == NULL)
        osh_w->osi = osi;

      osi->append(theora_stream);
      
      // write header pages of theorastream
      /* first packet will get its own page automatically */
      dprintf_full("theora_encode_header\n");
      theora_encode_header(ts, op);
      ogg_stream_packetin(osi->getStreamState(serialtheora), op);
      if(ogg_stream_pageout(osi->getStreamState(serialtheora), og)!=1){
        dprintf_err("OGGMuxDemuxIO::writeFrame: Internal Ogg library error.\n");
        ::exit(1);
      }
      stream->write(og->header, og->header_len);
      stream->write(og->body, og->body_len);

      theora_comment *tc;
      tc = new theora_comment;
      theora_comment_init(tc);
      theora_encode_comment(tc, op);
      ogg_stream_packetin(osi->getStreamState(serialtheora), op);
      theora_encode_tables(ts, op);
      ogg_stream_packetin(osi->getStreamState(serialtheora), op);
    }
    // vorbis stream as second
    if(vorbis_stream != NULL){
      // insert ogg-stream-info to ogg-stream-handler
      // if not present
      if(osh_w->osi == NULL)
        osh_w->osi = osi;
      osi->append(vorbis_stream);

      // write header pages of vorbisstream
      ogg_packet *header;
      ogg_packet *header_comm;
      ogg_packet *header_code;

      header = new ogg_packet;
      header_comm = new ogg_packet;
      header_code = new ogg_packet;

      dprintf_full("vorbis_encode_header: vorbis_stream=%p vd=%p vc=%p header=%p header_comm=%p header_code=%p\n",
                   vorbis_stream, vd, vc, header, header_comm, header_code);

      vorbis_analysis_headerout(vd, vc, header, header_comm, header_code);
      dprintf_full("vorbis_header_encoded\n");
      ogg_stream_packetin(osi->getStreamState(serialvorbis), header);
      if(ogg_stream_pageout(osi->getStreamState(serialvorbis), og) != 1){
        dprintf_err("Internal Ogg library error.\n");
        ::exit(1);
      }
      stream->write(og->header, og->header_len);
      stream->write(og->body, og->body_len);
      
      ogg_stream_packetin(osi->getStreamState(serialvorbis), header_comm);
      ogg_stream_packetin(osi->getStreamState(serialvorbis), header_code);
    }


    /* create the remaining theora headers */
    if(theora_stream != NULL){
      /* flush the rest of the theora headers */
      while(1){
        int result = ogg_stream_flush(osi->getStreamState(serialtheora), og);
        if(result < 0){
          /* theoretical can't get here */
          dprintf_err("Internal Ogg library error.(THEORA)\n");
          ::exit(1);
        }
        dprintf("OGGMuxDemuxIO:writeFrame: result = %i\n",result);
        if(result == 0) break;
        stream->write(og->header, og->header_len);
        stream->write(og->body, og->body_len);
      }
    }

    /* create the remaining vorbis headers */
    if(vorbis_stream != NULL){
      /* flush the rest of the vorbis headers */
      while(1){
        int result = ogg_stream_flush(osi->getStreamState(serialvorbis), og);
        if(result < 0){
          /* theoretically can't get here */
          dprintf_err("Internal Ogg library error. (VORBIS)\n");
          ::exit(1);
        }
        if(result == 0) break;
        stream->write(og->header, og->header_len);
        stream->write(og->body, og->body_len);
      }
    }
    
    delete og;
    delete op;
    og = NULL;
    op = NULL;

  } // if(firstFrame)

  AU *au = frm->getAU();
  ogg_packet *op = (ogg_packet*)au->payload;

  ogg_page *og;
  og = new ogg_page;
  int ret;
  if(out_es->isAudioStream()){
    ogg_stream_packetin(osi->getStreamState(serialvorbis), op);
    ret = ogg_stream_pageout(osi->getStreamState(serialvorbis), og);
    dprintf_full("OGGMuxDemuxIO::writeFrame: writing Audio-Frame (%i)\n", ret);
  } else {
    ogg_stream_packetin(osi->getStreamState(serialtheora), op);
    ret = ogg_stream_pageout(osi->getStreamState(serialtheora), og);
    dprintf_full("OGGMuxDemuxIO::writeFrame: writing Video-Frame (%i)\n", ret);
  }
  
  if(ret != 0){
    stream->write(og->header, og->header_len);
    stream->write(og->body, og->body_len);
  }

  delete og;
  og = NULL;

  //delete(au->payload);
  //  ogg_packet_clear(op);
  //  delete frm;
  //  frm = NULL;

  //  ::exit(0);  
  return 0;
}



Frame *OGGMuxDemuxIO::getFrame() {
  //  OGGHandler *osh = OGGContainerFile::getOGGHandler();
  ogg_page og;
  
  if(state != OPEN || !readOnly){
    dprintf_err("OGGMuxDemuxIO::getFrame: Stream not open (for reading?) or EOF!\n");
    return 0;
  }
  
  OGGContainerFile::oggMutexLock("OGGMuxDemuxIO");
  
  double start_dtime, now_dtime;
  struct timeval now_tv;
  gettimeofday(&now_tv,NULL);
  start_dtime = now_tv.tv_sec + now_tv.tv_usec/1000000.0;
  
  if(firstFrame && (state != OPEN))
    this->open();
  
  // Do Header-Parsing
  // I do not need header-parsing again, 'cause i 've OGGHandler :)
  if(firstFrame){
    // get OGGHandler
    osh = OGGContainerFile::getOGGHandler();
    vorbisframesSeen=0;
    theoraframesSeen=0;
    //    numStreams=0;
    //    streamp=0;
    firstFrame=false;
  }
  
  ogg_packet* op = new ogg_packet;
  
  AU *au;
  Frame *frm;
  
  bool processed = false;
  // do until at least one packet is processed.
  do{
    u8* op_copy;
    OGGStreamInfo *osi=osh->osi;
    assert(osi);
    char* str;
    // now look in each Streamstate, if there is a packet ready
    do{
      if(ogg_stream_packetout(osi->getStreamState(), op) > 0){
        au = new AU();
        // GOT PACKET FOR STREAM X
        dprintf_full("OGGMuxDemuxIO::getFrame: packetout OK (SIZE: %li), packetno = %li\n",
                     op->bytes, (long int)op->packetno);
        
        au->size=op->bytes;
        op_copy = new u8[sizeof(ogg_packet)+op->bytes];
        
        // copy all values from op to op_copy and
        // set packet* to object + sizeof(ogg_packet)
        // and copy packet to object + sizeof(ogg_packet)
        // to have all data in one place
        {
          ogg_packet *tmp = (ogg_packet*)op_copy;
          int op_size = sizeof(ogg_packet);
          memcpy(op_copy, op, op_size);
          tmp->packet = op_copy + op_size;
          memcpy(tmp->packet, op->packet, op->bytes);
        }
        
        au->payload = op_copy;
        
        /* 
         * if streamtype == VORBIS, do VORBIS specific stuff
         */
        if(osi->getStreamType() == OGG_VORBIS) {
          str="vorbis";
          // TODO:
          Frame::FrameType type = Frame::VORBIS_AUDIO;
          dprintf_full("OGGMuxDemuxIO::getFrame: Frame (%i) for OGG_VORBIS (granulepos: %li)!!!\n",
                       vorbisframesSeen,(long)op->granulepos);
          vorbis_info *vi = (vorbis_info*)osi->getCodecInfo();
          // int time_increment = (int)((float)(576*90000)/vi->rate/4);
          
          if(op->granulepos >= 0) {
            au->cts = (int)(((double)op->granulepos/(double)vi->rate)*90000.0);
            vorbisframesSeen = au->cts;
          } else {
            au->cts = vorbisframesSeen; // * es->getVOPTimeIncrement() ;//+ time_increment * vorbisframesSeen++;
          }
          //au->cts = 0;
          au->dts = au->cts;

          au->sampleFlags = 0;
          au->err = SA_OK;
          frm = new Frame(type);
          frm->setStreamID(osi->getStreamID());
          frm->setAU(au);
          
          processed = true;

          //      dprintf_err("OGGMuxDemuxIO::getFrame: %s: %li\n",str,(long)op->granulepos);
          dprintf_full("OGGMuxDemuxIO::getFrame: Vorbis-Timestamp: pos(%li)/rate(%li) = %f, au->cts = %i, mycts = %i\n",
                       (long)op->granulepos,
                       (long)vi->rate,
                       ((double)op->granulepos/vi->rate),
                       au->cts,
                       (int)(((double)op->granulepos/(double)vi->rate)*90000.0)
                       );

          dprintf_full("DEMUX_INFO: VORBIS, op-granule: %li, cts = %i, time = %f, framesSeen = %i\n", 
                       (long)op->granulepos, 
                       au->cts, ((double)op->granulepos/vi->rate),
                       vorbisframesSeen);
        }
        /*
         * if streamtype == THEORA, do THEORA specific stuff
         */
        else if(osi->getStreamType() == OGG_THEORA){
          str="theora";
          // CTS = numerator/denominator
          dprintf_full("OGGMuxDemuxIO::getFrame: Frame (%i) for OGG_THEORA (granulepos: %li)!!!\n",
                       theoraframesSeen, (long int)op->granulepos);
          Frame::FrameType type = Frame::NN_VOP;
          theora_info *ti = (theora_info*)osi->getCodecInfo();

          au->cts = (u32)(
                          90000.0 *
                          (float) theoraframesSeen++ /
                          (
                           (float)ti->fps_numerator /
                           (float)ti->fps_denominator
                           )
                          );
          //      au->cts = 0;    
          au->dts = au->cts;
          
          //      dprintf_err("OGGMuxDemuxIO::getFrame: %s: %i\n",str,theoraframesSeen);
          dprintf_full("OGGMuxDemuxIO::getFrame: OGGStreamStateINFO: packetno: %li ==========================\n",
                       (long int)osi->getStreamState()->packetno);
          au->sampleFlags = 0;
          au->err = SA_OK;
          
          if(theora_packet_iskeyframe(op)){
            dprintf_full("OGGMuxDemuxIO::getFrame: +KEYFRAME!!!\n");
            type = Frame::I_VOP;
          }else{
            dprintf_full("OGGMuxDemuxIO::getFrame: +NO keyframe!!!\n");
            type = Frame::B_VOP;
          }
          
          frm = new Frame(type);
          frm->setStreamID(osi->getStreamID());
          frm->setAU(au);
          frm->setType(type);
          
          dprintf_full("OGGMuxDemuxIO::getFrame frametype: += %i\n",frm->getType());
         
          processed = true;
          dprintf_full("DEMUX_INFO: THEORA, op-granule: %li, cts = %i, time = %f, fps = %f, framesSeen = %i\n", 
                       (long)op->granulepos, 
                       au->cts, au->cts/90000.0, (float)ti->fps_numerator/(float)ti->fps_denominator,
                       theoraframesSeen);
        } 
      }
      //      if(processed)return frm;
      osi = osi->getNext();
    }while(osi && !processed);
    
    //    dprintf_err("OGGMuxDemuxIO: packets seen: %li\n",packetsSeen++);
    
    // if there is no packet for any stream...
    if(!processed && state!=STREAMEOF){
      // do something to get one!
      //      int ret = 0, ret1 = 0;
      dprintf_full("OGGMuxDemuxIO::getFrame: packetout returned no packet... getting new page!\n");
      
      // read some bytes
      int finished = 0;
      finished = OGGContainerFile::bufferData(stream, &(osh->oy));
      dprintf_full("OGGMuxDemuxIO::getFrame: read %i bytes!\n", finished);
      
      if(finished == 0 || finished == -1){
        state = STREAMEOF;
        OGGContainerFile::oggMutexRelease("OGGMuxDemuxIO");
        return NULL;
      }
      
      // now try a pageout
      int ret = 0;
      while((ret=ogg_sync_pageout(&(osh->oy), &og))>0){
        // queue page in appropriate stream
        dprintf_full("OGGMuxDemuxIO::getFrame: sync_pageout got a page!\n");
        osi = osh->osi;
        // search for appropriate stream and buffer page
        if(osi->getStreamState(ogg_page_serialno(&og)))
          ogg_stream_pagein(osi->getStreamState(ogg_page_serialno(&og)), &og);
        else
          dprintf_full("OGGMuxDemuxIO::getFrame: EXTREME ERRORR!!!\n");
        
      }
      
    } // if(!processed)
    else break;
    
  }while(!processed); // until one packet is processed
  
  delete op;
  gettimeofday(&now_tv,NULL);
  now_dtime = now_tv.tv_sec + now_tv.tv_usec/1000000.0;
  dprintf_full("OGGMuxDemuxIO::getFrame(): worked for %2.0f msecs\n",
               (now_dtime-start_dtime)*1000.0);
  
#ifdef _POSIX_PRIORITY_SCHEDULING
  sched_yield(); //this is necessary to give parallel getFrames a chance
#endif
  
  OGGContainerFile::oggMutexRelease("OGGMuxDemuxIO");
    
  if(state == STREAMEOF)
    return NULL;
  else
    return frm;
}


#endif

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