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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

VorbisEncoder.cpp

/***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       VorbisEncoder.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 "VorbisEncoder.hpp"
#include "CompressedVideoFrame.hpp"


/***************************************************/
VorbisEncoder::VorbisEncoder(AudioESInfo *aes, u32 targetBitRate) {
        es = aes;
        muiTargetBitrate = es->getAvgBandwidth();

        dprintf_full("VorbisEncoder::VorbisEncoder: aes->getAvgBandwidth = %i, targetBitRate = %i\n",
                     aes->getAvgBandwidth(), targetBitRate);
        OGGMuxDemuxIO::initVorbis(aes);
        
        vi = OGGMuxDemuxIO::getVorbisInfo();
        //  vorbis_comment*   vc;
        vd = OGGMuxDemuxIO::getVorbisDspState();
        vb = OGGMuxDemuxIO::getVorbisBlock();
        
        strcpy(name,"VorbisEncoder-ViTooKi");
}


/***************************************************/
void VorbisEncoder::initialize() {
  /*
        if(initialized)
                return;
        
        dprintf_full("VorbisEncoder::initialize() Handle: %p BW: %i bps \n",
                     mpEncoderHandle, muiTargetBitrate);

        es->setAvgBandwidth(muiTargetBitrate);
        es->setVOPTimeIncrement(2350); // FIXME: 90000 DIV 38 frames, known by analyzing ffmpeg :(
        muiFrameNumber = 0;
        inBufSize=0;
        initialized = true;
        firstFrame = true;
  */
}


/***************************************************/
VorbisEncoder::~VorbisEncoder() {
  //    FFMPEGaudioEncoderClose(&mpEncoderHandle);
}



/***************************************************/
list < Frame * >VorbisEncoder::adapt(Frame * frm) {
       CompressedAudioFrame *vorbisFrame = NULL;
       list < Frame * >frmList;
       u32 iFramesize = 0;
       ogg_packet op;
       
       dprintf_full("VorbisEncoder::adapt: frame->AU->size: %i\n%s", frm->getAU()->size, frm->getAU()->toString());

       float** vorbis_buffer;
       int sampread = 0, count=0, i=0, j=0;

       int Bps = 2;
       int channels = 2;

       sampread= (frm->getAU()->size) / Bps / channels; // assuming ( 2 Bytes / sample ) ( 2 channels )

       vorbis_buffer=vorbis_analysis_buffer(vd, sampread);

       // payload has to be treated as signed char
       signed char* payload;
       payload = (signed char*)(frm->getAU()->payload);
       /* uninterleave samples */
       for(i=0; i<sampread; i++){
         for(j=0; j<channels; j++){
           vorbis_buffer[j][i]=
             ((payload[count+1]<<8) |
              (0x00ff & (int) payload[count])) 
             / 32768.f;
           count += 2;
         }
       }
       vorbis_analysis_wrote(vd, sampread);
       
       while(vorbis_analysis_blockout(vd, vb) == 1){
         /* analysis, assume we want to use bitrate management */
         vorbis_analysis(vb, NULL);
         vorbis_bitrate_addblock(vb);

         /* get packtes */
         while(vorbis_bitrate_flushpacket(vd, &op)){
           AU *pAU = new AU(frm->getAU());
           u8* payload = new u8[op.bytes + sizeof(ogg_packet)];
           memcpy(payload, &op, sizeof(ogg_packet));
           memcpy(payload+sizeof(ogg_packet), op.packet, op.bytes);
           
           ((ogg_packet*)payload)->packet = payload + sizeof(ogg_packet);
           
           pAU->size = op.bytes + sizeof(ogg_packet);
           pAU->payload = payload;
           pAU->cts = muiFrameNumber * es->getVOPTimeIncrement();
           
           vorbisFrame = new CompressedAudioFrame(Frame::VORBIS_AUDIO);

           vorbisFrame->setAU(pAU);
           vorbisFrame->setMediaTimeScale(es->getMediaTimeScale());

           frmList.push_back(vorbisFrame);


           muiFrameNumber++;
         }
       }

    
        /*
#define PCM_FRAME_SIZE (1152*2*2)  //FIXME: should be read from AVCodecContext->frame_size

        if (inBufSize > 0) { // smth was left from last round....
                memcpy(mpInBuf+inBufSize, frm->getAU()->payload, frm->getAU()->size);
                dprintf_full("MP3Encoder::adapt %i bytes were left from last round...stored further %i bytes\n",inBufSize,frm->getAU()->size);
                inBufSize += frm->getAU()->size;

                if (inBufSize >= PCM_FRAME_SIZE) {
                        iFramesize = FFMPEGaudioEncodeFrame(mpEncoderHandle, (char *)mpInBuf, mpOutBuf);
                        inBufSize -= PCM_FRAME_SIZE;
                        assert(inBufSize <= PCM_FRAME_SIZE); //avoid overlapping rest-buffer
                        memcpy(mpInBuf,mpInBuf+PCM_FRAME_SIZE,inBufSize); //move rest to the front

                        if (iFramesize > 0) {
                                AU *pAU = new AU(frm->getAU());
                                u8 *payload = new u8[iFramesize];
                                memcpy(payload, mpOutBuf, iFramesize);
                        
                                pAU->size = iFramesize;
                                pAU->payload = payload;
                                pAU->cts = muiFrameNumber * es->getVOPTimeIncrement();
                        
                                mpgFrame = new CompressedAudioFrame(Frame::MP3_AUDIO);
                                
                                //mpgFrame->detectFrameType();
                                mpgFrame->setAU(pAU);
                                mpgFrame->setMediaTimeScale(es->getMediaTimeScale());
                                frmList.push_back(mpgFrame);
                                dprintf_full("MP3Encoder::adapt overlapping frame: size %i bytes, %s frameNo %i, CTS %u:\r\n",
                                                                                 pAU->size, Frame::VOPTypeToChar(mpgFrame->getType()), muiFrameNumber,
                                                                                 mpgFrame->getAU()->cts);
                                muiFrameNumber++;
                        } else {
                                dprintf_full("MP3Encoder::adapt ... filling encoder queue: no return data yet.\n");
                        }
                } else {
                        dprintf_full("MP3Encoder::adapt ... still harvesting small pcm bits for one full frame...!\n");
                }
        } // smth was left from last round....
        else { //inBufSize==0, so store for next round
                memcpy(mpInBuf, frm->getAU()->payload, frm->getAU()->size);
                inBufSize= frm->getAU()->size;
                dprintf_full("MP3Encoder::adapt %i tail-bytes saved for next round...\n",inBufSize);
        }
        */
        return frmList;
}


