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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

TheoraDecoder.cpp

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

int             framesSeen;
OGGStreamInfo   *osi;
yuv_buffer      *yuv;
int             frameSize = 0;
// FILE*           out;
theora_info*    ti;
VideoESInfo*    ves;

TheoraDecoder::TheoraDecoder(VideoESInfo* es){
  dprintf_full("TheoraDecoder::TheoraDecoder(ves) isVisualStream = %s, HandlerType = %i, FPS = %f\n", 
               (es->isVisualStream() ? "TURE" : "FALSE"),
               es->getHandlerType(),
               es->getFPS()
               );
  ves = es;
  initialized = 0;
  initialize();
}

TheoraDecoder::~TheoraDecoder(){
  dprintf_full("TheoraDecoder::~TheoraDecoder()\n");
  if(initialized){
    delete ts;
    //    fclose(out);
  }
}

list < Frame * > TheoraDecoder::adapt(Frame * frm){
  OGGContainerFile::oggMutexLock("TheoraDecoder");
  list < Frame * >tmp;
  AU *au = frm->getAU();

  double vid_time;
  ogg_packet *op = (ogg_packet*)au->payload;
  yuv = new yuv_buffer; //(yuv_buffer*)malloc(sizeof(yuv_buffer));
  
  if (frm->getAU() == NULL){
    dprintf_full("TheoraDecoder::adapt: frm->getAU() was NULL!!\n");
    OGGContainerFile::oggMutexRelease("TheoraDecoder");
    return tmp;
  }

  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;

  // create ogg-package for theora-decoder
  dprintf_full("TheoraDecoder::adapt: got Frame %p, AU %p, cts %u!\n",frm, frm->getAU(), frm->getAU()->cts);

  // decode FRAME!
  {
    theora_decode_packetin(ts, op);
    theora_decode_YUVout(ts, yuv);
  }

  //vid_time    = theora_granule_time(ts, ts->granulepos);
  vid_time = framesSeen / ves->getFPS();
  dprintf_full("THDEC: VID_T = %f, FPS: %f, Frame#: %i\n", vid_time, ves->getFPS(), framesSeen);
 
  // make FRAME for ViTooKi
  AU *dAU = new AU();
  UncompressedVideoFrame *uvf;
  Frame::FrameType type = Frame::YUV_VOP;

  dAU->size = (u32)((float)frameSize * 1.5);
  dAU->payload = new u8[dAU->size];

  dAU->cts = (u32)(vid_time*90000.0);
  dAU->dts = au->cts;

  dprintf_full("TheoraDecoder::adapt: vid_timestamp: %f,\t granule_frame: %li,\t cts: %u, old_cts: %u\n",
               vid_time, 
               (long)theora_granule_frame(ts, ts->granulepos), 
               dAU->cts, au->cts);
  /*
   * size_t fwrite(const void *ptr, size_t size, size_t nmemb, FILE *stream); 
   * DESCRIPTION
   * The function fwrite writes nmemb elements of data, each size bytes long, 
   * to the stream pointed to by stream, obtaining them from the location given by ptr. 
   */
  {
    uint i = 0; int crop_offset = 0;
    crop_offset = ti->offset_x + yuv->y_stride * ti->offset_y;
    for(i=0; i < ti->height; i++){
      memcpy(dAU->payload + ti->width * i, yuv->y + crop_offset + yuv->y_stride * i, ti->width);
      //      fwrite(yuv->y + crop_offset + yuv->y_stride * i, 1, ti->width, out);
    }
     
    crop_offset = ti->offset_x/2 + yuv->uv_stride * (ti->offset_y/2);
    for(i=0; i < ti->height/2; i++){
      memcpy(dAU->payload + frameSize +  ti->width/2 * i , yuv->u + crop_offset + yuv->uv_stride*i, ti->width/2);
      //      fwrite(yuv->u + crop_offset + yuv->uv_stride*i, 1, ti->width/2, out);
    }

    for(i=0; i < ti->height/2; i++){
      memcpy(dAU->payload + frameSize + frameSize/4 + ti->width/2 * i, yuv->v + crop_offset + yuv->uv_stride*i, ti->width/2);
      //      fwrite(yuv->v + crop_offset + yuv->uv_stride*i, 1, ti->width/2, out);
    }
  }
  uvf = new UncompressedVideoFrame(type, yuv->y_width, yuv->y_height);
  uvf->setAU(dAU);

  tmp.push_back(uvf);

  delete yuv;

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

  if(au){
    dprintf_full("DEL START\n");
    if(op){
      dprintf_full("OP-> YES (%p)!!!\n",op);
      // should do:
      // ogg_packet_clear(op);
      // but ogg_packet is a mapping from au->payload!!!
      // so I only have to clear op->packet, because this was malloc'd by me
      //      free(op->packet);
    }
    else{
      dprintf_full("OP-> NO!!!!\n");
      //    frm->getAU()->payload = NULL;
    }
    dprintf_full("DEL FINISH\n");
  }
  
  OGGContainerFile::oggMutexRelease("TheoraDecoder");

  framesSeen++;
  return tmp;
}

void TheoraDecoder::initialize(){
  OGGHandler *ogh = OGGContainerFile::getOGGHandler();
  OGGStreamInfo *tmp = ogh->osi;
  dprintf_full("TheoraDecoder::initialize()\n");

  if(tmp){
    do{
      // in the TheoraDecoder we only seek for THEORA streams
      if(tmp->getStreamType() == OGG_THEORA){
        dprintf_full("TheoraDecoder::initialize(): FOUND OGG_THEORA\n");
        osi = tmp;
        // set width and height of stream
        break;
      }
      /*
        else if(tmp->getStreamType() == OGG_VORBIS){
        dprintf_full("TheoraDecoder::initialize(): FOUND OGG_VORBIS\n");
      */
      tmp = tmp->getNext();
    }while(tmp);
  }
  if(!osi){
    dprintf_err("TheoraDecoder::initialize(): no stream in OGG-file found... ABORTING!\n");
    exit(1);
  }
  ti = (theora_info*)osi->getCodecInfo();

  ts = new theora_state;
  theora_decode_init(ts, ti);
  dprintf_full("TheoraDecoder::THEORA_DECODE_INIT -- width %i , height %i\n",ti->width,ti->height);
  frameSize = ti->width * ti->height;

  framesSeen = 0;

  // YUV-out
  //  out = fopen("./out.yuv","w");

  initialized = 1;
}

#endif

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