RTMP.h

Go to the documentation of this file.

//
//   Copyright (C) 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_RTMP_H
#define GNASH_RTMP_H

#include <boost/cstdint.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/scoped_ptr.hpp>
#include <deque>
#include <map>

#include "SimpleBuffer.h"
#include "Socket.h"
#include "dsodefs.h"

#define RTMP_DEFAULT_CHUNKSIZE  128

// Forward declarations.
namespace gnash {
    namespace rtmp {
        class HandShaker;
    }
    class URL;
}

namespace gnash {
namespace rtmp {

//
//
enum ControlType
{
    CONTROL_CLEAR_STREAM = 0x00,
    CONTROL_CLEAR_BUFFER = 0x01,
    CONTROL_STREAM_DRY = 0x02,
    CONTROL_BUFFER_TIME = 0x03,
    CONTROL_RESET_STREAM = 0x04,
    CONTROL_PING = 0x06,
    CONTROL_PONG = 0x07,
    CONTROL_REQUEST_VERIFY = 0x1a,
    CONTROL_RESPOND_VERIFY = 0x1b,
    CONTROL_BUFFER_EMPTY = 0x1f,
    CONTROL_BUFFER_READY = 0x20
};

//
//
//
//
enum Channels
{
    CHANNEL_CONTROL1 = 0x02,
    CHANNEL_CONTROL2 = 0x03,
    CHANNEL_VIDEO = 0x08
};

enum PacketType
{
    PACKET_TYPE_NONE = 0x00,
    PACKET_TYPE_CHUNK_SIZE = 0x01,
    PACKET_TYPE_BYTES_READ = 0x03,
    PACKET_TYPE_CONTROL = 0x04,
    PACKET_TYPE_SERVERBW = 0x05,
    PACKET_TYPE_CLIENTBW = 0x06,
    PACKET_TYPE_AUDIO = 0x08,
    PACKET_TYPE_VIDEO = 0x09,
    PACKET_TYPE_FLEX_STREAM_SEND = 0x0f,
    PACKET_TYPE_FLEX_SHARED_OBJECT = 0x10,
    PACKET_TYPE_FLEX_MESSAGE = 0x11,
    PACKET_TYPE_METADATA = 0x12,
    PACKET_TYPE_SHARED_OBJECT = 0x13,
    PACKET_TYPE_INVOKE = 0x14,
    PACKET_TYPE_FLV = 0x16
};

//
//
//
enum PacketSize {
    RTMP_PACKET_SIZE_LARGE = 0,
    RTMP_PACKET_SIZE_MEDIUM = 1,
    RTMP_PACKET_SIZE_SMALL = 2,
    RTMP_PACKET_SIZE_MINIMUM = 3
};

struct RTMPHeader
{
    static const size_t headerSize = 18;

    RTMPHeader()
        :
        headerType(RTMP_PACKET_SIZE_LARGE),
        packetType(PACKET_TYPE_NONE),
        _timestamp(0),
        _streamID(0),
        channel(0),
        dataSize(0)
    {}

    PacketSize headerType;
    PacketType packetType;

    //
    boost::uint32_t _timestamp;

    boost::uint32_t _streamID;

    size_t channel;

    // The size of the data.
    size_t dataSize;

};

//
//
struct RTMPPacket
{
    //
    explicit RTMPPacket(size_t reserve = 0);
    
    //
    RTMPPacket(const RTMPPacket& other);

    ~RTMPPacket() {}

    RTMPHeader header;

    //
    boost::shared_ptr<SimpleBuffer> buffer;

