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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

VorbisDecoder.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: VorbisDecoder.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 "VorbisDecoder.hpp"

vorbis_info *vi;
vorbis_block *vb;

VorbisDecoder::VorbisDecoder(AudioESInfo* es) {
        this->es = es;
        strcpy(name,"VorbisDecoder");
        FrameCount = 0;
        Status = 0;
        initialized = false;
        lastTS=0;
        //      inputBuffer = new unsigned char[MAD_INPUT_BUFFER_SIZE + MAD_BUFFER_GUARD];
}


VorbisDecoder::~VorbisDecoder() {
        if (initialized) {
        }
        delete [] inputBuffer;
}

int audiobuf_fill = 0;
int audiobuf_ready = 0;
double audiotime;
ogg_int16_t *audiobuf;
ogg_int64_t *audiobuf_granulepos=0;

void VorbisDecoder::initialize() {
  /* First the structures used by libvorbis must be initialized. */
        
  OGGHandler *ogh = OGGContainerFile::getOGGHandler();
  OGGStreamInfo *tmp = ogh->osi;
  dprintf_full("VorbisDecoder::initialize()\n");

  vd =  new vorbis_dsp_state;
  vb = new vorbis_block;

  if(tmp){
    do{
      // in the VorbisDecoder we only seek for VORBIS streams
      if(tmp->getStreamType() == OGG_VORBIS){
        dprintf_full("VorbisDecoder::initialize(): FOUND OGG_VORBIS\n");
        osi = tmp;
        break;
      }
      tmp = tmp->getNext();
    }while(tmp);
  }
  if(!osi){
    dprintf_err("VorbisDecoder::initialize(): no stream in OGG-file found... ABORTING!\n");
    exit(1);
  }

  vi = (vorbis_info*)osi->getCodecInfo();

  vorbis_synthesis_init(vd, vi);
  vorbis_block_init(vd, vb);

  initialized=true;
  numInFrames = 0;
}


int samplesprocessed = 0;

/***************************************************************/
list < Frame * > VorbisDecoder::adapt(Frame * frm) {
        OGGContainerFile::oggMutexLock("VorbisDecoder");
        list < Frame * >tmp;
        u32 thisCTS;
        int thisSec;
        AU *au = frm->getAU();

        ogg_packet *op = (ogg_packet*)au->payload;
        
        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;

        dprintf_full("VorbisDecoder::adapt: got Frame %p, AU %p, cts %u!\n",frm, frm->getAU(), frm->getAU()->cts);

        //initialize decoder
        if (!initialized) {
                initialize();
        }

        if (frm->getAU() == NULL){
          dprintf_full("VorbisDecoder::adapt: frm->getAU() was NULL!!\n");
          OGGContainerFile::oggMutexRelease("VorbisDecoder");
          return tmp;
        }
        
        thisCTS = au->cts;
        thisSec = (int)floor((double)thisCTS / es->getMediaTimeScale());
        dprintf_full("VorbisDecoder::adapt: frame %i (size %i) CTS %i, VOP increment %i, samplerate %i Hz, Channels: %i, thisSec: %i, op->bytes: %li\n",
                     numInFrames, 
                     au->size, 
                     thisCTS, 
                     es->getVOPTimeIncrement(), 
                     es->getSampleRate(), 
                     es->getAudioChannels(),
                     thisSec,
                     op->bytes);

        numInFrames++;
        
        int samples;
        float **pcm;
        int i,j;
        AU *dAU = new AU();
        UncompressedAudioFrame *uaf;
        // check if all OK
        // and submit Ogg-Packet to Vorbis Synthesis
        {
          if(vorbis_synthesis(vb, op) == 0)
            vorbis_synthesis_blockin(vd,vb);
       
          samples = vorbis_synthesis_pcmout(vd, &pcm);
        }

        // if we have pcmdata... copy
        if(samples > 0) {
          samplesprocessed += samples;

          // dAU->payload ist u8
          // ein Sample hat 16 bits --> * 2
          // stereo --> * 2
          // mono   --> * 1
          int convsize = samples * 2 * vi->channels;
          int clipflag = 0;

          dAU->size = convsize;
          dAU->payload = new u8[convsize];
          
          ogg_int16_t* ptr = (ogg_int16_t*)(dAU->payload);

          // convsize/2 weil pro durchlauf beide channels berechnet werden
          for (i = 0; i < convsize/2/vi->channels; i++) {
            for (j = 0; j < vi->channels; j++) {
              int val = (int)rint(pcm[j][i]*32767.f);
              if(val >  32767){ clipflag = 1; val =  32767; }
              if(val < -32768){ clipflag = 1; val = -32768; }

              //*(ptr++)=val;
              *(ptr++) = (ogg_int16_t)val;
            }
          }
          
          if(clipflag)
            dprintf_full("VorbisDecoder::adapt: Clipping in frame %ld\n",(long)vd->sequence);

          vorbis_synthesis_read(vd, samples);

          if(vd->granulepos > 0)
            audiotime = vd->granulepos;// - samples + i;
          else
            audiotime += i;

          // realtime = audiotime / rate / 2 / vi->channels
          //      dAU->cts = (long)((audiotime/(vi->rate))*90000.0);
          //dAU->cts = (int)((samplesprocessed-samples)*90000.0/es->getSampleRate());
          dAU->cts = (int)((audiotime-i)*90000.0/es->getSampleRate());
          dAU->dts = dAU->cts;

          //FIXME: dirty hack by Mike
          //after some audio frames, start to adjust variable frame sizes to the average
          if (numInFrames > 100){
            dprintf_full("VorbisDecoder::adapt: setVOPTimeIncrement(%li) <- %i / %li * 90.000\n", 
                         (long)(((float)samples/(float)vi->rate)*90000.0),
                         samples,
                         vi->rate);
            es->setVOPTimeIncrement(
                                    (long)(((float)samples/(float)vi->rate)*90000.0));
          }
            //      es->setVOPTimeIncrement(dAU->cts/numInFrames);

          dprintf_full("VorbisDecoder::adapt: aud_timestamp: %f, aud_gran: %li (%li), cts: %u, VOPInc %i, samples: %i (%i), samplesprocessed: %i, numinframes: %i\n",
                       dAU->cts/90000.0,
                       (long) audiotime, (long)vd->granulepos,
                       dAU->cts, 
                       es->getVOPTimeIncrement(),
                       samples,i,
                       samplesprocessed,
                       numInFrames);


          uaf = new UncompressedAudioFrame(Frame::RAW_AUDIO);
          uaf->setAU(dAU);
          tmp.push_back(uaf);
          
        }

        //FIXME: assert(isAudioFrame)
        gettimeofday(&now_tv,NULL);
        now_dtime = now_tv.tv_sec + now_tv.tv_usec/1000000.0;
        dprintf_full("VorbisDecoder::adapt(): worked for %2.0f msecs\n",
                     (now_dtime-start_dtime)*1000.0);

        if(au){
          /********************************************************************
           * somehow the ogg_packet struct has already been cleared.
           * there is no memory leak! but don't ask why...
           * so i only set payload to NULL, so that AccessUnit doesn't try to
           * delete payload.
           */
          // printf("payload -> %p\n",au->payload);
          // au->payload=NULL;
        }

        OGGContainerFile::oggMutexRelease("VorbisDecoder");

        return tmp;
}

#endif

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