nginx-rtmp: connect过程

最新推荐文章于 2022-08-26 14:34:46 发布
最新推荐文章于 2022-08-26 14:34:46 发布
阅读量206 收藏
点赞数
原文链接：https://my.oschina.net/u/2326611/blog/1526177
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

客户端和服务器经过三次握手后，执行函数ngx_rtmp_cycle()。

首先执行函数ngx_rtmp_cycle()

void
ngx_rtmp_cycle(ngx_rtmp_session_t *s)
{
    ngx_connection_t           *c;

    c = s->connection;
    c->read->handler =  ngx_rtmp_recv;
    c->write->handler = ngx_rtmp_send;

    s->ping_evt.data = c;
    s->ping_evt.log = c->log;
    s->ping_evt.handler = ngx_rtmp_ping;
    ngx_rtmp_reset_ping(s);

    ngx_rtmp_recv(c->read);
}

gdb跟踪：

(gdb) bt
#0  ngx_rtmp_cycle (s=0x21a2220) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_handler.c:93
#1  0x00000000005453c1 in ngx_rtmp_handshake_done (s=0x21a2220) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_handshake.c:365
#2  0x00000000005457b2 in ngx_rtmp_handshake_recv (rev=0x7fffd79ff148) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_handshake.c:455
#3  0x000000000047d730 in ngx_epoll_process_events (cycle=0x20990d0, timer=10000, flags=1) at src/event/modules/ngx_epoll_module.c:694
#4  0x000000000046fcce in ngx_process_events_and_timers (cycle=0x20990d0) at src/event/ngx_event.c:236
#5  0x000000000047a6ec in ngx_single_process_cycle (cycle=0x20990d0) at src/os/unix/ngx_process_cycle.c:317
#6  0x0000000000449f5e in main (argc=3, argv=0x7fffffffe518) at src/core/nginx.c:418

 

接着执行函数ngx_rtmp_recv()

