Nginx-rtmp之 AMF0 的处理

最新推荐文章于 2021-06-14 17:28:12 发布
最新推荐文章于 2021-06-14 17:28:12 发布
阅读量436 收藏 1
点赞数
文章标签： 运维 数据结构与算法
原文链接：http://www.cnblogs.com/jimodetiantang/p/8975945.html
版权

1. 综述

当检测到接收到的 RTMP 消息中 Message Header 中 message type id 为 20 时，表示，接收到的是 AMF 类型的数据，
因此需要对接收的数据进行 AMF 解析。

#define NGX_RTMP_MSG_AMF_META           18
#define NGX_RTMP_MSG_AMF_SHARED         19
#define NGX_RTMP_MSG_AMF_CMD            20

amf 的基本类型如下：

#define NGX_RTMP_AMF_NUMBER             0x00
#define NGX_RTMP_AMF_BOOLEAN            0x01
#define NGX_RTMP_AMF_STRING             0x02
#define NGX_RTMP_AMF_OBJECT             0x03
#define NGX_RTMP_AMF_NULL               0x05
#define NGX_RTMP_AMF_ARRAY_NULL         0x06
#define NGX_RTMP_AMF_MIXED_ARRAY        0x08
#define NGX_RTMP_AMF_END                0x09
#define NGX_RTMP_AMF_ARRAY              0x0a

支持的扩展类型：

#define NGX_RTMP_AMF_INT8               0x0100
#define NGX_RTMP_AMF_INT16              0x0101
#define NGX_RTMP_AMF_INT32              0x0102
#define NGX_RTMP_AMF_VARIANT_           0x0103

1.1 抓包分析

一段 amf 数据的抓包图：

1382048-20180501115452215-146875511.png
可见，amf 数据的都是 "类型 + [长度] + 值" 的形式。

注意：抓包显示的都为大端形式.

  1. String 类型，即 0x02，1 个 byte 的 amf type，2 个 bytes 的字符长度，和 N 个 bytes 的数据。
    如下：02 00 07 63 6f 6e 6e 63 74. 第 1 个 byte 是 amf 类型，其后 2 个 bytes 是长度，63 6f 6e 6e 63 74
    是字符数据 "connect"。
    1382048-20180501122646130-337940137.png

  2. Number 类型(其实就是 Double)，即 0x00，一个 byte 的 amf type，8 个 bytes 的值。
    如下：00 3f f0 00 00 00 00 00 00。第 1 个 byte 是 amf 类型，其后 8 个 bytes 是值：1
    image

  3. Object 类型，即 0x03，第一个 byte 0x03 表示 object，其后跟 N 个 (key + value)。最后以 00 00 09
    表示 object 结束。
    image

2. 源码分析

2.1 用到的结构体

2.1.1 ngx_rtmp_amf_ctx_t

typedef ngx_chain_t * (*ngx_rtmp_amf_alloc_pt)(void *arg);


typedef struct {
    /* link 指向保存着接收到的数据的 ngx_chain_t 类型的结构体 in 首地址 */
    ngx_chain_t                        *link, *first;
    /* 数据的偏移值 */
    size_t                              offset;
    ngx_rtmp_amf_alloc_pt               alloc;
    void                               *arg;
    ngx_log_t                          *log;
} ngx_rtmp_amf_ctx_t;

2.1.2 ngx_rtmp_amf_elt_t: 从 amf 数据中读取数据保存到该结构体的相应成员中

typedef struct {
    /* 指定要获取的 amf 数据类型 */
    ngx_int_t                           type;
    /* 指定获取的 amf 名称 */
    ngx_str_t                           name;
    /* 将获取到的数据保存到该指针指向的内存中 */
    void                               *data;
    /* data 指向的内存的容量 */
    size_t                              len;
} ngx_rtmp_amf_elt_t;

接收或发送给客户端的 AMF 数据都是以该结构体的形式组织的。

