librtmp源码分析--AMF编码

先复习何谓大小端

小端格式和大端格式(Little-Endian&Big-Endian)

不同的CPU有不同的字节序类型，这些字节序是指整数在内存中保存的顺序。

最常见的有两种：

1． Little-endian：将低序字节存储在起始地址（低位编址）

2． Big-endian：将高序字节存储在起始地址（高位编址）

LE（little-endian）：

最符合人的思维的字节序 

地址低位存储值的低位 

地址高位存储值的高位 

怎么讲是最符合人的思维的字节序，是因为从人的第一观感来说 

低位值小，就应该放在内存地址小的地方，也即内存地址低位 

反之，高位值就应该放在内存地址大的地方，也即内存地址高位 
 

BE（big-endian）： 

最直观的字节序 

地址低位存储值的高位 

地址高位存储值的低位 

为什么说直观，不要考虑对应关系 

只需要把内存地址从左到右按照由低到高的顺序写出 

把值按照通常的高位到低位的顺序写出 

两者对照，一个字节一个字节的填充进去 
 

例子1：在内存中双字0x01020304(DWORD)的存储方式。 

内存地址 4000 4001 4002 4003 

   LE      04   03   02   01 

   BE      01   02   03   04 

注：每个地址存1个字节，每个字有4个字节。2位16进制数是1个字节（0xFF=11111111）。

 

例子2：如果我们将0x1234abcd写入到以0x0000开始的内存中，则结果为

　　　　big-endian   little-endian

0x0000    0x12         0xcd

0x0001    0x23         0xab

0x0002    0xab         0x34

0x0003    0xcd         0x12

x86系列的CPU都是little-endian的字节序。

了解浮点数如何存储？

C语言和C#语言中，对于浮点类型的数据采用单精度类型（float）和双精度类型(double)来存储，float数据占用32bit,double数据占用64bit,我们在声明一个变量float f= 2.25f的时候，是如何分配内存的呢？如果胡乱分配，那世界岂不是乱套了么，其实不论是float还是double在存储方式上都是遵从IEEE的规范的，float遵从的是IEEE R32.24 ,而double 遵从的是R64.53。

    无论是单精度还是双精度在存储中都分为三个部分：

1. 符号位(Sign) : 0代表正，1代表为负
2. 指数位（Exponent）:用于存储科学计数法中的指数数据，并且采用移位存储
3. 尾数部分（Mantissa）：尾数部分

 其中float的存储方式如下图所示：

而双精度的存储方式为:

 

根据IEEE（美国电气和电子工程师学会）754标准中的定义，单精度（Single Precision）浮点数是32位（即4字节）的，双精度（Double Precision）浮点数是64位（即8字节）的。两者的S、E、M所占的位数以及表示方法由下表可知：

	S	E	M	表示公式	偏移量
单精度浮点数	1（第31位）	8（30到23位）	23（22到0位）	(-1)^S*2(E-127)*1.M	127
双精度浮点数	1（第63位）	11（62到52位）	52（51到0位）	(-1)^S*2(E-1023)*1.M	1023

P是阶码，通常使用移码表示（移码和补码只有符号位相反，其余都一样。对于正数而言，原码、反码和补码都一样；对于负数而言，补码就是其绝对值的原码全部取反，然后加1）。阶码可以为正数，也可以为负数，为了处理负指数的情况，实际的指数值按要求需要加上一个偏差（Bias）值作为保存在指数域中的值，单精度数的偏差值为127，双精度数的偏差值为1023。例如，单精度的实际指数值0在指数域中将保存为127，而保存在指数域中的64则表示实际的指数值-63，偏差的引入使得对于单精度数，实际可以表达的指数值的范围就变成-127到128之间（包含两端）。
　　M为尾数，其中单精度数为23位长，双精度数为52位长。IEEE标准要求浮点数必须是规范的。这意味着尾数的小数点左侧必须为1，因此在保存尾数的时候，可以省略小数点前面这个1，从而腾出一个二进制位来保存更多的尾数。这样实际上用23位长的尾数域表达了24位的尾数。例如对于单精度数而言，二进制的1001.101（对应于十进制的9.625）可以表达为1.001101 × 23，所以实际保存在尾数域中的值为00110100000000000000000，即去掉小数点左侧的1，并用0在右侧补齐。
　　根据标准要求，无法精确保存的值必须向最接近的可保存的值进行舍入，即不足一半则舍，一半以上（包括一半）则进。不过对于二进制浮点数而言，还多一条规矩，就是当需要舍入的值刚好是一半时，不是简单地进，而是在前后两个等距接近的可保存的值中，取其中最后一位有效数字为零者。
　　据以上分析，IEEE 754标准中定义浮点数的表示范围为：

	二进制（Binary）	十进制（Decimal）
单精度浮点数	± (2-2^-23) × 2127	~ ± 10^38.53
双精度浮点数	± (2-2^-52) × 21023	~ ± 10^308.25

　　浮点数的表示有一定的范围，超出范围时会产生溢出（Flow），一般称大于绝对值最大的数据为上溢（Overflow），小于绝对值最小的数据为下溢（Underflow）。

