OpenRTMFP/Cumulus Primer（16）AMF解析之AMFReader

• Author: 柳大·Poechant（钟超）
• Email: zhongchao.ustc#gmail.com (#->@)
• Blog:Blog.CSDN.net/Poechant
• Date: April 24^th, 2012

1 ObjectDef

class ObjectDef {
public: 
    ObjectDef(UInt32 amf3,UInt8 arrayType=0)
        : amf3(amf3),
          reset(0),
          dynamic(false),
          externalizable(false),
          count(0),
          arrayType(arrayType) {
    }

    list<string>    hardProperties;
    UInt32          reset;
    bool            dynamic;
    bool            externalizable;
    UInt32          count;
    UInt8           arrayType;
    const UInt32    amf3;
};

2 AMFReader 定义

其中 PacketReader 作为其成员。

class AMFReader {
public:
    AMFReader(PacketReader& reader);
    ~AMFReader();

    void            readSimpleObject(AMFSimpleObject& object);

    void            read(std::string& value);
    double          readNumber();
    Poco::Int32     readInteger();
    bool            readBoolean();
    BinaryReader&   readByteArray(Poco::UInt32& size);
    Poco::Timestamp readDate();

    bool            readObject(std::string& type);
    bool            readArray();
    bool            readDictionary(bool& weakKeys);
    AMF::Type       readKey();
    AMF::Type       readValue();
    AMF::Type       readItem(std::string& name);
    BinaryReader&   readRawObjectContent();

    void            readNull();
    AMF::Type       followingType();

    bool            available();

    void            startReferencing();
    void            stopReferencing();

    PacketReader&   reader;

private:
    void                            readString(std::string& value);
    Poco::UInt8                     current();
    void                            reset();
    std::list<ObjectDef*>           _objectDefs;
    std::vector<Poco::UInt32>       _stringReferences;
    std::vector<Poco::UInt32>       _classDefReferences;
    std::vector<Poco::UInt32>       _references;
    std::vector<Poco::UInt32>       _amf0References;
    Poco::UInt32                    _amf0Reset;
    Poco::UInt32                    _reset;
    Poco::UInt32                    _amf3;
    bool                            _referencing;
};

2.1 构造函数、析构函数

参数为 PacketReader，会初始化一些成员变量。

AMFReader::AMFReader(PacketReader& reader)
    : reader(reader),
      _reset(0),
      _amf3(0),
      _amf0Reset(0),
      _referencing(true) {
}

析构时，会逐一释放 _objectDefs 中对象的内存：

AMFReader::~AMFReader() {
    list<ObjectDef*>::iterator it;
    for (it = _objectDefs.begin(); it!=_objectDefs.end(); ++it)
        delete *it;
}

2.2 简单封装 PacketReader 的一些函数

• reset：操作指针位置

    void AMFReader::reset() {
        if (_reset > 0) {
            reader.reset(_reset);
            _reset = 0;
        }
    }
  

• available：根据当前缓冲区大小和 written 计算得到

    bool AMFReader::available() {
        reset();
        return reader.available() > 0;
    }
  

• current：gptr 内存地址

    inline Poco::UInt8 AMFReader::current() {
        return *reader.current();
    }
  

2.3 设置 gptr 位置

其实 pptr 也被影响了，但是在 AMFReader 中只用 gptr。调用构造函数的时候，reset 被设为 0，其后在每次读取数据的时候都会影响reset。

void AMFReader::reset() {
    if(_reset>0) {
        reader.reset(_reset);
        _reset=0;
    }
}

2.4 判断类型

分析请看注释：

AMF::Type AMFReader::followingType() {

先 reset：

    reset();

    if (_amf3 != reader.position()) {
        if (_objectDefs.size() > 0)
            _amf3 = _objectDefs.back()->amf3;

是 AMF0 类型：

        else
            _amf3 = 0;
    }

如果没有可读数据了，则返回 AMF::End。

    if (!available())
        return AMF::End;

开始读了，先读到的表示 AMF 数据类型。要注意的是调用 current 并不改变指针的位置，所以你会在线面看到调用 next。

    UInt8 type = current();

    if (!_amf3 && type == AMF_AVMPLUS_OBJECT) {
        reader.next(1);
        _amf3 = reader.position();
        if(!available())
            return AMF::End;
        type = current();
    }

AMF3 类型

    if (_amf3) {
        switch(type) {

Undefined 和 null 都当做 null。

            case AMF3_UNDEFINED:
            case AMF3_NULL:
                return AMF::Null;

false 和 true 都是 boolean。

            case AMF3_FALSE:
            case AMF3_TRUE:
                return AMF::Boolean;
            case AMF3_INTEGER:
                return AMF::Integer;
            case AMF3_NUMBER:
                return AMF::Number;
            case AMF3_STRING:
                return AMF::String;
            case AMF3_DATE:
                return AMF::Date;
            case AMF3_ARRAY:
                return AMF::Array;
            case AMF3_DICTIONARY:
                return AMF::Dictionary;
            case AMF3_OBJECT:
                return AMF::Object;
            case AMF3_BYTEARRAY:
                return AMF::ByteArray;

落到 default 手里的话，就跳过这个字节，读取下一个。

            default:
                ERROR("Unknown AMF3 type %.2x",type)
                reader.next(1);
                return followingType();
        }
    }

AMF0 类型

    switch (type) {

undefined 和 null 都是 null

        case AMF_UNDEFINED:
        case AMF_NULL:
            return AMF::Null;

        case AMF_BOOLEAN:
            return AMF::Boolean;
        case AMF_NUMBER:
            return AMF::Number;

long string 和 string 都是 string

        case AMF_LONG_STRING:
        case AMF_STRING:
            return AMF::String;

mixed array 和 strict array 都是 array

        case AMF_MIXED_ARRAY:
        case AMF_STRICT_ARRAY:
            return AMF::Array;

        case AMF_DATE:
            return AMF::Date;

begin object 和 begin typed object 都是 object

        case AMF_BEGIN_OBJECT:
        case AMF_BEGIN_TYPED_OBJECT:
            return AMF::Object;

如果是引用，就跳过表示类型值的这个字节。这个先留下来，带我们分析完 readArray 和 readObject 再回头看。

        case AMF_REFERENCE: {
            reader.next(1);
            UInt16 reference = reader.read16();
            if (reference > _amf0References.size()) {
                ERROR("AMF0 reference not found")
                return followingType();
            }
            _amf0Reset = reader.position();
            reader.reset(_amf0References[reference]);
            return followingType();
        }

如果没了，或者不支持，或者都不是，就跳过这个字节，递归继续读取：

        case AMF_END_OBJECT:
            ERROR("AMF end object type without begin object type before")
            reader.next(1);
            return followingType();
        case AMF_UNSUPPORTED:
            WARN("Unsupported type in AMF format")
            reader.next(1);
            return followingType();
        default:
            ERROR("Unknown AMF type %.2x",type)
            reader.next(1);
            return followingType();
    }
}

followingType 是这个类的核心，每个具体的数据类型的分析都依赖于它的判断。这些类型的解析，会在下一篇文章中介绍。

-

转载请注明来自柳大的CSDN博客：Blog.CSDN.net/Poechant

-