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

Info

Last update:
12 Feb 2007

Documentation

Doxygen LXR

BufferedHttpMPGStreamReader.cpp

 /***********************************************************************
 *                                                                      *
 * ViTooKi                                                              *
 *                                                                      *
 * title: BufferedHTTPMPGStreamReader.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 "BufferedHttpMPGStreamReader.hpp"

#include "VideoESInfo.hpp"
#include "CompressedVideoFrame.hpp"
#include "CompressedAudioFrame.hpp"
#include "IO.hpp"
#include "../net/SDP.hpp"
#include "BitField.hpp"


#include "../container/ISOMP4ContainerFile.hpp"


BufferedHttpMPGStreamReader::BufferedHttpMPGStreamReader(ESInfo * esi, const char *file,
                                        bool write, bool omit, int bufferSize, int maxFrameSize): MPGStreamIO(esi, file, write, omit)
{

        dprintf_full("BufferedHttpMPGStreamReader::BufferedHttpMPGStreamReader file=%s writeonly=%s\n",(file?file:"NULL"),(write?"WRITE":"READ"));
        assert(esi);

        assert(bufferSize > 0);
        buffer = new u8[SAFETYDIST + bufferSize];
        initBuffer();
        this->bufferSize = bufferSize;
        bufferAtEnd = false;

        contentLength = 0;
        contentStart = NULL;

        this->maxFrameSize = maxFrameSize;
        DTS = 0;

        http = NULL;

        //FIXME: this call is necessary to get the correct filesize (contentlength)
        //however, with the videostream it produces an error when starting the datachannel-thread later (on wince)
        //thus, this call should be made in the calling object (e.g. simpleplayer) only for the audio-input 

        //this->open();
}


BufferedHttpMPGStreamReader::~BufferedHttpMPGStreamReader() 
{
        if (buffer != NULL) delete [] buffer;
        if (http != NULL) delete http;
}

bool BufferedHttpMPGStreamReader::open()
{

        setState(OPENING);

        http = new HttpRequest(url);

        if (http->makeHttpRequest()) {          
                initBuffer();
                contentLength = http->getContentLength();
                
                setState(OPEN);
                return true;
        }
        
        setState(CLOSED);
        return false;
}


bool BufferedHttpMPGStreamReader::close(bool immediate)
{
        if (http != NULL) {
                http->closeSock();
        }
        dprintf_small("BufferedHttpMPGStreamReader::close() set state to CLOSED!\n");
        setState(CLOSED);
        return true;
}

bool BufferedHttpMPGStreamReader::testFileopen()
{
        return true;
}


void BufferedHttpMPGStreamReader::initBuffer()
{
        lastBytesBuffered = bytesBuffered = 0;
        bytesRead = 0;
        bytesReadTotal = 0;
}



bool BufferedHttpMPGStreamReader::readBuffer()
{
        if (bufferAtEnd) {
                dprintf_small("BufferedHttpMPGStreamReader::readBuffer() buffer at the end --> set state to CLOSED!\n");
                setState(CLOSED);
                return false;
        }

        if (lastBytesBuffered != 0) {
                //copy bytes of last read access
                for (int i=0; i < SAFETYDIST; i++) buffer[i] = buffer[lastBytesBuffered+i];
        }

        bool waitForMoreData;
        do {
                waitForMoreData = false;
                lastBytesBuffered = bytesBuffered = http->continueReceive((char*)buffer + SAFETYDIST, bufferSize);
                dprintf_full("BufferedHttpMPGStreamReader::readBuffer() read %d bytes\n", bytesBuffered);
        
                if (bytesBuffered <= 0) {
                        if (bytesReadTotal < (signed)contentLength) {
                                msleep(10);
                                waitForMoreData = true;
                                dprintf_small("bufferedHttpMPGStreamReader:readBuffer() waiting for more data...\n");
                        } else {
                                bufferAtEnd = true;
                                bytesRead = 0;
                                return false;
                                //io will be closed by ::close() later!
                        }
                }
        } while (waitForMoreData == true);

        bytesRead = 0;
        return true;
}


int BufferedHttpMPGStreamReader::buffered_getc()
{
        if (bytesBuffered == 0) {
                if (!readBuffer()) {
                        return 0;
                }
        }
        bytesBuffered--;

        bytesReadTotal++;
        return (int)buffer[bytesRead++ + SAFETYDIST];
}


int BufferedHttpMPGStreamReader::buffered_read(u8 *buf, int nrBytes)
{
        for (int i = 0; i < nrBytes; i++) {
                buf[i] = buffered_getc();
        }
        return nrBytes;
}

int BufferedHttpMPGStreamReader::buffered_copy(u8 *buf, int nrBytes)
{
        int retVal = 0;

        if (bytesBuffered == 0) {
                if (!readBuffer()) {
                        return 0;
                }
        }

        if (nrBytes <= bytesBuffered) {
                memcpy(buf, buffer + bytesRead + SAFETYDIST, nrBytes);
                bytesRead += nrBytes;
                bytesReadTotal += nrBytes;
                bytesBuffered -= nrBytes;
                retVal = nrBytes;
        } else {
                retVal = buffered_copy(buf, bytesBuffered);
                retVal += buffered_copy(buf+retVal, nrBytes-retVal);
        }

        return retVal;
}


void BufferedHttpMPGStreamReader::goBack(int nrBytes)
{
        bytesRead -= nrBytes;
        bytesReadTotal -= nrBytes;
        bytesBuffered += nrBytes;
}


Frame *BufferedHttpMPGStreamReader::getFrame() {
        if (writeOnly || state != OPEN)
                return NULL;
 
        if (( (this->currentFrameNumber > this->endFrameNumber) && (endFrameNumber!=0) )) { // || feof(io)) {
                close(true);
                state=STREAMEOF;
                return NULL;
        }

        // now read the frame
        AU *au = new AU();
        Frame *frm = NULL;
        Frame::FrameType type = Frame::NN_VOP;

        // parse MPGFile for VOB_Code if it is a visual stream

        if(es->isVisualStream()) {
                // 00 00 01 182 dec -> 0x1B6 (=438 dec)
                u32 code = 2000;        // don't init to 0, we want the code from the 2nd frame, not the first
                int i = 0;

                u8 *data = new u8[MAX_FRAME_SIZE];

                do {
                        data[i] = buffered_getc();
                        code = (code << 8) | data[i]; //(u8)buffered_getc();
                        i++;
                        if ((i==4) && code == VOP_START_CODE) code = 0;
                } while ((code != VOP_START_CODE) && (i < maxFrameSize) && state != CLOSED);
                
                if (code == VOP_START_CODE) {
                        goBack(4);
                        i -= 4;
                        au->size = i;
                        au->payload = new u8[i];
                        memcpy(au->payload, data, i);
                        delete [] data;
                        dprintf_full("BufferedHttpMPGStreamReader::getFrame() read %d bytes of video frame\n", i);
                }

                if (au->size == 0) {
                        state = STREAMEOF;
                        delete au;
                        return NULL;
                }

                au->prio = IO_NETWORK_HIGHEST_PRIORITY;
                au->duration = es->getVOPTimeIncrement();
                au->cts = currentFrameNumber * es->getVOPTimeIncrement();
                au->dts = currentFrameNumber * es->getVOPTimeIncrement();
                au->sampleFlags = 0;
                if (code != VOP_START_CODE)
                au->err = SA_EOF;
                else
                au->err = SA_OK;

        }
        
        if(es->isAudioStream()) { //XXX not sure if it works properly
                // start code for MP3 frame is 11111111 111 (first 11 bits set) 
                u32 code = 2000;        // don't init to 0, we want the code from the 2nd frame, not the first
                int i = 0;

                //special handling for first frame
                if (framesSeen == 0) {
                        int ch = 0;
                        au->payload = new u8[1024];
                        do {
                                ch = buffered_getc();
                                au->payload[i] = ch;
                                i++;
                                code = (code << 8) | ch;
                        }
                        while ((code>>21) != 0x000007FF /*VOP_START_CODE for audio(actually MP3)*/);
                        au->size = i;
                } else {
                        au->payload = new u8[MAX_FRAME_SIZE];
                        au->size = buffered_copy(au->payload, maxFrameSize);
                }

                dprintf_full("BufferedHttpMPGStreamReader::getFrame() read %d bytes of audio frame\n", au->size);
        
                au->cts = DTS;
                au->dts = DTS;
                au->duration = 0;
                au->sampleFlags = 0;
                au->err = SA_OK;
        
                DTS += es->getVOPTimeIncrement();
        }

        // frame types will be detected in frm->setAU()!
        if(es->isVisualStream())
                frm = new CompressedVideoFrame(type, ((VideoESInfo*)es)->getWidth(), ((VideoESInfo*)es)->getHeight());
        else if(es->isAudioStream())
                frm=new CompressedAudioFrame(type);
        else
                frm = new CompressedVideoFrame(type, 0, 0);
        frm->setAU(au);
        frm->setMediaTimeScale(es->getMediaTimeScale());
        framesSeen++;
        currentFrameNumber++;


#ifdef _POSIX_PRIORITY_SCHEDULING
        sched_yield();
#else
        // for windows pthread lib!
#ifdef WIN32
#ifndef WINCE
        sched_yield();
#else
        Sleep(1);
#endif
#endif
#endif

  return frm;
}

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