NetStream_as.h

Go to the documentation of this file.

// 
//   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc
// 
// This program 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 3 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA


#ifndef GNASH_NETSTREAM_H
#define GNASH_NETSTREAM_H


#ifndef __STDC_CONSTANT_MACROS
#define __STDC_CONSTANT_MACROS
#endif

#include <boost/intrusive_ptr.hpp>
#include <string>
#include <boost/ptr_container/ptr_deque.hpp>
#include <boost/scoped_ptr.hpp>

#include "MediaParser.h"
#include "PlayHead.h" // for composition
#include "VideoDecoder.h" // for visibility of dtor
#include "AudioDecoder.h" // for visibility of dtor
#include "VirtualClock.h"
#include "Relay.h" // for ActiveRelay inheritance

// Forward declarations
namespace gnash {
    class CharacterProxy;
    class IOChannel;
    class NetConnection_as;
    class as_function;
    class DisplayObject;
    struct ObjectURI;
    namespace media {
        class MediaHandler;
    }
    namespace sound {
        class sound_handler;
        class InputStream;
    }
}

namespace gnash {

//
class BufferedAudioStreamer {
public:

    BufferedAudioStreamer(sound::sound_handler* handler);

    //
    class CursoredBuffer
    {
    public:
        CursoredBuffer()
            :
            m_size(0),
            m_data(NULL),
            m_ptr(NULL)
        {}

        ~CursoredBuffer()
        {
            delete [] m_data;
        }

        boost::uint32_t m_size;

        //
        boost::uint8_t* m_data;

        boost::uint8_t* m_ptr;
    };

    typedef boost::ptr_deque<CursoredBuffer> AudioQueue;

    // Delete all samples in the audio queue.
    void cleanAudioQueue();

    sound::sound_handler* _soundHandler;

    AudioQueue _audioQueue;

    size_t _audioQueueSize;

    boost::mutex _audioQueueMutex;

    // Id of an attached audio streamer, 0 if none
    sound::InputStream* _auxStreamer;

    //
    void attachAuxStreamer();

    //
    void detachAuxStreamer();

    unsigned int fetch(boost::int16_t* samples, unsigned int nSamples,
                    bool& eof);

    static unsigned int fetchWrapper(void* owner, boost::int16_t* samples,
                    unsigned int nSamples, bool& eof);

    //
    void push(CursoredBuffer* audio);

};

// -----------------------------------------------------------------

//
class NetStream_as : public ActiveRelay
{

public:

    enum PauseMode {
      pauseModeToggle = -1,
      pauseModePause = 0,
      pauseModeUnPause = 1  
    };

    NetStream_as(as_object* owner);

    ~NetStream_as();

    PlayHead::PlaybackStatus playbackState() const {
        return _playHead.getState();
    }

    //
    int videoHeight() const;

    //
    int videoWidth() const;

    void close();

    void setAudioController(DisplayObject* controller);
 
    //
    void pause(PauseMode mode);

    //
    void play(const std::string& source);

    //
    void seek(boost::uint32_t pos);

    //
    boost::int32_t time();

    void update();
    
    double getCurrentFPS()  { return 0; }

    //
    void setNetCon(NetConnection_as* nc) {
        _netCon = nc;
    }

    bool isConnected() const { return (_netCon); }

    //
    void setBufferTime(boost::uint32_t time);

    //
    boost::uint32_t bufferTime() { return _bufferTime; }

    long bytesLoaded();

    //
    long bytesTotal();

    //
    long bufferLength();

    //
    std::auto_ptr<image::GnashImage> get_video();
    
    void setInvalidatedVideo(DisplayObject* ch)
    {
        _invalidatedVideoCharacter = ch;
    }

    virtual void markReachableResources() const;

    //
    static unsigned int audio_streamer(void *udata, boost::int16_t* samples,
            unsigned int nSamples, bool& eof);

private:
    
    enum StatusCode {
    
        // Internal status, not a valid ActionScript value
        invalidStatus,

        bufferEmpty,

        bufferFull,

        bufferFlush,

        playStart,

        playStop,

        seekNotify,

        streamNotFound,

        invalidTime
    };

    enum DecodingState {
        DEC_NONE,
        DEC_STOPPED,
        DEC_DECODING,
        DEC_BUFFERING
    };

    typedef std::pair<std::string, std::string> NetStreamStatus;

    //
    void getStatusCodeInfo(StatusCode code, NetStreamStatus& info);

    as_object* getStatusObject(StatusCode code);

    //
    void initVideoDecoder(const media::VideoInfo& info);

    //
    void initAudioDecoder(const media::AudioInfo& parser);

    // Setups the playback
    bool startPlayback();

    // Pauses the playhead 
    //
    // Users:
    //  - ::decodeFLVFrame() 
    //  - ::pause() 
    //  - ::play() 
    //
    void pausePlayback();

    // Resumes the playback 
    //
    // Users:
    //  - ::av_streamer() 
    //  - ::play() 
    //  - ::startPlayback() 
    //  - ::advance() 
    //
    void unpausePlayback();

    //
    void refreshVideoFrame(bool alsoIfPaused = false);

    void refreshAudioBuffer();

    //
    std::auto_ptr<image::GnashImage> decodeNextVideoFrame();

    //
    BufferedAudioStreamer::CursoredBuffer* decodeNextAudioFrame();

    void pushDecodedAudioFrames(boost::uint32_t ts);

    //
    std::auto_ptr<image::GnashImage> getDecodedVideoFrame(boost::uint32_t ts);

    DecodingState decodingStatus(DecodingState newstate = DEC_NONE);

    void parseNextChunk();

    //
    void setStatus(StatusCode code);

    //
    void processStatusNotifications();

    void stopAdvanceTimer();

    void startAdvanceTimer();

    NetConnection_as* _netCon;

    boost::scoped_ptr<CharacterProxy> _audioController;
    
    // The size of the buffer in milliseconds
    boost::uint32_t _bufferTime;

    // Mutex to insure we don't corrupt the image
    boost::mutex image_mutex;

    // The image/videoframe which is given to the renderer
    std::auto_ptr<image::GnashImage> _imageframe;

    // The video URL
    std::string url;

    // The input media parser
    std::auto_ptr<media::MediaParser> _parser;

    // The position in the inputfile, only used when not playing a FLV
    long _inputPos;

    DisplayObject* _invalidatedVideoCharacter;

    DecodingState _decoding_state;

    // Mutex protecting _playback_state and _decoding_state
    // (not sure a single one is appropriate)
    boost::mutex _state_mutex;
    
    std::auto_ptr<media::VideoDecoder> _videoDecoder;

    bool _videoInfoKnown;

    std::auto_ptr<media::AudioDecoder> _audioDecoder;

    bool _audioInfoKnown;

    boost::scoped_ptr<InterruptableVirtualClock> _playbackClock;

    PlayHead _playHead;

    // Current sound handler
    sound::sound_handler* _soundHandler;

    // Current media handler
    media::MediaHandler* _mediaHandler;

    //
    std::auto_ptr<IOChannel> _inputStream;

    BufferedAudioStreamer _audioStreamer;

    StatusCode _statusCode;

    boost::mutex _statusMutex;

};

void netstream_class_init(as_object& global, const ObjectURI& uri);

void registerNetStreamNative(as_object& global);

} // gnash namespace

#endif