static void
ngx_rtmp_recv(ngx_event_t *rev)
{
    ngx_int_t                   n;
    ngx_connection_t           *c;
    ngx_rtmp_session_t         *s;
    ngx_rtmp_core_srv_conf_t   *cscf;
    ngx_rtmp_header_t          *h;
    ngx_rtmp_stream_t          *st, *st0;
    ngx_chain_t                *in, *head;
    ngx_buf_t                  *b;
    u_char                     *p, *pp, *old_pos;
    size_t                      size, fsize, old_size;
    uint8_t                     fmt, ext;
    uint32_t                    csid, timestamp;

    c = rev->data;
    s = c->data;
    b = NULL;
    old_pos = NULL;
    old_size = 0;
    cscf = ngx_rtmp_get_module_srv_conf(s, ngx_rtmp_core_module);

    if (c->destroyed) {
        return;
    }

    for( ;; ) {

        st = &s->in_streams[s->in_csid];

        /* allocate new buffer */
        if (st->in == NULL) {
            st->in = ngx_rtmp_alloc_in_buf(s);
            if (st->in == NULL) {
                ngx_log_error(NGX_LOG_INFO, c->log, 0,
                        "in buf alloc failed");
                ngx_rtmp_finalize_session(s);
                return;
            }
        }

        h  = &st->hdr;
        in = st->in;
        b  = in->buf;

        if (old_size) {

            ngx_log_debug1(NGX_LOG_DEBUG_RTMP, c->log, 0,
                    "reusing formerly read data: %d", old_size);

            b->pos = b->start;
            b->last = ngx_movemem(b->pos, old_pos, old_size);

            if (s->in_chunk_size_changing) {
                ngx_rtmp_finalize_set_chunk_size(s);
            }

        } else {

            if (old_pos) {
                b->pos = b->last = b->start;
            }

            n = c->recv(c, b->last, b->end - b->last);

            if (n == NGX_ERROR || n == 0) {
                ngx_rtmp_finalize_session(s);
                return;
            }

            if (n == NGX_AGAIN) {
                if (ngx_handle_read_event(c->read, 0) != NGX_OK) {
                    ngx_rtmp_finalize_session(s);
                }
                return;
            }

            s->ping_reset = 1;
            ngx_rtmp_update_bandwidth(&ngx_rtmp_bw_in, n);
            b->last += n;
            s->in_bytes += n;

            if (s->in_bytes >= 0xf0000000) {
                ngx_log_debug0(NGX_LOG_DEBUG_RTMP, c->log, 0,
                               "resetting byte counter");
                s->in_bytes = 0;
                s->in_last_ack = 0;
            }

            if (s->ack_size && s->in_bytes - s->in_last_ack >= s->ack_size) {

                s->in_last_ack = s->in_bytes;

                ngx_log_debug1(NGX_LOG_DEBUG_RTMP, c->log, 0,
                        "sending RTMP ACK(%uD)", s->in_bytes);

                if (ngx_rtmp_send_ack(s, s->in_bytes)) {
                    ngx_rtmp_finalize_session(s);
                    return;
                }
            }
        }

        old_pos = NULL;
        old_size = 0;

        /* parse headers */
        if (b->pos == b->start) {
            p = b->pos;

            /* chunk basic header */
            fmt  = (*p >> 6) & 0x03;
            csid = *p++ & 0x3f;

            if (csid == 0) {
                if (b->last - p < 1)
                    continue;
                csid = 64;
                csid += *(uint8_t*)p++;

            } else if (csid == 1) {
                if (b->last - p < 2)
                    continue;
                csid = 64;
                csid += *(uint8_t*)p++;
                csid += (uint32_t)256 * (*(uint8_t*)p++);
            }

            ngx_log_debug2(NGX_LOG_DEBUG_RTMP, c->log, 0,
                    "RTMP bheader fmt=%d csid=%D",
                    (int)fmt, csid);

            if (csid >= (uint32_t)cscf->max_streams) {
                ngx_log_error(NGX_LOG_INFO, c->log, 0,
                    "RTMP in chunk stream too big: %D >= %D",
                    csid, cscf->max_streams);
                ngx_rtmp_finalize_session(s);
                return;
            }

            /* link orphan */
            if (s->in_csid == 0) {

                /* unlink from stream #0 */
                st->in = st->in->next;

                /* link to new stream */
                s->in_csid = csid;
                st = &s->in_streams[csid];
                if (st->in == NULL) {
                    in->next = in;
                } else {
                    in->next = st->in->next;
                    st->in->next = in;
                }
                st->in = in;
                h = &st->hdr;
                h->csid = csid;
            }

            ext = st->ext;
            timestamp = st->dtime;
            if (fmt <= 2 ) {
                if (b->last - p < 3)
                    continue;
                /* timestamp:
                 *  big-endian 3b -> little-endian 4b */
                pp = (u_char*)&timestamp;
                pp[2] = *p++;
                pp[1] = *p++;
                pp[0] = *p++;
                pp[3] = 0;

                ext = (timestamp == 0x00ffffff);

                if (fmt <= 1) {
                    if (b->last - p < 4)
                        continue;
                    /* size:
                     *  big-endian 3b -> little-endian 4b
                     * type:
                     *  1b -> 1b*/
                    pp = (u_char*)&h->mlen;
                    pp[2] = *p++;
                    pp[1] = *p++;
                    pp[0] = *p++;
                    pp[3] = 0;
                    h->type = *(uint8_t*)p++;

                    if (fmt == 0) {
                        if (b->last - p < 4)
                            continue;
                        /* stream:
                         *  little-endian 4b -> little-endian 4b */
                        pp = (u_char*)&h->msid;
                        pp[0] = *p++;
                        pp[1] = *p++;
                        pp[2] = *p++;
                        pp[3] = *p++;
                    }
                }
            }

            /* extended header */
            if (ext) {
                if (b->last - p < 4)
                    continue;
                pp = (u_char*)&timestamp;
                pp[3] = *p++;
                pp[2] = *p++;
                pp[1] = *p++;
                pp[0] = *p++;
            }

            if (st->len == 0) {
                /* Messages with type=3 should
                 * never have ext timestamp field
                 * according to standard.
                 * However that's not always the case
                 * in real life */
                st->ext = (ext && cscf->publish_time_fix);
                if (fmt) {
                    st->dtime = timestamp;
                } else {
                    h->timestamp = timestamp;
                    st->dtime = 0;
                }
            }

            ngx_log_debug8(NGX_LOG_DEBUG_RTMP, c->log, 0,
                    "RTMP mheader fmt=%d %s (%d) "
                    "time=%uD+%uD mlen=%D len=%D msid=%D",
                    (int)fmt, ngx_rtmp_message_type(h->type), (int)h->type,
                    h->timestamp, st->dtime, h->mlen, st->len, h->msid);

            /* header done */
            b->pos = p;

            if (h->mlen > cscf->max_message) {
                ngx_log_error(NGX_LOG_INFO, c->log, 0,
                        "too big message: %uz", cscf->max_message);
                ngx_rtmp_finalize_session(s);
                return;
            }
        }

        size = b->last - b->pos;
        fsize = h->mlen - st->len;

        if (size < ngx_min(fsize, s->in_chunk_size))
            continue;

        /* buffer is ready */

        if (fsize > s->in_chunk_size) {
            /* collect fragmented chunks */
            st->len += s->in_chunk_size;
            b->last = b->pos + s->in_chunk_size;
            old_pos = b->last;
            old_size = size - s->in_chunk_size;

        } else {
            /* handle! */
            head = st->in->next;
            st->in->next = NULL;
            b->last = b->pos + fsize;
            old_pos = b->last;
            old_size = size - fsize;
            st->len = 0;
            h->timestamp += st->dtime;

            if (ngx_rtmp_receive_message(s, h, head) != NGX_OK) {
                ngx_rtmp_finalize_session(s);
                return;
            }

            if (s->in_chunk_size_changing) {
                /* copy old data to a new buffer */
                if (!old_size) {
                    ngx_rtmp_finalize_set_chunk_size(s);
                }

            } else {
                /* add used bufs to stream #0 */
                st0 = &s->in_streams[0];
                st->in->next = st0->in;
                st0->in = head;
                st->in = NULL;
            }
        }

        s->in_csid = 0;
    }
}