单精度浮点数和双精度浮点数都是用IEEE 754标准定义的，其中有一些特殊约定，例如：
　　1、当P=0，M=0时，表示0。
　　2、当P=255，M=0时，表示无穷大，用符号位来确定是正无穷大还是负无穷大。
　　3、当P=255，M≠0时，表示NaN（Not a Number，不是一个数）。

    R32.24和R64.53的存储方式都是用科学计数法来存储数据的，比如8.25用十进制的科学计数法表示就为:8.25*,而120.5可以表示为:1.205*,这些小学的知识就不用多说了吧。而我们傻蛋计算机根本不认识十进制的数据，他只认识0，1，所以在计算机存储中，首先要将上面的数更改为二进制的科学计数法表示，8.25用二进制表示可表示为1000.01,我靠，不会连这都不会转换吧?那我估计要没辙了。120.5用二进制表示为：1110110.1用二进制的科学计数法表示1000.01可以表示为1.0001*,1110110.1可以表示为1.1101101*,任何一个数都的科学计数法表示都为1.xxx*,尾数部分就可以表示为xxxx,第一位都是1嘛，干嘛还要表示呀？可以将小数点前面的1省略，所以23bit的尾数部分，可以表示的精度却变成了24bit，道理就是在这里，那24bit能精确到小数点后几位呢，我们知道9的二进制表示为1001，所以4bit能精确十进制中的1位小数点，24bit就能使float能精确到小数点后6位，而对于指数部分，因为指数可正可负，8位的指数位能表示的指数范围就应该为:-127-128了，所以指数部分的存储采用移位存储，存储的数据为元数据+127，下面就看看8.25和120.5在内存中真正的存储方式。

     首先看下8.25，用二进制的科学计数法表示为:1.0001*

按照上面的存储方式，符号位为:0，表示为正，指数位为:3+127=130 ,位数部分为,故8.25的存储方式如下图所示:

而单精度浮点数120.5的存储方式如下图所示:

那么如果给出内存中一段数据，并且告诉你是单精度存储的话，你如何知道该数据的十进制数值呢？其实就是对上面的反推过程，比如给出如下内存数据：0100001011101101000000000000，首先我们现将该数据分段，0 10000 0101 110 1101 0000 0000 0000 0000，在内存中的存储就为下图所示：

根据我们的计算方式，可以计算出，这样一组数据表示为:1.1101101*=120.5

而双精度浮点数的存储和单精度的存储大同小异，不同的是指数部分和尾数部分的位数。所以这里不再详细的介绍双精度的存储方式了，只将120.5的最后存储方式图给出，大家可以仔细想想为何是这样子的

下面我就这个基础知识点来解决一个我们的一个疑惑，请看下面一段程序，注意观察输出结果

            float f = 2.2f;
            double d = (double)f;
            Console.WriteLine(d.ToString("0.0000000000000"));
            f = 2.25f;
            d = (double)f;
            Console.WriteLine(d.ToString("0.0000000000000"));

可能输出的结果让大家疑惑不解，单精度的2.2转换为双精度后，精确到小数点后13位后变为了2.2000000476837，而单精度的2.25转换为双精度后，变为了2.2500000000000，为何2.2在转换后的数值更改了而2.25却没有更改呢？很奇怪吧？其实通过上面关于两种存储结果的介绍，我们已经大概能找到答案。首先我们看看2.25的单精度存储方式，很简单 0 1000 0001 001 0000 0000 0000 0000 0000,而2.25的双精度表示为:0 100 0000 0001 0010 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000,这样2.25在进行强制转换的时候，数值是不会变的，而我们再看看2.2呢，2.2用科学计数法表示应该为：将十进制的小数转换为二进制的小数的方法为将小数*2，取整数部分，所以0.282=0.4，所以二进制小数第一位为0.4的整数部分0，0.4×2=0.8，第二位为0,0.8*2=1.6,第三位为1，0.6×2 = 1.2，第四位为1，0.2*2=0.4，第五位为0，这样永远也不可能乘到=1.0，得到的二进制是一个无限循环的排列 00110011001100110011... ,对于单精度数据来说，尾数只能表示24bit的精度，所以2.2的float存储为:

但是这样存储方式，换算成十进制的值，却不会是2.2的，应为十进制在转换为二进制的时候可能会不准确，如2.2，而double类型的数据也存在同样的问题，所以在浮点数表示中会产生些许的误差，在单精度转换为双精度的时候，也会存在误差的问题，对于能够用二进制表示的十进制数据，如2.25，这个误差就会不存在，所以会出现上面比较奇怪的输出结果。

Bytes.h

//自已字节序的一些宏，在win32平台下，系统的字节序默认为小端字节序

#ifndef __BYTES_H__
#define __BYTES_H__
#include <stdint.h>
#ifdef _WIN32
/* Windows is little endian only */
#define  __LITTLE_ENDIAN  1234
#define  __BIG_ENDIAN      4321
#define  __BYTE_ORDER   __LITTLE_ENDIAN
#define  __FLOAT_WORD_ORDER   __BYTE_ORDER
typedef unsigned char uint8_t;
#else /* !_WIN32 */
#include <sys/param.h>
#if defined(BYTE_ORDER) && !defined(__BYTE_ORDER)
#define __BYTE_ORDER    BYTE_ORDER
#endif

#if defined(BIG_ENDIAN) && !defined(__BIG_ENDIAN)
#define __BIG_ENDIAN BIG_ENDIAN
#endif

#if defined(LITTLE_ENDIAN) && !defined(__LITTLE_ENDIAN)
#define __LITTLE_ENDIAN LITTLE_ENDIAN
#endif
#endif /* !_WIN32 */


/* define default endianness */
#ifndef __LITTLE_ENDIAN
#define __LITTLE_ENDIAN 1234
#endif

#ifndef __BIG_ENDIAN
#define __BIG_ENDIAN 4321
#endif

#ifndef __BYTE_ORDER
#warning "Byte order not defined on your system, assuming little endian!"
#define __BYTE_ORDER __LITTLE_ENDIAN
#endif

/* ok, we assume to have the same float word order and byte order if float word order is not defined */
#ifndef __FLOAT_WORD_ORDER
#warning "Float word order not defined, assuming the same as byte order!"
#define __FLOAT_WORD_ORDER __BYTE_ORDER
#endif