2.2 ngx_rtmp_amf_read：解析 amf 数据

ngx_int_t ngx_rtmp_amf_read(ngx_rtmp_amf_ctx_t *ctx, ngx_rtmp_amf_elt_t *elts,
        size_t nelts)
{
    void                       *data;
    ngx_int_t                   type;
    uint8_t                     type8;
    size_t                      n;
    uint16_t                    len;
    ngx_int_t                   rc;
    u_char                      buf[8];
    uint32_t                    max_index;

    for(n = 0; n < nelts; ++n) {

        /* 一般 amf 命令名通常伴随着字符串类型，但是 shared object 名是没有类型的 */
        if (elts && elts->type & NGX_RTMP_AMF_TYPELESS) {
            type = elts->type & ~NGX_RTMP_AMF_TYPELESS;
            data = elts->data;

        } else {
            /* 读取 1 个字节的数据到 type8 中 */
            switch (ngx_rtmp_amf_get(ctx, &type8, 1)) {
                case NGX_DONE:
                    if (elts->type & NGX_RTMP_AMF_OPTIONAL) {
                        return NGX_OK;
                    }
                    /* fall through */
                case NGX_ERROR:
                    return NGX_ERROR;
            }
            type = type8;
            data = (elts &&
                    /* 检测 elts->type 的类型 与 读取出的类型 type 是否相同，是则 
                     * data 指向 elts->data，否则为 NULL */
                    ngx_rtmp_amf_is_compatible_type(
                                 (uint8_t) (elts->type & 0xff), (uint8_t) type))
                ? elts->data
                : NULL;

            if (elts && (elts->type & NGX_RTMP_AMF_CONTEXT)) {
                if (data) {
                    *(ngx_rtmp_amf_ctx_t *) data = *ctx;
                }
                data = NULL;
            }
        }
    
        /* 根据类型 type 取出对应的数据 */
        switch (type) {
            case NGX_RTMP_AMF_NUMBER:
                if (ngx_rtmp_amf_get(ctx, buf, 8) != NGX_OK) {
                    return NGX_ERROR;
                }
                ngx_rtmp_amf_reverse_copy(data, buf, 8);
                break;

            case NGX_RTMP_AMF_BOOLEAN:
                if (ngx_rtmp_amf_get(ctx, data, 1) != NGX_OK) {
                    return NGX_ERROR;
                }
                break;

            case NGX_RTMP_AMF_STRING:
                /* 读取 2 字节的 length，保存到 buf 中 */
                if (ngx_rtmp_amf_get(ctx, buf, 2) != NGX_OK) {
                    return NGX_ERROR;
                }
                /* 将 buf 中保存的大端字节序转换为小端字节序，保存到 len 中 */
                ngx_rtmp_amf_reverse_copy(&len, buf, 2);

                if (data == NULL) {
                    rc = ngx_rtmp_amf_get(ctx, data, len);

                } else if (elts->len <= len) {
                    rc = ngx_rtmp_amf_get(ctx, data, elts->len - 1);
                    if (rc != NGX_OK)
                        return NGX_ERROR;
                    ((char*)data)[elts->len - 1] = 0;
                    rc = ngx_rtmp_amf_get(ctx, NULL, len - elts->len + 1);

                } else {
                    /* 读取该 amf 字符串的真正的字符串数据到 data 中 */
                    rc = ngx_rtmp_amf_get(ctx, data, len);
                    ((char*)data)[len] = 0;
                }

                if (rc != NGX_OK) {
                    return NGX_ERROR;
                }

                break;

            case NGX_RTMP_AMF_NULL:
            case NGX_RTMP_AMF_ARRAY_NULL:
                break;

            case NGX_RTMP_AMF_MIXED_ARRAY:
                if (ngx_rtmp_amf_get(ctx, &max_index, 4) != NGX_OK) {
                    return NGX_ERROR;
                }
                /* fall through */

            case NGX_RTMP_AMF_OBJECT:
                if (ngx_rtmp_amf_read_object(ctx, data,
                    data && elts ? elts->len / sizeof(ngx_rtmp_amf_elt_t) : 0
                    ) != NGX_OK)
                {
                    return NGX_ERROR;
                }
                break;

            case NGX_RTMP_AMF_ARRAY:
                if (ngx_rtmp_amf_read_array(ctx, data,
                    data && elts ? elts->len / sizeof(ngx_rtmp_amf_elt_t) : 0
                    ) != NGX_OK)
                {
                    return NGX_ERROR;
                }
                break;

            case NGX_RTMP_AMF_VARIANT_:
                if (ngx_rtmp_amf_read_variant(ctx, data,
                    data && elts ? elts->len / sizeof(ngx_rtmp_amf_elt_t) : 0
                    ) != NGX_OK)
                {
                    return NGX_ERROR;
                }
                break;

            case NGX_RTMP_AMF_INT8:
                if (ngx_rtmp_amf_get(ctx, data, 1) != NGX_OK) {
                    return NGX_ERROR;
                }
                break;

            case NGX_RTMP_AMF_INT16:
                if (ngx_rtmp_amf_get(ctx, buf, 2) != NGX_OK) {
                    return NGX_ERROR;
                }
                ngx_rtmp_amf_reverse_copy(data, buf, 2);
                break;

            case NGX_RTMP_AMF_INT32:
                if (ngx_rtmp_amf_get(ctx, buf, 4) != NGX_OK) {
                    return NGX_ERROR;
                }
                ngx_rtmp_amf_reverse_copy(data, buf, 4);
                break;

            case NGX_RTMP_AMF_END:
                return NGX_OK;

            default:
                return NGX_ERROR;
        }

        if (elts) {
            /* 若 elts 数组中的当前元素获取成功，则接着获取下一个 elts 元素要获取的值 */
            ++elts;
        }
    }

    return NGX_OK;
}