gdb跟踪：

(gdb) bt
#0  ngx_rtmp_recv (rev=0x7fffd79ff148) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_handler.c:233
#1  0x0000000000546000 in ngx_rtmp_cycle (s=0x21a2220) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_handler.c:102
#2  0x00000000005453c1 in ngx_rtmp_handshake_done (s=0x21a2220) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_handshake.c:365
#3  0x00000000005457b2 in ngx_rtmp_handshake_recv (rev=0x7fffd79ff148) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_handshake.c:455
#4  0x000000000047d730 in ngx_epoll_process_events (cycle=0x20990d0, timer=10000, flags=1) at src/event/modules/ngx_epoll_module.c:694
#5  0x000000000046fcce in ngx_process_events_and_timers (cycle=0x20990d0) at src/event/ngx_event.c:236
#6  0x000000000047a6ec in ngx_single_process_cycle (cycle=0x20990d0) at src/os/unix/ngx_process_cycle.c:317
#7  0x0000000000449f5e in main (argc=3, argv=0x7fffffffe518) at src/core/nginx.c:418

connect

connect时，对应Command Message，即Type ID为20，Chunk Stream ID为3，Stream ID 为0。

结构体ngx_rtmp_header_t内容：

typedef struct {
    uint32_t                csid;       /* chunk stream id */
    uint32_t                timestamp;  /* timestamp (delta) */
    uint32_t                mlen;       /* message length */
    uint8_t                 type;       /* message type id */
    uint32_t                msid;       /* message stream id */
} ngx_rtmp_header_t;

函数ngx_rtmp_receive_message()中，ngx_rtmp_header_t中type为20，即函数指针evh对应函数ngx_rtmp_amf_message_handler()：