#if !defined(__BYTE_ORDER) || !defined(__FLOAT_WORD_ORDER)
#error "Undefined byte or float word order!"
#endif

#if __FLOAT_WORD_ORDER != __BIG_ENDIAN && __FLOAT_WORD_ORDER != __LITTLE_ENDIAN
#error "Unknown/unsupported float word order!"
#endif

#if __BYTE_ORDER != __BIG_ENDIAN && __BYTE_ORDER != __LITTLE_ENDIAN
#error "Unknown/unsupported byte order!"
#endif
#endif

amf.h

#include <stdint.h>
#ifndef TRUE
#define TRUE 1
#define FALSE 0
#endif


#ifdef __cplusplus
extern "C"
{
#endif

//AMF0的数据类型

typedef enum
  { AMF_NUMBER = 0, //double，占6个字节
    AMF_BOOLEAN, //bool型
    AMF_STRING, //字符串
    AMF_OBJECT,//AMF对象
    AMF_MOVIECLIP, /* reserved, not used */

    AMF_NULL,//空类型

     AMF_UNDEFINED,//未定义类型 

     AMF_REFERENCE, AMF_ECMA_ARRAY, 

    AMF_OBJECT_END,//标识嵌套结束

    AMF_STRICT_ARRAY, AMF_DATE, AMF_LONG_STRING, AMF_UNSUPPORTED,
    AMF_RECORDSET, /* reserved, not used */
    AMF_XML_DOC, AMF_TYPED_OBJECT,
    AMF_AVMPLUS, /* switch to AMF3 */
    AMF_INVALID = 0xff
  } AMFDataType;

//AMF3的数据类型
  typedef enum
  { AMF3_UNDEFINED = 0, AMF3_NULL, AMF3_FALSE, AMF3_TRUE,
    AMF3_INTEGER, AMF3_DOUBLE, AMF3_STRING, AMF3_XML_DOC, AMF3_DATE,
    AMF3_ARRAY, AMF3_OBJECT, AMF3_XML, AMF3_BYTE_ARRAY
  } AMF3DataType;

//定义一种AVal类型，封装过的字符串
  typedef struct AVal
  {
    char *av_val;
    int av_len;
  } AVal;

//定义获取Aval类型数据大小的宏
#define AVC(str) {str,sizeof(str)-1}

//比较两个Aval类型数据是否相等
#define AVMATCH(a1,a2) ((a1)->av_len == (a2)->av_len && !memcmp((a1)->av_val,(a2)->av_val,(a1)->av_len))


  struct AMFObjectProperty;

//定义AMF对象类型
  typedef struct AMFObject
  {
    int o_num;
    struct AMFObjectProperty *o_props;
  } AMFObject;


  typedef struct AMFObjectProperty
  {
    AVal p_name;//键名和长度
    AMFDataType p_type;//键值数据类型

//键值，有可能是number型，string型，嵌套对象类型
    union
    {
      double p_number;
      AVal p_aval;
      AMFObject p_object;
    } p_vu;
    int16_t p_UTCoffset;
  } AMFObjectProperty;


  char *AMF_EncodeString(char *output, char *outend, const AVal * str);
  char *AMF_EncodeNumber(char *output, char *outend, double dVal);
  char *AMF_EncodeInt16(char *output, char *outend, short nVal);
  char *AMF_EncodeInt24(char *output, char *outend, int nVal);
  char *AMF_EncodeInt32(char *output, char *outend, int nVal);
  char *AMF_EncodeBoolean(char *output, char *outend, int bVal);


  /* Shortcuts for AMFProp_Encode */
  char *AMF_EncodeNamedString(char *output, char *outend, const AVal * name, const AVal * value);
  char *AMF_EncodeNamedNumber(char *output, char *outend, const AVal * name, double dVal);
  char *AMF_EncodeNamedBoolean(char *output, char *outend, const AVal * name, int bVal);


  unsigned short AMF_DecodeInt16(const char *data);
  unsigned int AMF_DecodeInt24(const char *data);
  unsigned int AMF_DecodeInt32(const char *data);
  void AMF_DecodeString(const char *data, AVal * str);
  void AMF_DecodeLongString(const char *data, AVal * str);
  int AMF_DecodeBoolean(const char *data);
  double AMF_DecodeNumber(const char *data);


  char *AMF_Encode(AMFObject * obj, char *pBuffer, char *pBufEnd);
  char *AMF_EncodeEcmaArray(AMFObject *obj, char *pBuffer, char *pBufEnd);
  char *AMF_EncodeArray(AMFObject *obj, char *pBuffer, char *pBufEnd);


  int AMF_Decode(AMFObject * obj, const char *pBuffer, int nSize,
int bDecodeName);
  int AMF_DecodeArray(AMFObject * obj, const char *pBuffer, int nSize,
      int nArrayLen, int bDecodeName);
  int AMF3_Decode(AMFObject * obj, const char *pBuffer, int nSize,
  int bDecodeName);
  void AMF_Dump(AMFObject * obj);
  void AMF_Reset(AMFObject * obj);


  void AMF_AddProp(AMFObject * obj, const AMFObjectProperty * prop);
  int AMF_CountProp(AMFObject * obj);
  AMFObjectProperty *AMF_GetProp(AMFObject * obj, const AVal * name,
int nIndex);


  AMFDataType AMFProp_GetType(AMFObjectProperty * prop);
  void AMFProp_SetNumber(AMFObjectProperty * prop, double dval);
  void AMFProp_SetBoolean(AMFObjectProperty * prop, int bflag);
  void AMFProp_SetString(AMFObjectProperty * prop, AVal * str);
  void AMFProp_SetObject(AMFObjectProperty * prop, AMFObject * obj);


  void AMFProp_GetName(AMFObjectProperty * prop, AVal * name);
  void AMFProp_SetName(AMFObjectProperty * prop, AVal * name);
  double AMFProp_GetNumber(AMFObjectProperty * prop);
  int AMFProp_GetBoolean(AMFObjectProperty * prop);
  void AMFProp_GetString(AMFObjectProperty * prop, AVal * str);
  void AMFProp_GetObject(AMFObjectProperty * prop, AMFObject * obj);


  int AMFProp_IsValid(AMFObjectProperty * prop);


  char *AMFProp_Encode(AMFObjectProperty * prop, char *pBuffer, char *pBufEnd);
  int AMF3Prop_Decode(AMFObjectProperty * prop, const char *pBuffer,
      int nSize, int bDecodeName);
  int AMFProp_Decode(AMFObjectProperty * prop, const char *pBuffer,
     int nSize, int bDecodeName);


  void AMFProp_Dump(AMFObjectProperty * prop);
  void AMFProp_Reset(AMFObjectProperty * prop);


  typedef struct AMF3ClassDef
  {
    AVal cd_name;
    char cd_externalizable;
    char cd_dynamic;
    int cd_num;
    AVal *cd_props;
  } AMF3ClassDef;


  void AMF3CD_AddProp(AMF3ClassDef * cd, AVal * prop);
  AVal *AMF3CD_GetProp(AMF3ClassDef * cd, int idx);


#ifdef __cplusplus
}
#endif