2.2.1 ngx_rtmp_amf_get

/* @ctx：指向 ngx_rtmp_amf_ctx_t 类型的指针，该结构体的成员 link 保存着接收到的 amf 数据
 * @p：将读取到的数据保存到该指针 p 指向的内存
 * @n：要读取的字节数
 */
static ngx_int_t ngx_rtmp_amf_get(ngx_rtmp_amf_ctx_t *ctx, void *p, size_t n)
{
    size_t          size;
    ngx_chain_t    *l;
    size_t          offset;
    u_char         *pos, *last;
#ifdef NGX_DEBUG
    void           *op = p;
    size_t          on = n;
#endif

    if (!n)
        return NGX_OK;

    for(l = ctx->link, offset = ctx->offset; l; l = l->next, offset = 0) {

        /* 开始 pos 指向所要读取数据的起始地址 */
        pos  = l->buf->pos + offset;
        /* last 指向数据的末尾地址 */
        last = l->buf->last;

        /* 当数据充足时 */
        if (last >= pos + n) {
            if (p) {
                /* 拷贝 n 个字节的数据到 p 指向的内存中 */
                p = ngx_cpymem(p, pos, n);
            }
            /* ctx->offset 的偏移值加 n，表示已经读出了 n 个字节的数据 */
            ctx->offset = offset + n;
            ctx->link = l;

#ifdef NGX_DEBUG
            ngx_rtmp_amf_debug("read", ctx->log, (u_char*)op, on);
#endif

            return NGX_OK;
        }

        /* 当 ctx->link 指向的 ngx_chain_t 链表保存的数据不足 n 个时，则将能读取出的数据都读取出来 */
        size = last - pos;

        if (p) {
            p = ngx_cpymem(p, pos, size);
        }

        /* 计算余下未读的字节数，跳到下一个链表继续读取，直到读够为止 */
        n -= size;
    }

    ngx_log_debug1(NGX_LOG_DEBUG_RTMP, ctx->log, 0,
            "AMF read eof (%d)", n);

    return NGX_DONE;
}