执行函数ngx_rtmp_receive_message()
ngx_int_t
ngx_rtmp_receive_message(ngx_rtmp_session_t *s,
        ngx_rtmp_header_t *h, ngx_chain_t *in)
{
    ngx_rtmp_core_main_conf_t  *cmcf;
    ngx_array_t                *evhs;
    size_t                      n;
    ngx_rtmp_handler_pt        *evh;

    cmcf = ngx_rtmp_get_module_main_conf(s, ngx_rtmp_core_module);

#ifdef NGX_DEBUG
    {
        int             nbufs;
        ngx_chain_t    *ch;

        for(nbufs = 1, ch = in;
                ch->next;
                ch = ch->next, ++nbufs);

        ngx_log_debug7(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
                "RTMP recv %s (%d) csid=%D timestamp=%D "
                "mlen=%D msid=%D nbufs=%d",
                ngx_rtmp_message_type(h->type), (int)h->type,
                h->csid, h->timestamp, h->mlen, h->msid, nbufs);
    }
#endif

    if (h->type > NGX_RTMP_MSG_MAX) {
        ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
                "unexpected RTMP message type: %d", (int)h->type);
        return NGX_OK;
    }

    evhs = &cmcf->events[h->type];
    evh = evhs->elts;

    ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
            "nhandlers: %d", evhs->nelts);

    for(n = 0; n < evhs->nelts; ++n, ++evh) {
        if (!evh) {
            continue;
        }
        ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
                "calling handler %d", n);

        switch ((*evh)(s, h, in)) {
            case NGX_ERROR:
                ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
                        "handler %d failed", n);
                return NGX_ERROR;
            case NGX_DONE:
                return NGX_OK;
        }
    }

    return NGX_OK;
}

 

执行函数ngx_rtmp_amf_message_handler()
ngx_int_t
ngx_rtmp_amf_message_handler(ngx_rtmp_session_t *s,
        ngx_rtmp_header_t *h, ngx_chain_t *in)
{
    ngx_rtmp_amf_ctx_t          act;
    ngx_rtmp_core_main_conf_t  *cmcf;
    ngx_array_t                *ch;
    ngx_rtmp_handler_pt        *ph;
    size_t                      len, n;

    static u_char               func[128];

    static ngx_rtmp_amf_elt_t   elts[] = {

        { NGX_RTMP_AMF_STRING,
          ngx_null_string,
          func,   sizeof(func) },
    };

    /* AMF command names come with string type, but shared object names
     * come without type */
    if (h->type == NGX_RTMP_MSG_AMF_SHARED ||
        h->type == NGX_RTMP_MSG_AMF3_SHARED)
    {
        elts[0].type |= NGX_RTMP_AMF_TYPELESS;
    } else {
        elts[0].type &= ~NGX_RTMP_AMF_TYPELESS;
    }

    if ((h->type == NGX_RTMP_MSG_AMF3_SHARED ||
         h->type == NGX_RTMP_MSG_AMF3_META ||
         h->type == NGX_RTMP_MSG_AMF3_CMD)
         && in->buf->last > in->buf->pos)
    {
        ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
                "AMF3 prefix: %ui", (ngx_int_t)*in->buf->pos);
        ++in->buf->pos;
    }

    cmcf = ngx_rtmp_get_module_main_conf(s, ngx_rtmp_core_module);

    /* read AMF func name & transaction id */
    ngx_memzero(&act, sizeof(act));
    act.link = in;
    act.log = s->connection->log;
    memset(func, 0, sizeof(func));

    if (ngx_rtmp_amf_read(&act, elts,
                sizeof(elts) / sizeof(elts[0])) != NGX_OK)
    {
        ngx_log_debug0(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
                "AMF cmd failed");
        return NGX_ERROR;
    }

    /* skip name */
    in = act.link;
    in->buf->pos += act.offset;

    len = ngx_strlen(func);

    ch = ngx_hash_find(&cmcf->amf_hash,
            ngx_hash_strlow(func, func, len), func, len);

    if (ch && ch->nelts) {
        ph = ch->elts;
        for (n = 0; n < ch->nelts; ++n, ++ph) {
            ngx_log_debug3(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
                "AMF func '%s' passed to handler %d/%d",
                func, n, ch->nelts);
            switch ((*ph)(s, h, in)) {
                case NGX_ERROR:
                    return NGX_ERROR;
                case NGX_DONE:
                    return NGX_OK;
            }
        }
    } else {
        ngx_log_debug1(NGX_LOG_DEBUG_RTMP, s->connection->log, 0,
            "AMF cmd '%s' no handler", func);
    }

    return NGX_OK;
}