#endif /* __AMF_H__ */

amf.c

#include <string.h>
#include <assert.h>
#include <stdlib.h>


#include "rtmp_sys.h"
#include "amf.h"
#include "log.h"
#include "bytes.h"


static const AMFObjectProperty AMFProp_Invalid = { {0, 0}, AMF_INVALID };
static const AMFObject AMFObj_Invalid = { 0, 0 };
static const AVal AV_empty = { 0, 0 };


/* Data is Big-Endian，把两个大端的1字节数据合成一个小端short型 */
unsigned short
AMF_DecodeInt16(const char *data)
{
  unsigned char *c = (unsigned char *) data;
  unsigned short val;
  val = (c[0] << 8) | c[1];
  return val;
}

//把三个1字节数据合成1个int型小端数据
unsigned int
AMF_DecodeInt24(const char *data)
{
  unsigned char *c = (unsigned char *) data;
  unsigned int val;
  val = (c[0] << 16) | (c[1] << 8) | c[2];
  return val;
}
//把四个1字节数据合成1个int型小段数据
unsigned int
AMF_DecodeInt32(const char *data)
{
  unsigned char *c = (unsigned char *)data;
  unsigned int val;
  val = (c[0] << 24) | (c[1] << 16) | (c[2] << 8) | c[3];
  return val;
}

//data中前两个字节为字符串长度，提取出字符串长度，再加两字节偏移即为数据部分
void
AMF_DecodeString(const char *data, AVal *bv)
{
  bv->av_len = AMF_DecodeInt16(data);
  bv->av_val = (bv->av_len > 0) ? (char *)data + 2 : NULL;
}

//同上，只不过data中前4个字节为字符串长度
void
AMF_DecodeLongString(const char *data, AVal *bv)
{
  bv->av_len = AMF_DecodeInt32(data);
  bv->av_val = (bv->av_len > 0) ? (char *)data + 4 : NULL;
}

//解析number型数据，这里的转换我还不清楚
double
AMF_DecodeNumber(const char *data)
{
  double dVal;
#if __FLOAT_WORD_ORDER == __BYTE_ORDER
#if __BYTE_ORDER == __BIG_ENDIAN
  memcpy(&dVal, data, 8);

//如果是小端
#elif __BYTE_ORDER == __LITTLE_ENDIAN
  unsigned char *ci, *co;
  ci = (unsigned char *)data;
  co = (unsigned char *)&dVal;
  co[0] = ci[7];
  co[1] = ci[6];
  co[2] = ci[5];
  co[3] = ci[4];
  co[4] = ci[3];
  co[5] = ci[2];
  co[6] = ci[1];
  co[7] = ci[0];
#endif
#else
#if __BYTE_ORDER == __LITTLE_ENDIAN /* __FLOAT_WORD_ORER == __BIG_ENDIAN */
  unsigned char *ci, *co;
  ci = (unsigned char *)data;
  co = (unsigned char *)&dVal;
  co[0] = ci[3];
  co[1] = ci[2];
  co[2] = ci[1];
  co[3] = ci[0];
  co[4] = ci[7];
  co[5] = ci[6];
  co[6] = ci[5];
  co[7] = ci[4];
#else /* __BYTE_ORDER == __BIG_ENDIAN && __FLOAT_WORD_ORER == __LITTLE_ENDIAN */
  unsigned char *ci, *co;
  ci = (unsigned char *)data;
  co = (unsigned char *)&dVal;
  co[0] = ci[4];
  co[1] = ci[5];
  co[2] = ci[6];
  co[3] = ci[7];
  co[4] = ci[0];
  co[5] = ci[1];
  co[6] = ci[2];
  co[7] = ci[3];
#endif
#endif
  return dVal;
}

//解析bool型数据，0x00表示false 0x01表示true
int
AMF_DecodeBoolean(const char *data)
{
  return *data != 0;
}

//
char *
AMF_EncodeInt16(char *output, char *outend, short nVal)
{
  if (output+2 > outend)
    return NULL;


  output[1] = nVal & 0xff;
  output[0] = nVal >> 8;
  return output+2;
}

