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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

StrongTemporalAdaptor.hpp

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

#ifndef _PS_STRONGTEMPORALADAPTOR_HPP
#define _PS_STRONGTEMPORALADAPTOR_HPP

#include "VideoAdaptor.hpp"
#include "global.hpp"
#include "Frame.hpp"
#include "ESInfo.hpp"
#include "BitField.hpp"

class StrongTemporalAdaptor : public VideoAdaptor {
public:
        StrongTemporalAdaptor(VideoESInfo * esi) {
                es = esi;
                inFrames = 0;
                outFrames = 0;
                lastDTS = 0;
                initialized = false;
                strcpy(name,"StrongTemporalAdaptor");
        };
        StrongTemporalAdaptor() {
                es = NULL;
                inFrames = 0;
                outFrames = 0;
                lastDTS = 0;
                initialized = false;
                strcpy(name,"StrongTemporalAdaptor");
        };

        virtual ~ StrongTemporalAdaptor() {
        };

        Adaptor * clone() {
                return new StrongTemporalAdaptor(es);
        };

        list < Frame * >adapt(Frame * frm) {
                if(!initialized)
                        initialize();
                // a temporaladaptor is not allowed to delete the input frame
                // because other DataSinks might need it as input
                inFrames++;
                list < Frame * >tmp;
                if (!doAdapt(frm)) {
                        tmp.push_front(frm);
                        outFrames++;
                }

                return tmp;
        };

        void initialize() {     
                if(initialized)
                        return;
                initialized = true;
                if(es) {
                        u32 oldBW=es->getAvgBandwidth();
                        float bFrame=es->getAvgBFrameSize();
                        u32 newBW=(u32)(oldBW*bFrame);
                        dprintf_full("TemporalAdaptor::initialize BW %u -%f-> %u\n",oldBW,bFrame,newBW);
                        es->setAvgBFrameSize(0.0);
                        es->setNum_B_frames(0);
                        es->setAvgBandwidth(newBW);
                }       
        };
        list < Frame * >close() {
                
                list < Frame * >tmp;
                
                // set the fps
                if (es) {
                        origVopTimeIncr=es->getVOPTimeIncrement();
                        u32 vInc=es->getDuration()/this->outFrames;
                        u32 t=vInc%origVopTimeIncr;
                        vInc-=t;
                        es->setVOPTimeIncrement(vInc);
                        u64 fs=es->getCurrentDemuxedMediaSize();
                        fs*=8000;
                        fs/=es->getDurationInMs();
                        es->setAvgBandwidth((u32)fs);
                }
                // correct the bitfield, which now shows a too small complete status
                if(es && es->getFrameStatistic()) {
                        BitField* b=new BitField(es->getFrameStatistic()->getSize(),true);
                        es->setFrameStatistic(b);
                }
                return tmp;
        };
        u32 getTranscodingCosts() const {
                return 1000u;
        }
protected:
        inline bool doAdapt(Frame * &frm) {
                u32 i = frm->getType();
                return i == Frame::B_VOP || i == Frame::P_VOP;
    };
        u32 inFrames;
        u32 outFrames;
        u32 lastDTS;
        u32 origVopTimeIncr;
};


#endif

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