rtmp 协议测试函数

#include "cvector.h"
#include"stdio.h"
#include <memory.h>
#include <vector>
#include <string>

using namespace std;

#ifdef __APPLE__
#import <CoreFoundation/CFByteOrder.h> // TODO: Remove Apple framework reliance in this code.

#define double_swap CFConvertFloat64HostToSwapped
#else
#include <byteswap.h>
inline double double_swap(double value)
{
    union v {
        double       f;
        uint64_t     i;
    };
    
    union v val;
    
    val.f = value;
    val.i = bswap_64(val.i);
    
    return val.f;
}

#define CFConvertDoubleSwappedToHost double_swap
typedef double CFSwappedFloat64;
#endif


typedef enum
{
    kAMFNumber = 0,
    kAMFBoolean,
    kAMFString,
    kAMFObject,
    kAMFMovieClip,        /* reserved, not used */
    kAMFNull,
    kAMFUndefined,
    kAMFReference,
    kAMFEMCAArray,
    kAMFObjectEnd,
    kAMFStrictArray,
    kAMFDate,
    kAMFLongString,
    kAMFUnsupported,
    kAMFRecordSet,        /* reserved, not used */
    kAMFXmlDoc,
    kAMFTypedObject,
    kAMFAvmPlus,        /* switch to AMF3 */
    kAMFInvalid = 0xff
} AMFDataType_t;

/************************************************
 * Buffer writing funcs
 ************************************************/
static inline void put_buff(std::vector<uint8_t>& data, const uint8_t *src, size_t srcsize)
{
    size_t pos = data.size();
    data.resize(data.size() + srcsize);
    memcpy(&data[pos],src,srcsize);
}

static inline void put_byte(std::vector<uint8_t>& data, uint8_t val)
{
    data.push_back(val);
}

static inline void put_be16(std::vector<uint8_t>& data, short val)
{
    char buf[2];
    buf[1] = val & 0xff;
    buf[0] = (val >> 8) & 0xff;
    
    put_buff(data,(const uint8_t*)buf,sizeof(uint16_t));
}
static inline int get_be16(uint8_t* val) {
    return ((val[0]&0xff) << 8) | ((val[1]&0xff)) ;
}
static inline void put_be24(std::vector<uint8_t>& data, int32_t val)
{
    char buf[3];
    
    buf[2] = val & 0xff;
    buf[1] = (val >> 8) & 0xff;
    buf[0] = (val >> 16) & 0xff;
    
    put_buff(data, (const uint8_t*)buf, 3);
    
}

static inline int get_be24(uint8_t* val) {
    int ret = ((val[2]&0xff)) | ((val[1]&0xff) << 8) | ((val[0]&0xff)<<16) ;
    return ret;
}

static inline void put_be32(std::vector<uint8_t>& data, int32_t val)
{
    char buf[4];
    
    buf[3] = val & 0xff;
    buf[2] = (val >> 8) & 0xff;
    buf[1] = (val >> 16) & 0xff;
    buf[0] = (val >> 24) & 0xff;
    
    put_buff(data, (const uint8_t*)buf, sizeof(int32_t));
}

static inline int get_be32(uint8_t* val) {
    return ((val[0]&0xff)<<24) | ((val[1]&0xff)<<16) | ((val[2]&0xff) << 8) | ((val[3]&0xff)) ;
}

static inline void put_tag(std::vector<uint8_t>& data, uint8_t *tag)
{
    while (*tag) {
        put_byte(data, *tag++);
    }
}

static inline void put_string(std::vector<uint8_t>& data, std::string string) {
    if(string.length() < 0xFFFF) {
        put_byte(data, kAMFString);
        put_be16(data, string.length());
    } else {
        put_byte(data, kAMFLongString);
        put_be32(data, static_cast<int32_t>(string.length()));
    }
    put_buff(data, (const uint8_t*)string.c_str(), string.length());
}

static inline std::string get_string(uint8_t* buf, int& bufsize) {
    int len = 0;
    if(*buf++ == kAMFString) {
        len = get_be16(buf);
        buf+=2;
        bufsize = 2 + len;
    } else {
        len = get_be32(buf);
        buf+=4;
        bufsize = 4 + len;
    }
    
    std::string val((const char*)buf,len);
    return val;
}

static inline std::string get_string(uint8_t* buf) {
    int buflen = 0;
    return get_string(buf, buflen);
}

static inline void put_double(std::vector<uint8_t>& data, double val) {
    put_byte(data, kAMFNumber);
    
    CFSwappedFloat64 buf = CFConvertFloat64HostToSwapped(val);
    
    put_buff(data, (uint8_t*)&buf, sizeof(CFSwappedFloat64));
}

static inline double get_double(uint8_t* buf) {
    CFSwappedFloat64 arg;
    memcpy(&arg, buf, sizeof(arg));
    return CFConvertDoubleSwappedToHost(arg);
}

static inline void put_bool(std::vector<uint8_t>& data, bool val) {
    put_byte(data, kAMFBoolean);
    put_byte(data, val);
}

static inline void put_name(std::vector<uint8_t>& data, std::string name) {
    put_be16(data, name.size());
    put_buff(data, (uint8_t*)name.c_str(), name.size());
}

static inline void put_named_double(std::vector<uint8_t>& data, std::string name, double val) {
    put_name(data,name);
    put_double(data, val);
}

static inline void put_named_string(std::vector<uint8_t>& data, std::string name, std::string val) {
    put_name(data, name);
    put_string(data, val);
}

static inline void put_named_bool(std::vector<uint8_t>& data, std::string name, bool val) {
    put_name(data,name);
    put_bool(data, val);
}

int main()
{
    std::vector<uint8_t> buff;

    put_string(buff, "connect");
    put_double(buff, 12.11);
    
    put_be16(buff,12);
    put_string( buff, "abc" );
    
    int norg;
    string sout = get_string( &buff[0], norg );

    int nns = (norg + 1) + 1;
    double dd = get_double( &buff[0] + nns );
    nns += sizeof(double);
    
    short bn  = get_be16( &buff[0] + nns );
    nns += sizeof(short);
    
    string vv = get_string( &buff[0] + nns, norg );
    
    return 0;
}