//
char *
AMF_EncodeInt24(char *output, char *outend, int nVal)
{
  if (output+3 > outend)
    return NULL;


  output[2] = nVal & 0xff;
  output[1] = nVal >> 8;
  output[0] = nVal >> 16;
  return output+3;
}


char *
AMF_EncodeInt32(char *output, char *outend, int nVal)
{
  if (output+4 > outend)
    return NULL;


  output[3] = nVal & 0xff;
  output[2] = nVal >> 8;
  output[1] = nVal >> 16;
  output[0] = nVal >> 24;
  return output+4;
}


char *
AMF_EncodeString(char *output, char *outend, const AVal *bv)
{
  if ((bv->av_len < 65536 && output + 1 + 2 + bv->av_len > outend) ||
output + 1 + 4 + bv->av_len > outend)
    return NULL;


  if (bv->av_len < 65536)
    {
      *output++ = AMF_STRING;


      output = AMF_EncodeInt16(output, outend, bv->av_len);
    }
  else
    {
      *output++ = AMF_LONG_STRING;


      output = AMF_EncodeInt32(output, outend, bv->av_len);
    }
  memcpy(output, bv->av_val, bv->av_len);
  output += bv->av_len;


  return output;
}


char *
AMF_EncodeNumber(char *output, char *outend, double dVal)
{
  if (output+1+8 > outend)
    return NULL;


  *output++ = AMF_NUMBER; /* type: Number */


#if __FLOAT_WORD_ORDER == __BYTE_ORDER
#if __BYTE_ORDER == __BIG_ENDIAN
  memcpy(output, &dVal, 8);
#elif __BYTE_ORDER == __LITTLE_ENDIAN
  {
    unsigned char *ci, *co;
    ci = (unsigned char *)&dVal;
    co = (unsigned char *)output;
    co[0] = ci[7];
    co[1] = ci[6];
    co[2] = ci[5];
    co[3] = ci[4];
    co[4] = ci[3];
    co[5] = ci[2];
    co[6] = ci[1];
    co[7] = ci[0];
  }
#endif
#else
#if __BYTE_ORDER == __LITTLE_ENDIAN /* __FLOAT_WORD_ORER == __BIG_ENDIAN */
  {
    unsigned char *ci, *co;
    ci = (unsigned char *)&dVal;
    co = (unsigned char *)output;
    co[0] = ci[3];
    co[1] = ci[2];
    co[2] = ci[1];
    co[3] = ci[0];
    co[4] = ci[7];
    co[5] = ci[6];
    co[6] = ci[5];
    co[7] = ci[4];
  }
#else /* __BYTE_ORDER == __BIG_ENDIAN && __FLOAT_WORD_ORER == __LITTLE_ENDIAN */
  {
    unsigned char *ci, *co;
    ci = (unsigned char *)&dVal;
    co = (unsigned char *)output;
    co[0] = ci[4];
    co[1] = ci[5];
    co[2] = ci[6];
    co[3] = ci[7];
    co[4] = ci[0];
    co[5] = ci[1];
    co[6] = ci[2];
    co[7] = ci[3];
  }
#endif
#endif


  return output+8;
}


char *
AMF_EncodeBoolean(char *output, char *outend, int bVal)
{
  if (output+2 > outend)
    return NULL;


  *output++ = AMF_BOOLEAN;


  *output++ = bVal ? 0x01 : 0x00;


  return output;
}


char *
AMF_EncodeNamedString(char *output, char *outend, const AVal *strName, const AVal *strValue)
{
  if (output+2+strName->av_len > outend)
    return NULL;
  output = AMF_EncodeInt16(output, outend, strName->av_len);


  memcpy(output, strName->av_val, strName->av_len);
  output += strName->av_len;


  return AMF_EncodeString(output, outend, strValue);
}


char *
AMF_EncodeNamedNumber(char *output, char *outend, const AVal *strName, double dVal)
{
  if (output+2+strName->av_len > outend)
    return NULL;
  output = AMF_EncodeInt16(output, outend, strName->av_len);


  memcpy(output, strName->av_val, strName->av_len);
  output += strName->av_len;


  return AMF_EncodeNumber(output, outend, dVal);
}


char *
AMF_EncodeNamedBoolean(char *output, char *outend, const AVal *strName, int bVal)
{
  if (output+2+strName->av_len > outend)
    return NULL;
  output = AMF_EncodeInt16(output, outend, strName->av_len);


  memcpy(output, strName->av_val, strName->av_len);
  output += strName->av_len;


  return AMF_EncodeBoolean(output, outend, bVal);
}


void
AMFProp_GetName(AMFObjectProperty *prop, AVal *name)
{
  *name = prop->p_name;
}


void
AMFProp_SetName(AMFObjectProperty *prop, AVal *name)
{
  prop->p_name = *name;
}


AMFDataType
AMFProp_GetType(AMFObjectProperty *prop)
{
  return prop->p_type;
}


double
AMFProp_GetNumber(AMFObjectProperty *prop)
{
  return prop->p_vu.p_number;
}


int
AMFProp_GetBoolean(AMFObjectProperty *prop)
{
  return prop->p_vu.p_number != 0;
}


void
AMFProp_GetString(AMFObjectProperty *prop, AVal *str)
{
  if (prop->p_type == AMF_STRING)
    *str = prop->p_vu.p_aval;
  else
    *str = AV_empty;
}


void
AMFProp_GetObject(AMFObjectProperty *prop, AMFObject *obj)
{
  if (prop->p_type == AMF_OBJECT)
    *obj = prop->p_vu.p_object;
  else
    *obj = AMFObj_Invalid;
}


int
AMFProp_IsValid(AMFObjectProperty *prop)
{
  return prop->p_type != AMF_INVALID;
}