/***************************************************/
list < Frame * >VorbisEncoder::close() {
        list < Frame * >frmList;
        /*
        CompressedAudioFrame *mpgFrame = NULL;
        u32 iFramesize;

        dprintf_full("MP3Encoder::close ... there are %i bytes left in inBuf, draining....\n",inBufSize);
        
        if (inBufSize > 0) {
                //maybe FIXME: for large input frames, maybe more than one PCM_FRAME_SIZE is still in buffer?  --> while() needed...
                assert(inBufSize <= PCM_FRAME_SIZE); //avoid overlapping rest-buffer
                iFramesize = FFMPEGaudioEncodeFrame(mpEncoderHandle, (char *)mpInBuf, mpOutBuf);
        
                do { 
                        if (iFramesize > 0) {
                                AU *pAU = new AU();
                                u8 *payload = new u8[iFramesize];
                                memcpy(payload, mpOutBuf, iFramesize);
                                
                                pAU->size = iFramesize;
                                pAU->payload = payload;
                                pAU->cts = muiFrameNumber * es->getVOPTimeIncrement();
                                
                                mpgFrame = new CompressedAudioFrame(Frame::MP3_AUDIO);
                                
                                //mpgFrame->detectFrameType();
                                mpgFrame->setAU(pAU);
                                mpgFrame->setMediaTimeScale(es->getMediaTimeScale());
                                frmList.push_back(mpgFrame);
                                dprintf_full("MP3Encoder::close FINAL frame: size %i bytes, %s frameNo %i, CTS %u:\n",
                                                                                 pAU->size, Frame::VOPTypeToChar(mpgFrame->getType()), muiFrameNumber,
                                                                                 mpgFrame->getAU()->cts);
                                muiFrameNumber++;
                        } else {
                                dprintf_err("MP3Encoder::close ... FINAL pcm samples didnt lead to encoded frame?!?!\n");
                        }
                        iFramesize = FFMPEGaudioEncodeFrame(mpEncoderHandle, NULL, mpOutBuf);
                }       while (iFramesize > 0);

        } else {
                dprintf_full("MP3Encoder::close ... nothing left to decode.\n");
        }
        
        */
        return frmList;
}

Adaptor* VorbisEncoder::clone(){
  return NULL;
}

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