2.2.2 ngx_rtmp_amf_reverse_copy

static ngx_inline void *ngx_rtmp_amf_reverse_copy(void *dst, void* src, size_t len)
{
    size_t  k;

    if (dst == NULL || src == NULL) {
        return NULL;
    }

    /* 将 src 中的数据从末尾开始一个个赋给 dst[0],dst[1],dst[2],... */
    for(k = 0; k < len; ++k) {
        ((u_char*)dst)[k] = ((u_char*)src)[len - 1 - k];
    }

    return dst;
}

2.3 ngx_rtmp_amf_read_object

static ngx_int_t
ngx_rtmp_amf_read_object(ngx_rtmp_amf_ctx_t *ctx, ngx_rtmp_amf_elt_t *elts,
        size_t nelts)
{
    uint8_t                 type;
    uint16_t                len;
    size_t                  n, namelen, maxlen;
    ngx_int_t               rc;
    u_char                  buf[2];

    maxlen = 0;
    for(n = 0; n < nelts; ++n) {
        namelen = elts[n].name.len;
        if (namelen > maxlen)
            maxlen = namelen;
    }

    for( ;; ) {

#if !(NGX_WIN32)
        char    name[maxlen];
#else
        char    name[1024];
        if (maxlen > sizeof(name)) {
            return NGX_ERROR;
        }
#endif
        /* read key */
        switch (ngx_rtmp_amf_get(ctx, buf, 2)) {
        case NGX_DONE:
            /* Envivio sends unfinalized arrays */
            return NGX_OK;
        case NGX_OK:
            break;
        default:
            return NGX_ERROR;
        }

        ngx_rtmp_amf_reverse_copy(&len, buf, 2);

        if (!len)
            break;

        if (len <= maxlen) {
            rc = ngx_rtmp_amf_get(ctx, name, len);

        } else {
            rc = ngx_rtmp_amf_get(ctx, name, maxlen);
            if (rc != NGX_OK)
                return NGX_ERROR;
            rc = ngx_rtmp_amf_get(ctx, 0, len - maxlen);
        }

        if (rc != NGX_OK)
            return NGX_ERROR;

        /* TODO: if we require array to be sorted on name
         * then we could be able to use binary search */
        for(n = 0; n < nelts
                && (len != elts[n].name.len
                    || ngx_strncmp(name, elts[n].name.data, len));
                ++n);

        if (ngx_rtmp_amf_read(ctx, n < nelts ? &elts[n] : NULL, 1) != NGX_OK)
            return NGX_ERROR;
    }

    if (ngx_rtmp_amf_get(ctx, &type, 1) != NGX_OK
        || type != NGX_RTMP_AMF_END)
    {
        return NGX_ERROR;
    }

    return NGX_OK;
}

2.4 ngx_rtmp_amf_write