char *
AMFProp_Encode(AMFObjectProperty *prop, char *pBuffer, char *pBufEnd)
{
  if (prop->p_type == AMF_INVALID)
    return NULL;


  if (prop->p_type != AMF_NULL && pBuffer + prop->p_name.av_len + 2 + 1 >= pBufEnd)
    return NULL;


  if (prop->p_type != AMF_NULL && prop->p_name.av_len)
    {
      *pBuffer++ = prop->p_name.av_len >> 8;
      *pBuffer++ = prop->p_name.av_len & 0xff;
      memcpy(pBuffer, prop->p_name.av_val, prop->p_name.av_len);
      pBuffer += prop->p_name.av_len;
    }


  switch (prop->p_type)
    {
    case AMF_NUMBER:
      pBuffer = AMF_EncodeNumber(pBuffer, pBufEnd, prop->p_vu.p_number);
      break;


    case AMF_BOOLEAN:
      pBuffer = AMF_EncodeBoolean(pBuffer, pBufEnd, prop->p_vu.p_number != 0);
      break;


    case AMF_STRING:
      pBuffer = AMF_EncodeString(pBuffer, pBufEnd, &prop->p_vu.p_aval);
      break;


    case AMF_NULL:
      if (pBuffer+1 >= pBufEnd)
        return NULL;
      *pBuffer++ = AMF_NULL;
      break;


    case AMF_OBJECT:
      pBuffer = AMF_Encode(&prop->p_vu.p_object, pBuffer, pBufEnd);
      break;


    case AMF_ECMA_ARRAY:
      pBuffer = AMF_EncodeEcmaArray(&prop->p_vu.p_object, pBuffer, pBufEnd);
      break;


    case AMF_STRICT_ARRAY:
      pBuffer = AMF_EncodeArray(&prop->p_vu.p_object, pBuffer, pBufEnd);
      break;


    default:
      RTMP_Log(RTMP_LOGERROR, "%s, invalid type. %d", __FUNCTION__, prop->p_type);
      pBuffer = NULL;
    };


  return pBuffer;
}


int
AMFProp_Decode(AMFObjectProperty *prop, const char *pBuffer, int nSize,
       int bDecodeName)
{
  int nOriginalSize = nSize;
  int nRes;


  prop->p_name.av_len = 0;
  prop->p_name.av_val = NULL;


  if (nSize == 0 || !pBuffer)
    {
      RTMP_Log(RTMP_LOGDEBUG, "%s: Empty buffer/no buffer pointer!", __FUNCTION__);
      return -1;
    }


  if (bDecodeName && nSize < 4)
    { /* at least name (length + at least 1 byte) and 1 byte of data */
      RTMP_Log(RTMP_LOGDEBUG,
  "%s: Not enough data for decoding with name, less than 4 bytes!",
  __FUNCTION__);
      return -1;
    }


  if (bDecodeName)
    {
      unsigned short nNameSize = AMF_DecodeInt16(pBuffer);
      if (nNameSize > nSize - 2)
{
  RTMP_Log(RTMP_LOGDEBUG,
      "%s: Name size out of range: namesize (%d) > len (%d) - 2",
      __FUNCTION__, nNameSize, nSize);
  return -1;
}


      AMF_DecodeString(pBuffer, &prop->p_name);
      nSize -= 2 + nNameSize;
      pBuffer += 2 + nNameSize;
    }


  if (nSize == 0)
    {
      return -1;
    }


  nSize--;


  prop->p_type = *pBuffer++;
  switch (prop->p_type)
    {
    case AMF_NUMBER:
      if (nSize < 8)
return -1;
      prop->p_vu.p_number = AMF_DecodeNumber(pBuffer);
      nSize -= 8;
      break;
    case AMF_BOOLEAN:
      if (nSize < 1)
return -1;
      prop->p_vu.p_number = (double)AMF_DecodeBoolean(pBuffer);
      nSize--;
      break;
    case AMF_STRING:
      {
unsigned short nStringSize = AMF_DecodeInt16(pBuffer);


if (nSize < (long)nStringSize + 2)
  return -1;
AMF_DecodeString(pBuffer, &prop->p_vu.p_aval);
nSize -= (2 + nStringSize);
break;
      }
    case AMF_OBJECT:
      {
int nRes = AMF_Decode(&prop->p_vu.p_object, pBuffer, nSize, TRUE);
if (nRes == -1)
  return -1;
nSize -= nRes;
break;
      }
    case AMF_MOVIECLIP:
      {
RTMP_Log(RTMP_LOGERROR, "AMF_MOVIECLIP reserved!");
return -1;
break;
      }
    case AMF_NULL:
    case AMF_UNDEFINED:
    case AMF_UNSUPPORTED:
      prop->p_type = AMF_NULL;
      break;
    case AMF_REFERENCE:
      {
RTMP_Log(RTMP_LOGERROR, "AMF_REFERENCE not supported!");
return -1;
break;
      }
    case AMF_ECMA_ARRAY:
      {
nSize -= 4;


/* next comes the rest, mixed array has a final 0x000009 mark and names, so its an object */
nRes = AMF_Decode(&prop->p_vu.p_object, pBuffer + 4, nSize, TRUE);
if (nRes == -1)
  return -1;
nSize -= nRes;
break;
      }
    case AMF_OBJECT_END:
      {
return -1;
break;
      }
    case AMF_STRICT_ARRAY:
      {
unsigned int nArrayLen = AMF_DecodeInt32(pBuffer);
nSize -= 4;


nRes = AMF_DecodeArray(&prop->p_vu.p_object, pBuffer + 4, nSize,
   nArrayLen, FALSE);
if (nRes == -1)
  return -1;
nSize -= nRes;
break;
      }
    case AMF_DATE:
      {
RTMP_Log(RTMP_LOGDEBUG, "AMF_DATE");


if (nSize < 10)
  return -1;


prop->p_vu.p_number = AMF_DecodeNumber(pBuffer);
prop->p_UTCoffset = AMF_DecodeInt16(pBuffer + 8);


nSize -= 10;
break;
      }
    case AMF_LONG_STRING:
    case AMF_XML_DOC:
      {
unsigned int nStringSize = AMF_DecodeInt32(pBuffer);
if (nSize < (long)nStringSize + 4)
  return -1;
AMF_DecodeLongString(pBuffer, &prop->p_vu.p_aval);
nSize -= (4 + nStringSize);
if (prop->p_type == AMF_LONG_STRING)
  prop->p_type = AMF_STRING;
break;
      }
    case AMF_RECORDSET:
      {
RTMP_Log(RTMP_LOGERROR, "AMF_RECORDSET reserved!");
return -1;
break;
      }
    case AMF_TYPED_OBJECT:
      {
RTMP_Log(RTMP_LOGERROR, "AMF_TYPED_OBJECT not supported!");
return -1;
break;
      }
    case AMF_AVMPLUS:
      {
int nRes = AMF3_Decode(&prop->p_vu.p_object, pBuffer, nSize, TRUE);
if (nRes == -1)
  return -1;
nSize -= nRes;
prop->p_type = AMF_OBJECT;
break;
      }
    default:
      RTMP_Log(RTMP_LOGDEBUG, "%s - unknown datatype 0x%02x, @%p", __FUNCTION__,
  prop->p_type, pBuffer - 1);
      return -1;
    }


  return nOriginalSize - nSize;
}