其中func表示"connect"，通过hash找到对应的处理函数，即ph对应函数ngx_rtmp_cmd_connect_init()

函数ngx_rtmp_cmd_connect_init()
static ngx_int_t
ngx_rtmp_cmd_connect_init(ngx_rtmp_session_t *s, ngx_rtmp_header_t *h,
        ngx_chain_t *in)
{
    size_t                      len;

    static ngx_rtmp_connect_t   v;

    static ngx_rtmp_amf_elt_t  in_cmd[] = {

        { NGX_RTMP_AMF_STRING,
          ngx_string("app"),
          v.app, sizeof(v.app) },

        { NGX_RTMP_AMF_STRING,
          ngx_string("flashVer"),
          v.flashver, sizeof(v.flashver) },

        { NGX_RTMP_AMF_STRING,
          ngx_string("swfUrl"),
          v.swf_url, sizeof(v.swf_url) },

        { NGX_RTMP_AMF_STRING,
          ngx_string("tcUrl"),
          v.tc_url, sizeof(v.tc_url) },

        { NGX_RTMP_AMF_NUMBER,
          ngx_string("audioCodecs"),
          &v.acodecs, sizeof(v.acodecs) },

        { NGX_RTMP_AMF_NUMBER,
          ngx_string("videoCodecs"),
          &v.vcodecs, sizeof(v.vcodecs) },

        { NGX_RTMP_AMF_STRING,
          ngx_string("pageUrl"),
          v.page_url, sizeof(v.page_url) },

        { NGX_RTMP_AMF_NUMBER,
          ngx_string("objectEncoding"),
          &v.object_encoding, 0},
    };

    static ngx_rtmp_amf_elt_t  in_elts[] = {

        { NGX_RTMP_AMF_NUMBER,
          ngx_null_string,
          &v.trans, 0 },

        { NGX_RTMP_AMF_OBJECT,
          ngx_null_string,
          in_cmd, sizeof(in_cmd) },
    };

    ngx_memzero(&v, sizeof(v));
    if (ngx_rtmp_receive_amf(s, in, in_elts,
                sizeof(in_elts) / sizeof(in_elts[0])))
    {
        return NGX_ERROR;
    }

    len = ngx_strlen(v.app);
    if (len > 10 && !ngx_memcmp(v.app + len - 10, "/_definst_", 10)) {
        v.app[len - 10] = 0;
    } else if (len && v.app[len - 1] == '/') {
        v.app[len - 1] = 0;
    }

    ngx_rtmp_cmd_fill_args(v.app, v.args);

    ngx_log_error(NGX_LOG_INFO, s->connection->log, 0,
            "connect: app='%s' args='%s' flashver='%s' swf_url='%s' "
            "tc_url='%s' page_url='%s' acodecs=%uD vcodecs=%uD "
            "object_encoding=%ui",
            v.app, v.args, v.flashver, v.swf_url, v.tc_url, v.page_url,
            (uint32_t)v.acodecs, (uint32_t)v.vcodecs,
            (ngx_int_t)v.object_encoding);

    return ngx_rtmp_connect(s, &v);
}

debug调试：

(gdb) bt
#0  ngx_rtmp_cmd_connect_init (s=0x21a2220, h=0x209d298, in=0x209e0f0) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_cmd_module.c:206
#1  0x000000000054db82 in ngx_rtmp_amf_message_handler (s=0x21a2220, h=0x209d298, in=0x209e0f0) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_receive.c:448
#2  0x0000000000548eee in ngx_rtmp_receive_message (s=0x21a2220, h=0x209d298, in=0x209e0f0) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_handler.c:1172
#3  0x00000000005470f6 in ngx_rtmp_recv (rev=0x7fffd79ff148) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_handler.c:529
#4  0x0000000000546000 in ngx_rtmp_cycle (s=0x21a2220) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_handler.c:102
#5  0x00000000005453c1 in ngx_rtmp_handshake_done (s=0x21a2220) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_handshake.c:365
#6  0x00000000005457b2 in ngx_rtmp_handshake_recv (rev=0x7fffd79ff148) at ../../NGINX-RTMP/nginx-rtmp-module-master/ngx_rtmp_handshake.c:455
#7  0x000000000047d730 in ngx_epoll_process_events (cycle=0x20990d0, timer=10000, flags=1) at src/event/modules/ngx_epoll_module.c:694
#8  0x000000000046fcce in ngx_process_events_and_timers (cycle=0x20990d0) at src/event/ngx_event.c:236
#9  0x000000000047a6ec in ngx_single_process_cycle (cycle=0x20990d0) at src/os/unix/ngx_process_cycle.c:317
#10 0x0000000000449f5e in main (argc=3, argv=0x7fffffffe518) at src/core/nginx.c:418