ngx_int_t ngx_rtmp_amf_write(ngx_rtmp_amf_ctx_t *ctx,
        ngx_rtmp_amf_elt_t *elts, size_t nelts)
{
    size_t                  n;
    ngx_int_t               type;
    uint8_t                 type8;
    void                   *data;
    uint16_t                len;
    uint32_t                max_index;
    u_char                  buf[8];

    for(n = 0; n < nelts; ++n) {

        type = elts[n].type;
        data = elts[n].data;
        len  = (uint16_t) elts[n].len;

        /* 如果该 amf 为 shared 类型，则表示没有该 amf 数据
         * 不是 "类型+值" 的形式，即直接是 "值" */
        if (type & NGX_RTMP_AMF_TYPELESS) {
            type &= ~NGX_RTMP_AMF_TYPELESS;
        } else {
            type8 = (uint8_t)type;
            /* 先写入 1 byte 的类型 */
            if (ngx_rtmp_amf_put(ctx, &type8, 1) != NGX_OK)
                return NGX_ERROR;
        }

        switch(type) {
            case NGX_RTMP_AMF_NUMBER:
                if (ngx_rtmp_amf_put(ctx,
                            ngx_rtmp_amf_reverse_copy(buf,
                                data, 8), 8) != NGX_OK)
                {
                    return NGX_ERROR;
                }
                break;

            case NGX_RTMP_AMF_BOOLEAN:
                if (ngx_rtmp_amf_put(ctx, data, 1) != NGX_OK) {
                    return NGX_ERROR;
                }
                break;

            case NGX_RTMP_AMF_STRING:
                if (len == 0 && data) {
                    len = (uint16_t) ngx_strlen((u_char*) data);
                }

                /* 写入 2 bytes 的 长度 */
                if (ngx_rtmp_amf_put(ctx,
                            ngx_rtmp_amf_reverse_copy(buf,
                                &len, 2), 2) != NGX_OK)
                {
                    return NGX_ERROR;
                }

                /* 接着写入 len 大小的字符串数据 data */
                if (ngx_rtmp_amf_put(ctx, data, len) != NGX_OK) {
                    return NGX_ERROR;
                }
                break;

            case NGX_RTMP_AMF_NULL:
            case NGX_RTMP_AMF_ARRAY_NULL:
                break;

            case NGX_RTMP_AMF_MIXED_ARRAY:
                max_index = 0;
                if (ngx_rtmp_amf_put(ctx, &max_index, 4) != NGX_OK) {
                    return NGX_ERROR;
                }
                /* fall through */

            case NGX_RTMP_AMF_OBJECT:
                type8 = NGX_RTMP_AMF_END;
                if (ngx_rtmp_amf_write_object(ctx, data,
                        elts[n].len / sizeof(ngx_rtmp_amf_elt_t)) != NGX_OK
                    || ngx_rtmp_amf_put(ctx, &type8, 1) != NGX_OK)
                {
                    return NGX_ERROR;
                }
                break;

            case NGX_RTMP_AMF_ARRAY:
                if (ngx_rtmp_amf_write_array(ctx, data,
                        elts[n].len / sizeof(ngx_rtmp_amf_elt_t)) != NGX_OK)
                {
                    return NGX_ERROR;
                }
                break;

            case NGX_RTMP_AMF_INT8:
                if (ngx_rtmp_amf_put(ctx, data, 1) != NGX_OK) {
                    return NGX_ERROR;
                }
                break;

            case NGX_RTMP_AMF_INT16:
                if (ngx_rtmp_amf_put(ctx,
                            ngx_rtmp_amf_reverse_copy(buf,
                                data, 2), 2) != NGX_OK)
                {
                    return NGX_ERROR;
                }
                break;

            case NGX_RTMP_AMF_INT32:
                if (ngx_rtmp_amf_put(ctx,
                            ngx_rtmp_amf_reverse_copy(buf,
                                data, 4), 4) != NGX_OK)
                {
                    return NGX_ERROR;
                }
                break;

            default:
                return NGX_ERROR;
        }
    }

    return NGX_OK;
}

2.4.1 ngx_rtmp_amf_put

static ngx_int_t ngx_rtmp_amf_put(ngx_rtmp_amf_ctx_t *ctx, void *p, size_t n)
{
    ngx_buf_t       *b;
    size_t          size;
    ngx_chain_t    *l, *ln;

#ifdef NGX_DEBUG
    ngx_rtmp_amf_debug("write", ctx->log, (u_char*)p, n);
#endif

    l = ctx->link;

    if (ctx->link && ctx->first == NULL) {
        ctx->first = ctx->link;
    }

    while(n) {
        b = l ? l->buf : NULL;

        if (b == NULL || b->last == b->end) {

            ln = ctx->alloc(ctx->arg);
            if (ln == NULL) {
                return NGX_ERROR;
            }

            if (ctx->first == NULL) {
                ctx->first = ln;
            }

            if (l) {
                l->next = ln;
            }

            l = ln;
            ctx->link = l;
            b = l->buf;
        }

        size = b->end - b->last;

        /* 若要写入的缓存空间足够，则直接将其cp */
        if (size >= n) {
            b->last = ngx_cpymem(b->last, p, n);
            return NGX_OK;
        }

        /* 否则，若内存不足，则只写入 size 字节的数组，
         * 余下的写入下一个 ngx_chain_t 中(存在的话) */
        b->last = ngx_cpymem(b->last, p, size);
        p = (u_char*)p + size;
        n -= size;
    }

    return NGX_OK;
}

