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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

DataSink.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title:       DataSink.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 "DataSink.hpp"
#include "adaptors/Forwarder.hpp"

DataSink::DataSink(u32 id, IO * out, const char *addr, int prt, 
                                                                         Adaptor * adaptor) {
        // try to set the address
        // if this fails we have a name not an ip-address
        // perform a dns lookup, but don't use qt -> signals
        if (addr) {
                adr = new char[strlen(addr) + 1];
                strcpy(adr, addr);
        } else {
                adr = NULL;
        }
        if (adaptor == NULL)
                localAdaptor = new Forwarder();
        else
                localAdaptor = adaptor;
        port = prt;
        output = out;
        lastFrm = NULL;
        clientId=id;
}


DataSink::~DataSink() {
        dprintf_full("DataSink::Destructor\n");
        if (output) {
                if (output->getState() != IO::CLOSED)
                        output->close(true);
                if(output->running())
                        output->wait();         
                delete output;
        }
        if (adr)
                delete[] adr;
        if(localAdaptor) {
                dprintf_full("DataSink::~DataSink() deleting %s\n", localAdaptor->getName());
                delete localAdaptor;
        }
}


const char *DataSink::getAddress() const {
        return adr;
}


bool DataSink::send(Frame * frm) {
#ifdef VITOOKI_DEBUG
        double start_dtime, now_dtime;
        struct timeval now_tv;
#endif
                
        lastFrm = frm;
        bool retVal = true;
        if (output) {
                assert(frm != NULL);
                assert(frm->getAU() != NULL);
                dprintf_full("DataSink::send: Output is set at client. Got frame with CTS %i prio %i size %i\n",
                                                                 frm->getAU()->cts, frm->getAU()->prio, frm->getAU()->size);
                if (output->getState() != IO::OPEN &&
                                output->getState() != IO::MUTED &&
                                output->getState() != IO::PAUSED)
                        output->open();
                //first, output should always be set to IO::OPEN
                if (output->getState() != IO::OPEN &&
                                output->getState() != IO::MUTED &&
                                output->getState() != IO::PAUSED) {
                        dprintf_err("DataSink::send: State = %i failed to open OUTPUT\n", output->getState());
                        return false;
                }
                
                
                if (output->getState() != IO::MUTED) {
                        // everything ok,
                        // now adapt the data
                        
#ifdef VITOOKI_DEBUG
                        gettimeofday(&now_tv,NULL);
                        start_dtime = now_tv.tv_sec + now_tv.tv_usec/1000000.0;
#endif
                        
                        list < Frame * >fr;
                        fr = localAdaptor->adapt(frm);
                        
#ifdef VITOOKI_DEBUG
                        gettimeofday(&now_tv,NULL);
                        now_dtime = now_tv.tv_sec + now_tv.tv_usec/1000000.0;
                        
                        if (localAdaptor != NULL)
                                dprintf_full("DataSink::send(): local adaptation (%s) worked for %2.0f msecs\n",localAdaptor->getName(),
                                                                                 (now_dtime-start_dtime)*1000.0);
#endif
                        
                        list < Frame * >::iterator fI;
                        while (!fr.empty()) {
                                // now write the data   
                                fI = fr.begin();
                                int i = output->writeFrame((*fI));
                                if (*fI != frm)
                                        delete *fI;
                                fr.pop_front();
                                if (i <= 0) {
                                        dprintf_small("DataSink: Failed to write frame? %i\n", i);
                                        retVal = false;
                                }
                        }
                }//not MUTED
                else { 
                        //completely ignore frame, since no output could handle still encoded frame!
                        /*
                        // give the un-adapted frame to output, so CTS might still be
                        //used for synchronization, but the frame cannot be viewed!!!
                        int i = output->writeFrame(frm);
                        //still encoded frm will deleted within DataChannel
                        if (i <= 0) {
                        dprintf_small("DataSink: Failed to write muted frame? %i\n", i);
                        retVal = false;
                        }
                        */
                }
                
                return retVal;
        }
        return false;           // no output is set
}


bool DataSink::close(bool immediate) {
        list < Frame * >lFrm2 = localAdaptor->close();
        list < Frame * >::iterator lFrm2I;
        int i;
        
        dprintf_full("DataSink::close\n");
        while (!lFrm2.empty()) {
                lFrm2I = lFrm2.begin();
                if (output && !immediate) {
                        i = output->writeFrame((*lFrm2I));
                }
                if (*lFrm2I != lastFrm)
                        delete *lFrm2I;
                lFrm2.pop_front();
        }
        if (output)
                return output->close(immediate);
        return false;
}


void DataSink::pauseOutput() {
        if (output)
                output->pause();
}


void DataSink::playOutput(double prefetch) {
        if (output)
                output->play(prefetch);
}


void DataSink::muteOutput() {
        if (output)
                output->mute();
}

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