void
AMFProp_Dump(AMFObjectProperty *prop)
{
  char strRes[256];
  char str[256];
  AVal name;


  if (prop->p_type == AMF_INVALID)
    {
      RTMP_Log(RTMP_LOGDEBUG, "Property: INVALID");
      return;
    }


  if (prop->p_type == AMF_NULL)
    {
      RTMP_Log(RTMP_LOGDEBUG, "Property: NULL");
      return;
    }


  if (prop->p_name.av_len)
    {
      name = prop->p_name;
    }
  else
    {
      name.av_val = "no-name.";
      name.av_len = sizeof("no-name.") - 1;
    }
  if (name.av_len > 18)
    name.av_len = 18;


  snprintf(strRes, 255, "Name: %18.*s, ", name.av_len, name.av_val);


  if (prop->p_type == AMF_OBJECT)
    {
      RTMP_Log(RTMP_LOGDEBUG, "Property: <%sOBJECT>", strRes);
      AMF_Dump(&prop->p_vu.p_object);
      return;
    }
  else if (prop->p_type == AMF_ECMA_ARRAY)
    {
      RTMP_Log(RTMP_LOGDEBUG, "Property: <%sECMA_ARRAY>", strRes);
      AMF_Dump(&prop->p_vu.p_object);
      return;
    }
  else if (prop->p_type == AMF_STRICT_ARRAY)
    {
      RTMP_Log(RTMP_LOGDEBUG, "Property: <%sSTRICT_ARRAY>", strRes);
      AMF_Dump(&prop->p_vu.p_object);
      return;
    }


  switch (prop->p_type)
    {
    case AMF_NUMBER:
      snprintf(str, 255, "NUMBER:\t%.2f", prop->p_vu.p_number);
      break;
    case AMF_BOOLEAN:
      snprintf(str, 255, "BOOLEAN:\t%s",
       prop->p_vu.p_number != 0.0 ? "TRUE" : "FALSE");
      break;
    case AMF_STRING:
      snprintf(str, 255, "STRING:\t%.*s", prop->p_vu.p_aval.av_len,
       prop->p_vu.p_aval.av_val);
      break;
    case AMF_DATE:
      snprintf(str, 255, "DATE:\ttimestamp: %.2f, UTC offset: %d",
       prop->p_vu.p_number, prop->p_UTCoffset);
      break;
    default:
      snprintf(str, 255, "INVALID TYPE 0x%02x", (unsigned char)prop->p_type);
    }


  RTMP_Log(RTMP_LOGDEBUG, "Property: <%s%s>", strRes, str);
}


void
AMFProp_Reset(AMFObjectProperty *prop)
{
  if (prop->p_type == AMF_OBJECT || prop->p_type == AMF_ECMA_ARRAY ||
      prop->p_type == AMF_STRICT_ARRAY)
    AMF_Reset(&prop->p_vu.p_object);
  else
    {
      prop->p_vu.p_aval.av_len = 0;
      prop->p_vu.p_aval.av_val = NULL;
    }
  prop->p_type = AMF_INVALID;
}


/* AMFObject */


char *
AMF_Encode(AMFObject *obj, char *pBuffer, char *pBufEnd)
{
  int i;


  if (pBuffer+4 >= pBufEnd)
    return NULL;


  *pBuffer++ = AMF_OBJECT;


  for (i = 0; i < obj->o_num; i++)
    {
      char *res = AMFProp_Encode(&obj->o_props[i], pBuffer, pBufEnd);
      if (res == NULL)
{
  RTMP_Log(RTMP_LOGERROR, "AMF_Encode - failed to encode property in index %d",
      i);
  break;
}
      else
{
  pBuffer = res;
}
    }


  if (pBuffer + 3 >= pBufEnd)
    return NULL; /* no room for the end marker */


  pBuffer = AMF_EncodeInt24(pBuffer, pBufEnd, AMF_OBJECT_END);


  return pBuffer;
}


