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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

AdaptorChain.cpp

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

AdaptorChain::AdaptorChain()
{
        initialized = false;
        strcpy(name,"AdaptorChain");
}


AdaptorChain::~AdaptorChain()
{
        dprintf_full("AdaptorChain::~AdaptorChain()\n");
        list < Adaptor * >::iterator adaptorIterator;
        for (adaptorIterator = mAdaptorList.begin();
                         adaptorIterator != mAdaptorList.end(); adaptorIterator++) {
                if (*adaptorIterator != NULL)
                        delete *adaptorIterator;
        }
        
}


void AdaptorChain::initialize()
{
        list < Adaptor * >::iterator adaptorIterator;

  initialized = true;
        for (adaptorIterator = mAdaptorList.begin();
                         adaptorIterator != mAdaptorList.end(); adaptorIterator++) {
                (*adaptorIterator)->initialize();
        }
};


list < Frame * >AdaptorChain::close()
{
        list < Frame * >l;
        list < Adaptor * >::iterator adaptorIterator;
        list < Frame * >::iterator li;
        for (adaptorIterator = mAdaptorList.begin();
                         adaptorIterator != mAdaptorList.end(); adaptorIterator++) {
                int size = l.size();
                
                // feed all from l into the next adaptor
                // and store the returned results at the end of l
                while (size > 0) {
                        li = l.begin();
                        list < Frame * >l2 = (*adaptorIterator)->adapt(*li);
                        
                        if( (*li) != (*(l2.begin())) )
                                delete (*li);
                        list < Frame * >::iterator li2;
                        while (!l2.empty()) {
                                li2 = l2.begin();
                                l.push_back(*li2);
                                l2.pop_front();
                        }
                        l.pop_front();  // remove the first element, which is already adapted
                        --size;
                }
                // after we have sent all frames returned from the previous close,
                // close this adaptor so that it is guaranteed empty
                list < Frame * >l2 = (*adaptorIterator)->close();
                list < Frame * >::iterator li2;
                while (!l2.empty()) {
                        li2 = l2.begin();
                        l.push_back(*li2);
                        l2.pop_front();
                }
        }
        return l;
}


list < Frame * >AdaptorChain::adapt(Frame * frm)
{
        list < Frame * >*inFrameList=NULL;
        list < Frame * >*outFrameList=NULL;
        list < Frame * >retFrameList;
        list < Adaptor * >::iterator adaptorIterator;
        Adaptor *adaptor=NULL;
        Frame *frame=NULL;
        Frame *tmpFrame=NULL;
        
        if (!initialized)
                initialize();

        dprintf_full("AdaptorChain::adapt Input Frame is %p\n",frm);
        
        if (!initialized) {
                list<Frame*> tmp;
                return tmp;
        }

        inFrameList = new list < Frame * >;
        outFrameList = new list < Frame * >;
        inFrameList->push_back(frm);

        for (adaptorIterator = mAdaptorList.begin();
                         adaptorIterator != mAdaptorList.end(); adaptorIterator++) {
                adaptor = *adaptorIterator;
                //dprintf_full("AdaptorChain::adapt will use sub-adaptor %s\n",adaptor->getName());

                // WARNING:
                // we never delete input frames
                // only intermediate frames created by an adaptor are deleted
                frame=NULL;
                while (!inFrameList->empty()) {
                        frame = inFrameList->front();
                        //dprintf_full("AdaptorChain::adapt getting from inList Frame %p\n",frame);

                        retFrameList = adaptor->adapt(frame);
                        tmpFrame=NULL;
                        while (!retFrameList.empty()) {
                                tmpFrame=retFrameList.front();
                                retFrameList.pop_front();
                                //dprintf_full("AdaptorChain::adapt getting adaptation result Frame %p\n",tmpFrame);
                                outFrameList->push_back(tmpFrame);
                                if(frame && frame!=tmpFrame && frame!=frm) {
                                        dprintf_full("AdaptorChain::adapt deleting Frame %p\n",frame);
                                        delete frame;
                                        frame=NULL;
                                }
                        }
                        if(frame && frame!=tmpFrame && frame!=frm) {
                                // caching adaptors have to deep-copy
                                dprintf_full("AdaptorChain::adapt deleting cached Frame %p\n",frame);
                                delete frame;
                                frame=NULL;
                        }
                        inFrameList->pop_front();
                }
                delete inFrameList;

                // moving to next adaptor, outFrameList is going to be the new inFrameList
                inFrameList = outFrameList;
                outFrameList = new list < Frame * >;
        }

        delete outFrameList;
        list<Frame*> resultList=*inFrameList;
        
        delete inFrameList;
        return resultList;
}


bool AdaptorChain::addAdaptor(Adaptor * pAdaptor)
{
        // Some tricky check if inserting pAdaptor creates
        // a valid chain should be done here!
        mAdaptorList.push_back(pAdaptor);
        return true;
}


bool AdaptorChain::pushFrontAdaptor(Adaptor * pAdaptor){
        mAdaptorList.push_front(pAdaptor);
        return true;
}


u32 AdaptorChain::getTranscodingCosts() const
{
        std::list < Adaptor * >::const_iterator adaptorIterator;
        u32 sumC=0u;
  for (adaptorIterator = mAdaptorList.begin();
                         adaptorIterator != mAdaptorList.end(); 
                         adaptorIterator++) {

                if (*adaptorIterator != NULL) {
                        sumC+=(*adaptorIterator)->getTranscodingCosts();
                }
        }       
        return sumC;
}

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