2.4.2 ngx_rtmp_amf_write_object

static ngx_int_t ngx_rtmp_amf_write_object(ngx_rtmp_amf_ctx_t *ctx,
        ngx_rtmp_amf_elt_t *elts, size_t nelts)
{
    uint16_t                len;
    size_t                  n;
    u_char                  buf[2];

    for(n = 0; n < nelts; ++n) {

        len = (uint16_t) elts[n].name.len;

        /* 先写入 2 bytes 长度值 */
        if (ngx_rtmp_amf_put(ctx,
                    ngx_rtmp_amf_reverse_copy(buf,
                        &len, 2), 2) != NGX_OK)
        {
            return NGX_ERROR;
        }

        /* 接着将 len bytes 的 名称写入*/
        if (ngx_rtmp_amf_put(ctx, elts[n].name.data, len) != NGX_OK) {
            return NGX_ERROR;
        }

        /* 接着写入上面 elts[n].name 的值 */
        if (ngx_rtmp_amf_write(ctx, &elts[n], 1) != NGX_OK) {
            return NGX_ERROR;
        }
    }

    /* 该 object 的项都写入完成后，最后写入 2 bytes 的 '\0' */
    if (ngx_rtmp_amf_put(ctx, "\0\0", 2) != NGX_OK) {
        return NGX_ERROR;
    }

    return NGX_OK;
}

转载于:https://www.cnblogs.com/jimodetiantang/p/8975945.html

weixin_30437481
关注
rtmp amf 0
突围
12-10 403
AMF是Adobe设计的一种通用数据封装格式。 rtmp协议中数据都是大端的，所以在放数据前都要将数据转成大端的形式。 AMF(Action Message Format)是一种 二进制格式数据型态，AMF协议基于HTTP，将flash客户端数据编码后传回server，server端的remoting adaptor接收到数据后则会解码回正确的native对象，交给正确的程序处理，并以同样的数...
nginx-rtmp源码概述
wu5215080的专栏
05-19 5075
github:https://github.com/arut/nginx-rtmp-module/wiki /* 点播相关*/ ngx_rtmp_dash_module ngx_rtmp_mp4 ngx_rtmp_mp4 ngx_rtmp_mp4_module /* 主要支持rtmp MP4这块点播相关功能，支持seek操作*/ ngx_rtmp_flv_module /*...
RTMP中的AMF0格式说明
weixin_33725126的博客
06-23 585
2019独角兽企业重金招聘Python工程师标准>>> ...
通过nginx负载marcomedia AMF flash remoting RIA客户端
akulakk's memory stack
08-19 1426
  通常我们使用nginx来做http的负载,今天我通过试验发现,nginx默认是支持AMF协议的.不得不赞一个!  通常我们在flash客户端中负载的话是修改remoting service的gateway地址,比如有2个服务,部署于game1.xxx.com 和 game2.xxx.com 那么flash中AS的网关调用写法就是调用 http://game1.xxx.com/gateway.aspx 或者 http://game2.xxx.com/gateway.aspx  这样做,负载就很麻烦,域名改