    size_t bytesRead;
};


//
inline bool
hasPayload(const RTMPPacket& p)
{
    return (p.buffer.get());
}

//
inline void
clearPayload(RTMPPacket& p)
{
    p.buffer.reset();
    p.bytesRead = 0;
}

//
inline size_t
payloadSize(const RTMPPacket& p)
{
    assert(hasPayload(p));
    const SimpleBuffer& buf = *p.buffer;
    assert(buf.size() >= RTMPHeader::headerSize);
    return buf.size() - RTMPHeader::headerSize;
}

inline boost::uint8_t*
payloadData(RTMPPacket& p)
{
    assert(hasPayload(p));
    SimpleBuffer& buf = *p.buffer;
    return buf.data() + RTMPHeader::headerSize;
}

inline const boost::uint8_t*
payloadData(const RTMPPacket& p)
{
    assert(hasPayload(p));
    const SimpleBuffer& buf = *p.buffer;
    return buf.data() + RTMPHeader::headerSize;
}

//
inline const boost::uint8_t*
payloadEnd(const RTMPPacket& p)
{
    assert(hasPayload(p));
    SimpleBuffer& buf = *p.buffer;
    return buf.data() + buf.size();
}

//
inline bool
isReady(const RTMPPacket& p) {
    return p.bytesRead == p.header.dataSize;
}


//
//
//
//
struct DSOEXPORT RTMP
{

    RTMP();

    ~RTMP();

    //
    //
    bool connect(const URL& url);

    //
    void call(const SimpleBuffer& amf);

    //
    //
    void play(const SimpleBuffer& amf, int id);

    //
    void setBufferTime(size_t time, int streamID);

    //
    //
    bool connected() const {
        return _connected;
    }

    //
    bool error() const {
        return _error;
    }

    //
    //
    //
    void update();

    //
    void close();

    //
    boost::shared_ptr<SimpleBuffer> getMessage() {
        if (_messageQueue.empty()) return boost::shared_ptr<SimpleBuffer>();
        boost::shared_ptr<SimpleBuffer> b = _messageQueue.front();
        _messageQueue.pop_front();
        return b;
    }
    
    //
    boost::shared_ptr<SimpleBuffer> getFLVFrame() {
        if (_flvQueue.empty()) return boost::shared_ptr<SimpleBuffer>();
        boost::shared_ptr<SimpleBuffer> b = _flvQueue.front();
        _flvQueue.pop_front();
        return b;
    }

    void handlePacket(const RTMPPacket& packet);
    
    int readSocket(boost::uint8_t* dst, int num);

    bool sendPacket(RTMPPacket& packet);

    //
    void setServerBandwidth(boost::uint32_t bw) {
        _serverBandwidth = bw;
    }

    boost::uint32_t serverBandwidth() const {
        return _serverBandwidth;
    }

    void setBandwidth(boost::uint32_t bw) {
        _bandwidth = bw;
    }

    boost::uint32_t bandwidth() const {
        return _bandwidth;
    }

    int _inChunkSize;
    int m_mediaChannel;
    boost::uint8_t m_nClientBW2;
    size_t _bytesIn;
    size_t _bytesInSent;

private:

    enum ChannelType {
        CHANNELS_IN,
        CHANNELS_OUT
    };
    
    bool readPacketHeader(RTMPPacket& packet);

    bool readPacketPayload(RTMPPacket& packet);

    bool hasPacket(ChannelType t, size_t channel) const;

    //
    RTMPPacket& getPacket(ChannelType t, size_t channel);

    //
    RTMPPacket& storePacket(ChannelType t, size_t channel, const RTMPPacket& p);

    //
    //
    typedef std::map<size_t, RTMPPacket> ChannelSet;
    
    Socket _socket;

    ChannelSet _inChannels;

    ChannelSet _outChannels;
    
    std::deque<boost::shared_ptr<SimpleBuffer> > _messageQueue;
    std::deque<boost::shared_ptr<SimpleBuffer> > _flvQueue;

    boost::uint32_t _serverBandwidth;

    boost::uint32_t _bandwidth;

    size_t _outChunkSize;

    boost::scoped_ptr<HandShaker> _handShaker;

    bool _connected;

    bool _error;

    //
    boost::scoped_ptr<RTMPPacket> _incompletePacket;

};

DSOEXPORT bool sendServerBW(RTMP& r);

bool sendCtrl(RTMP& r, ControlType, unsigned int nObject, unsigned int nTime);

std::ostream& operator<<(std::ostream& o, PacketType p);

std::ostream& operator<<(std::ostream& o, ControlType t);

} // namespace rtmp

} // namespace gnash
#endif