服务器对于connect的响应为_result，然后返回到函数ngx_rtmp_recv()，继续接收客户的数据。

转载于:https://my.oschina.net/u/2326611/blog/1526177

weixin_33946020
关注
Nginx - 搭建RTMP+HLS流媒体服务器
幻世
01-21 807
拉取视频流的软件也很多，比如VLC、FFmpeg等都可以拉流并播放。左侧为FFmpeg推流，右侧为PotPlayer拉流播放。另一个常用的推流软件是OBS。输入拉取视频的服务器RTMP流地址。，在控件一栏中打开设置，点开推流。安装Nginx和RTMP模块。修改nginx的配置文件。随后在控件，点击开始推流。在文件后追加以下内容。
rtmp用户请求连接建立
weixin_42146646的博客
03-15 373
  上一节，我们介绍了rtmp模块的初始化；在上一节中，我们提到了，当有rtmp模块的请求到达时，nginx处理网络事件的event模块会回调rtmp模块的ngx_rtmp_init_connection接口，本节中，我们将分析一下RTMP模块是如何处理连接请求的。   我们首先看一下ngx_rtmp_init_connection该函数的函数体，在函数体部分有对关键部分的解释说明： void ngx_rtmp_init_connection(ngx_connection_t *c) { n.
ngx_rtmp_cycle函数
xuyanlqs的博客
08-23 361
void ngx_rtmp_cycle(ngx_rtmp_session_t *s) 给连接设置读写处理函数：ngx_rtmp_recv，ngx_rtmp_send。 给session设置ping的处理函数：ngx_rtmp_ping。 reset ping。这里使用了红黑树。 调用ngx_rtmp_recv。
Nginx-rtmp 直播媒体实时流实现
嘿嘿
07-10 1564
这两篇博客也是跟直播流媒体相关的(2019-11-08) 物联网架构成长之路(41)-直播流媒体入门(RTSP篇)https://www.cnblogs.com/wunaozai/p/11772060.html 物联网架构成长之路(42)-直播流媒体入门(RTMP篇)https://www.cnblogs.com/wunaozai/p/11772392.html 0. 前言 　　这段时间在搭建一个IPCamera项目服务器。视频点对点通话，客户端会查看设备端的音视频实时流。为了省...
Nginx-rtmp直播之业务流程分析
weixin_30951389的博客
05-08 875
1. 综述 1.1 直播原理 使用 obs 向 nginx 推送一个直播流，该直播流经 nginx-rtmp 的 ngx_rtmp_live_module 模块转发给 application live 应用， 然后使用 vlc 连接 live，播放该直播流。 1.2 nginx.conf # 创建的子进程数 worker_processes 1; error_log stderr debu...
树莓派 编译nginx添加nginx-rtmp-module-master
qbbing2013的博客
08-26 513
usr/local/nginx/sbin/nginx -t //检查nginx配置文件。/usr/local/nginx/sbin/nginx -s reopen // 重启 Nginx。/usr/local/nginx/sbin/nginx -s stop // 停止 Nginx。/usr/local/nginx/sbin/nginx //启动nginx。...
Nginx-rtmp实现直播媒体实时流效果
09-30
Nginx-RTMP 实现直播媒体实时流 在现代互联网直播系统中，实时流媒体传输扮演着至关重要的角色。Nginx-RTMP 模块是一个强大的工具，用于构建实时流媒体服务器，以支持RTMP（Real-Time Messaging Protocol）协议，...
Nginx RTMP 模块 nginx-rtmp-module 指令详解
trigfj的博客
02-04 370
Nginx RTMP 模块 nginx-rtmp-module 指令详解
基于obs的rtmp源码分析之RTMP_Connect(rtmp连接)
一个大龄程序员的博客
03-12 1141
最近在研究OBS源码，里面有一个很重要的模块是推流模块，OBS是使用RTMP进行推流的，源码里面也有RTMP的源码，翻了一下目前网上没有详细的RTMP源码注释，所以这里基于OBS项目，来详细讲一下RTMP源码包括内核数据结构、公共函数接口功能。关于具体的RTMP协议，网上有很多RTMP协议可以找到这里只做简单介绍，重点是代码的注释分析。接口比较多写的比较细，耐心看哈哈哈。 这里所有的实际测试推流操作均为向斗鱼上推流（因为我一直用它看直播哈） RTMP协议是应用层协议，是要靠底层可靠的传输层协议（通常是TCP
Rtmp信令交互过程分析三-连接(connect)
wq892373445的博客
07-02 388
概述 握手之后就是连接(connect)，由客户端发起，服务端响应，connect指定的app。 1、C->S : connect app：需要connect的app名称 flashVer tcUrl fpad capabilities audioCodecs videoCodecs videoFunction 2、S->C : Window Acknowledgement Size 指定Window Acknowledgem
Nginx-rtmp点播之业务流程分析
weixin_30306905的博客
05-03 335
1. 点播的播放流程分析 1.1 ngx_rtmp_cycle 在握手结束后，即进入该函数中做进一步处理。 void ngx_rtmp_cycle(ngx_rtmp_session_t *s) { ngx_connection_t *c; c = s->connection; /* 重新设置读/写事件的回调函数 */ c->read...
rtmp信令交互过程分析三-连接(connect)
Jacob_job的博客
08-20 1843
概述 握手之后就是连接(connect)，由客户端发起，服务端响应，connect指定的app。 1、C-&amp;gt;S : connect app：需要connect的app名称 flashVer tcUrl fpad capabilities audioCodecs videoCodecs videoFunction 2、S-&amp;gt;C : Window Acknowledgement...
rtmp连接服务器失败(一个低级错误)
weixin_34414650的博客
07-26 5918
由于rtmp底层使用的也是socket ，所以如果想正常使用RTMP_Connect(); 则需要在使用该连接之前先初始化套接字： WORD wVersionRequested; WSADATA wsaData; int err; wVersionRequested = MAKEWORD( 1, 1 ); err = WSAStartup( wVer...
记录Nginx RTMP流媒体服务器遇到的几个坑
沉醉不知归路的博客
11-20 2万+
记录一下最近几天遇到的坑吧，2333 先贴几个参考博客链接： Nginx服务器config：http://blog.csdn.net/defonds/article/details/9274479/ Nginx windows下的环境搭建：http://blog.csdn.net/never715/article/details/74078954#nginx-rtmp环境搭建 还有忘了从那位
Nginx RTMP 功能研究
热门推荐
csallen的专栏
12-26 12万+
Nginx-RTMP功能调研 1. RTMP协议介绍...2 2.RTMP server.3 2.1当前的流媒体server.3 2.2Wowza功能...3 3.Nginx-based RTMP server.5 3.1  Nginx rtmp 功能点...5 3.2编译nginx rtmp模块...6 3.3配置以及功能介绍...6 3.4用nginx-rtmp-module
使用Nginx搭建rtmp流媒体服务器笔记
fulinux的博客
05-20 1万+
平台软硬件环境：PC，ubunut 16.04主要是做个记录，方便日后查询。主要是参考这篇博客：http://www.jianshu.com/p/f0bf83ca3ea3碰到的第一个问题：error: ‘OPENSSL_config’ is deprecated [-Werror=deprecated-declarations]一开始以为Ubuntu安装了openssl和libssl-dev就可以
Nginx+nginx-rtmp-module+FFmpeg：构建全面流媒体服务器指南
总结起来，使用nginx、nginx-rtmp-module和FFmpeg搭建流媒体服务器的关键在于：Nginx提供基本的服务器架构和连接管理，nginx-rtmp-module扩展了其对实时流的支持，而FFmpeg负责实际的编码和转码操作。通过精心配置，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值