RTMP协议中的AMF0格式定义
FLASH流媒体协议研究
12-11 5025
RTMP协议中的AMF0格式定义
RTMP协议– AMF消息详解
qq_28309121的博客
03-01 2303
一、简述： 本教程是基于VLC实现的Rtmp服务器与客户端的播放流程 AMF 命令-命令消息类型 发送端发送时会带有： 命令的名字，如 connect Transaction ID 表示此次命令的标识 Command Object 表示相关参数 接受端收到命令后，会返回以下三种消息中的一种： _result 消息表示接受该命令，对端可以继续往下执行流程 _error 消息代表拒绝该...
nginx-rtmp-module-master直播流组件源码
08-11
2. **ngx_rtmp_handler.c/h**：处理RTMP协议的各个消息类型，如 chunking、AMF编码解码等。 3. **ngx_rtmp_hls_module.c/h**：HLS模块，处理HLS切片和M3U8索引文件生成。 4. **ngx_rtmp_record_module.c/h**：录制...
基于nginx-rtmp-module模块实现的HTTP-FLV直播模块nginx-http-flv-module（三）
winshining的专栏
08-08 1万+
接上一篇《基于nginx-rtmp-module模块实现的HTTP-FLV直播模块nginx-http-flv-module（二）》内容。 项目地址：https://github.com/winshining/nginx-http-flv-module，欢迎大家下载测试，返回bug和提交PR。 2018-10-28：现在nginx-htt-flv-module还...
基于nginx-rtmp-module模块的relay功能分析及完善
回报社会的专栏
06-03 3993
多种实时流请求触发中继的实现基于nginx-1.8.1+nginx-rtmp-module方案1.概述²  视频直播方案基于nginx+rtmp；²  集群内区分边缘和源务服器，边缘与源是基于rtmp流做同步的，有relay模块实现；²  集群内服务器除提供rtmp实时流基础功能外，基于rtmp实时流，还提供了httplive stream(hls)实时流及http live flv(hlf)实时...
OBS直播设置详细教程与nginx-rtmp-hls-flv应用
配置nginx-rtmp模块通常包括编辑nginx的配置文件，增加rtmp模块的配置段落，并设置不同的应用来处理输入和输出流。例如，创建一个应用来接收RTMP流，然后定义一个hls应用来生成HLS播放列表，或者创建一个flv应用来...
rtmp数据封装二-AMF
Jacob_job的博客
08-20 1236
简介 rtmp协议在传输script数据onMetaData时使用AMF(Action Message Format)格式封装。 AMF_TYPE对应的编号： 0 ： AMF_NUMBER 1 ： AMF_BOOLEAN, 2 ： AMF_STRING, 3 ： AMF_OBJECT, 4 ： AMF_MOVIECLIP, 5 ： AMF_NULL, 6 ： AMF_UNDEFINED, ...
nginx-rtmp协议解读
weixin_43360707的博客
06-14 1777
前言 1.RTMP(实时消息传输协议)是Adobe 公司开发的一个基于TCP的应用层协议。 2.RTMP协议中基本的数据单元称为消息（Message）。 3.当RTMP协议在互联网中传输数据的时候，消息会被拆分成更小的单元，称为消息块（Chunk）。 一、握手协议 要建立一个有效的RTMP Connection链接，首先要“握手”:客户端要向服务器发送C0,C1,C2（按序）三个chunk，服务器向客户端发送S0,S1,S2（按序）三个chunk，然后才能进行有效的信息传输。RTMP协议本身并没有规定..
RTMP协议分析
潇湘无敌手个人天空
02-09 1万+
一、RTMP包头 RTMP协议 封包 参考Red5 RTMP协议封包 由一个包头和一个包体组成,包头可以是4种长度的任意一种:12, 8, 4,  1 byte(s).完整的RTMP包头应该是12bytes,包含了时间戳,Head_Type,AMFSize,AMFType,StreamID信息, 8字节的包头只纪录了时间戳,Head_Type,AMFSize,AMFType, 4个字节的包
rtmp协议规范详解
二进制君
01-17 1万+
转载请注明出处：http://blog.csdn.net/handsomehong 本篇文章大部分是rtmp协议1.0版本的翻译，翻译参考了网上的版本，加了一些抓包分析。 Adobe公司的实时消息传输协议 摘要 　　此备忘录描述了 Adobe公司的实时消息传输协议(RTMP)，此协议从属于应用层，被用来在适合的传输协议（如TCP）上复用和打包多媒体传输流（如音频、视频和互动
小谈RTMP中AMF3类型的Command message
k1988的程序生活
03-05 2573
由于历史原因我喜欢将这个消息叫做invoke。 1、AMF3类型的Invoke消息的类型是17，而AMF0的Invoke消息的消息类型是20。 2、AMF3类型的Invoke也是使用AMF0进行序列化，只是其中的object使用AFM0类型AMF0_AMF3_OBJECT(0x11)，也就是body部分是一个 采用AFM3格式的object。 3、AMF3类型Invoke消息体的第
ffmpeg+nginx建立rtmp服务器，播放摄像头流
tianyu的专栏 - Linux site:blog.csdn.net/wishfly
07-12 1455
好文章，http://blog.fs-Linux.org/?p=137 先转载，然后再动手实践看看 live555可以建立rtsp这个大伙都知道，ffserver+ffmpeg也可以建立一个实时rtsp服务，那么rtmp呢？好多人会首选red5，al'right，这里用的是nginx，下面记录一下使用nginx建立rtmp的全过程 首先下载一份nginx的rtmp的module
如何给 nginx rtmp 服务加入鉴权机制
热门推荐
〓☆〓 清风徐来918 （QQ:89617663）
12-09 1万+
目前直播平台非常的火爆。当前有不少的流媒体CDN，基于rtmp，http-flv和hls协议的。 也可以自己搭建私有的流媒体服务器，目前比较常见的有：Live555，EasyDarwin，Red5，DSS，Wowza，nginx-rtmp 这里重点讲解开源的nginx-rtmp服务器。但是流媒体服务器最大的一个问题就是防盗链和鉴权问题，如何防止流媒体服务器被第三方应用免费使用。 所以需要给n
FFMPEG_RTMP协议_收流_推流
06-29
RTMP推流，收流的各代码实现和代码和协议讲解 包括如下内容【0】所有需要的软件、代码、资料都在百度云盘中提取码在视频中和课程的第一部分。有问题，请及时联系。【1】AS3版本:基于ADOBE公司的FLASH程序的AS3.0代码,实现flash版本的收流，推流和摄像头的捕获和推流。【2】最全种类的HTML插件,有swf，js等10多个插件，视频中提供了演示，方便您的使用。【3】基于java的ssh框架的视频网站，实现了视频的点播和在线播放，视频的转码、加水印、截取缩略图。想学习ssh的视频网站的朋友可以看一下。【4】基于FFMPEG的视频收流和推流。VS2010开发环境【5】基于LIBRTMP的视频手收流和推流。包含推送FLV和H264.基于VCS2010开发环境【6】RTMPDump代码讲解，一个完整实现了RTMP推流和收流的代码。结合代码和协议，让您尽快熟悉RTMP协议和这套开源的代码，您可以改造成您需要的程序。RTMPDump是个好代码。
RTMP协议中的AMF数据
yeyumin89的专栏
09-01 6972
这里有一个连接，amf0和amf3的库，我下了看了下，还是自己写吧，哎。http://wooce.iteye.com/blog/1396278 参考crtmpserver的代码写的，其中有amf.h文件。     AMF数据第一个byte为此数据的类型，类型有： Number 0×00 double类型 Boolean 0×01
RTMP协议中的AMF数据类型说明
01-14 5514
这里有一个连接，amf0和amf3的库，我下了看了下，还是自己写吧，哎。http://wooce.iteye.com/blog/1396278 参考crtmpserver的代码写的，其中有amf.h文件。     AMF数据第一个byte为此数据的类型，类型有： Number 0×00 double类型 Boolean 0×01 bool类型
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值