char *
AMF_EncodeEcmaArray(AMFObject *obj, char *pBuffer, char *pBufEnd)
{
  int i;


  if (pBuffer+4 >= pBufEnd)
    return NULL;


  *pBuffer++ = AMF_ECMA_ARRAY;


  pBuffer = AMF_EncodeInt32(pBuffer, pBufEnd, obj->o_num);


  for (i = 0; i < obj->o_num; i++)
    {
      char *res = AMFProp_Encode(&obj->o_props[i], pBuffer, pBufEnd);
      if (res == NULL)
{
  RTMP_Log(RTMP_LOGERROR, "AMF_Encode - failed to encode property in index %d",
      i);
  break;
}
      else
{
  pBuffer = res;
}
    }


  if (pBuffer + 3 >= pBufEnd)
    return NULL; /* no room for the end marker */


  pBuffer = AMF_EncodeInt24(pBuffer, pBufEnd, AMF_OBJECT_END);


  return pBuffer;
}


char *
AMF_EncodeArray(AMFObject *obj, char *pBuffer, char *pBufEnd)
{
  int i;


  if (pBuffer+4 >= pBufEnd)
    return NULL;


  *pBuffer++ = AMF_STRICT_ARRAY;


  pBuffer = AMF_EncodeInt32(pBuffer, pBufEnd, obj->o_num);


  for (i = 0; i < obj->o_num; i++)
    {
      char *res = AMFProp_Encode(&obj->o_props[i], pBuffer, pBufEnd);
      if (res == NULL)
{
  RTMP_Log(RTMP_LOGERROR, "AMF_Encode - failed to encode property in index %d",
      i);
  break;
}
      else
{
  pBuffer = res;
}
    }


  //if (pBuffer + 3 >= pBufEnd)
  //  return NULL; /* no room for the end marker */


  //pBuffer = AMF_EncodeInt24(pBuffer, pBufEnd, AMF_OBJECT_END);


  return pBuffer;
}


int
AMF_DecodeArray(AMFObject *obj, const char *pBuffer, int nSize,
int nArrayLen, int bDecodeName)
{
  int nOriginalSize = nSize;
  int bError = FALSE;


  obj->o_num = 0;
  obj->o_props = NULL;
  while (nArrayLen > 0)
    {
      AMFObjectProperty prop;
      int nRes;
      nArrayLen--;


      if (nSize <= 0)
{
  bError = TRUE;
  break;
}
      nRes = AMFProp_Decode(&prop, pBuffer, nSize, bDecodeName);
      if (nRes == -1)
{
  bError = TRUE;
  break;
}
      else
{
  nSize -= nRes;
  pBuffer += nRes;
  AMF_AddProp(obj, &prop);
}
    }
  if (bError)
    return -1;


  return nOriginalSize - nSize;
}



int
AMF_Decode(AMFObject *obj, const char *pBuffer, int nSize, int bDecodeName)
{
  int nOriginalSize = nSize;
  int bError = FALSE; /* if there is an error while decoding - try to at least find the end mark AMF_OBJECT_END */


  obj->o_num = 0;
  obj->o_props = NULL;
  while (nSize > 0)
    {
      AMFObjectProperty prop;
      int nRes;


      if (nSize >=3 && AMF_DecodeInt24(pBuffer) == AMF_OBJECT_END)
{
  nSize -= 3;
  bError = FALSE;
  break;
}


      if (bError)
{
  RTMP_Log(RTMP_LOGERROR,
      "DECODING ERROR, IGNORING BYTES UNTIL NEXT KNOWN PATTERN!");
  nSize--;
  pBuffer++;
  continue;
}


      nRes = AMFProp_Decode(&prop, pBuffer, nSize, bDecodeName);
      if (nRes == -1)
{
  bError = TRUE;
  break;
}
      else
{
  nSize -= nRes;
  if (nSize < 0)
    {
      bError = TRUE;
      break;
    }
  pBuffer += nRes;
  AMF_AddProp(obj, &prop);
}
    }
  if (bError)
    return -1;
  return nOriginalSize - nSize;
}

//添加属性，这里做了优化，每满15个再添加时，一次性分配16个属性空间
void
AMF_AddProp(AMFObject *obj, const AMFObjectProperty *prop)
{
  if (!(obj->o_num & 0x0f))
    obj->o_props =
      realloc(obj->o_props, (obj->o_num + 16) * sizeof(AMFObjectProperty));
  memcpy(&obj->o_props[obj->o_num++], prop, sizeof(AMFObjectProperty));
}

//计算AMF对象属性个数
int
AMF_CountProp(AMFObject *obj)
{
  return obj->o_num;
}

//获取AMF对象第nIndex个属性，如果nIndex非法，则返回含有name键的所有属性
AMFObjectProperty *
AMF_GetProp(AMFObject *obj, const AVal *name, int nIndex)
{
  if (nIndex >= 0)
    {
      if (nIndex < obj->o_num)
return &obj->o_props[nIndex];
    }
  else
    {
      int n;
      for (n = 0; n < obj->o_num; n++)
{
  if (AVMATCH(&obj->o_props[n].p_name, name))
    return &obj->o_props[n];
}
    }
  return (AMFObjectProperty *)&AMFProp_Invalid;
}

//打印AMF对象
void
AMF_Dump(AMFObject *obj)
{
  int n;
  RTMP_Log(RTMP_LOGDEBUG, "(object begin)");
  for (n = 0; n < obj->o_num; n++)
    {
      AMFProp_Dump(&obj->o_props[n]);
    }
  RTMP_Log(RTMP_LOGDEBUG, "(object end)");
}


//复位对象
void
AMF_Reset(AMFObject *obj)
{
  int n;
  for (n = 0; n < obj->o_num; n++)
    {
      AMFProp_Reset(&obj->o_props[n]);
    }
  free(obj->o_props);
  obj->o_props = NULL;
  obj->o_num = 0;
}