735 lines
20 KiB
C
735 lines
20 KiB
C
|
/*
|
||
|
|
* Copyright (C) AlexWoo(Wu Jie) wj19840501@gmail.com
|
||
|
|
*/
|
||
|
|
|
||
|
|
|
||
|
|
#include <ngx_config.h>
|
||
|
|
#include <ngx_core.h>
|
||
|
|
#include "ngx_rtmp.h"
|
||
|
|
#include "ngx_rtmp_codec_module.h"
|
||
|
|
#include "ngx_rtmp_live_module.h"
|
||
|
|
|
||
|
|
|
||
|
|
static ngx_rtmp_close_stream_pt next_close_stream;
|
||
|
|
|
||
|
|
|
||
|
|
static void *ngx_rtmp_gop_create_app_conf(ngx_conf_t *cf);
|
||
|
|
static char *ngx_rtmp_gop_merge_app_conf(ngx_conf_t *cf, void *parent,
|
||
|
|
void *child);
|
||
|
|
|
||
|
|
static ngx_int_t ngx_rtmp_gop_postconfiguration(ngx_conf_t *cf);
|
||
|
|
|
||
|
|
#define ngx_rtmp_gop_next(s, pos) ((pos + 1) % s->out_queue)
|
||
|
|
#define ngx_rtmp_gop_prev(s, pos) (pos == 0 ? s->out_queue - 1 : pos - 1)
|
||
|
|
|
||
|
|
typedef struct {
|
||
|
|
/* publisher: head of cache
|
||
|
|
* player: cache send position of publisher's out
|
||
|
|
*/
|
||
|
|
size_t gop_pos;
|
||
|
|
/* tail of cache */
|
||
|
|
size_t gop_last;
|
||
|
|
/* 0 for not send, 1 for sending, 2 for sent */
|
||
|
|
ngx_flag_t send_gop;
|
||
|
|
|
||
|
|
ngx_rtmp_frame_t *keyframe;
|
||
|
|
|
||
|
|
ngx_rtmp_frame_t *aac_header;
|
||
|
|
ngx_rtmp_frame_t *avc_header;
|
||
|
|
|
||
|
|
ngx_rtmp_frame_t *latest_aac_header;
|
||
|
|
ngx_rtmp_frame_t *latest_avc_header;
|
||
|
|
|
||
|
|
ngx_uint_t meta_version;
|
||
|
|
|
||
|
|
uint32_t first_timestamp;
|
||
|
|
|
||
|
|
/* only for publisher, must at last of ngx_rtmp_gop_ctx_t */
|
||
|
|
ngx_rtmp_frame_t *cache[];
|
||
|
|
} ngx_rtmp_gop_ctx_t;
|
||
|
|
|
||
|
|
typedef struct {
|
||
|
|
ngx_msec_t cache_time;
|
||
|
|
ngx_flag_t low_latency;
|
||
|
|
ngx_flag_t send_all;
|
||
|
|
ngx_msec_t fix_timestamp;
|
||
|
|
ngx_flag_t zero_start;
|
||
|
|
} ngx_rtmp_gop_app_conf_t;
|
||
|
|
|
||
|
|
|
||
|
|
static ngx_command_t ngx_rtmp_gop_commands[] = {
|
||
|
|
|
||
|
|
{ ngx_string("cache_time"),
|
||
|
|
NGX_RTMP_MAIN_CONF|NGX_RTMP_SRV_CONF|NGX_RTMP_APP_CONF|NGX_CONF_TAKE1,
|
||
|
|
ngx_conf_set_msec_slot,
|
||
|
|
NGX_RTMP_APP_CONF_OFFSET,
|
||
|
|
offsetof(ngx_rtmp_gop_app_conf_t, cache_time),
|
||
|
|
NULL },
|
||
|
|
|
||
|
|
{ ngx_string("low_latency"),
|
||
|
|
NGX_RTMP_MAIN_CONF|NGX_RTMP_SRV_CONF|NGX_RTMP_APP_CONF|NGX_CONF_TAKE1,
|
||
|
|
ngx_conf_set_flag_slot,
|
||
|
|
NGX_RTMP_APP_CONF_OFFSET,
|
||
|
|
offsetof(ngx_rtmp_gop_app_conf_t, low_latency),
|
||
|
|
NULL },
|
||
|
|
|
||
|
|
{ ngx_string("send_all"),
|
||
|
|
NGX_RTMP_MAIN_CONF|NGX_RTMP_SRV_CONF|NGX_RTMP_APP_CONF|NGX_CONF_TAKE1,
|
||
|
|
ngx_conf_set_flag_slot,
|
||
|
|
NGX_RTMP_APP_CONF_OFFSET,
|
||
|
|
offsetof(ngx_rtmp_gop_app_conf_t, send_all),
|
||
|
|
NULL },
|
||
|
|
|
||
|
|
{ ngx_string("fix_timestamp"),
|
||
|
|
NGX_RTMP_MAIN_CONF|NGX_RTMP_SRV_CONF|NGX_RTMP_APP_CONF|NGX_CONF_TAKE1,
|
||
|
|
ngx_conf_set_msec_slot,
|
||
|
|
NGX_RTMP_APP_CONF_OFFSET,
|
||
|
|
offsetof(ngx_rtmp_gop_app_conf_t, fix_timestamp),
|
||
|
|
NULL },
|
||
|
|
|
||
|
|
{ ngx_string("zero_start"),
|
||
|
|
NGX_RTMP_MAIN_CONF|NGX_RTMP_SRV_CONF|NGX_RTMP_APP_CONF|NGX_CONF_TAKE1,
|
||
|
|
ngx_conf_set_flag_slot,
|
||
|
|
NGX_RTMP_APP_CONF_OFFSET,
|
||
|
|
offsetof(ngx_rtmp_gop_app_conf_t, zero_start),
|
||
|
|
NULL },
|
||
|
|
ngx_null_command
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
static ngx_rtmp_module_t ngx_rtmp_gop_module_ctx = {
|
||
|
|
NULL, /* preconfiguration */
|
||
|
|
ngx_rtmp_gop_postconfiguration, /* postconfiguration */
|
||
|
|
NULL, /* create main configuration */
|
||
|
|
NULL, /* init main configuration */
|
||
|
|
NULL, /* create server configuration */
|
||
|
|
NULL, /* merge server configuration */
|
||
|
|
ngx_rtmp_gop_create_app_conf, /* create app configuration */
|
||
|
|
ngx_rtmp_gop_merge_app_conf /* merge app configuration */
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
ngx_module_t ngx_rtmp_gop_module = {
|
||
|
|
NGX_MODULE_V1,
|
||
|
|
&ngx_rtmp_gop_module_ctx, /* module context */
|
||
|
|
ngx_rtmp_gop_commands, /* module directives */
|
||
|
|
NGX_RTMP_MODULE, /* module type */
|
||
|
|
NULL, /* init master */
|
||
|
|
NULL, /* init module */
|
||
|
|
NULL, /* init process */
|
||
|
|
NULL, /* init thread */
|
||
|
|
NULL, /* exit thread */
|
||
|
|
NULL, /* exit process */
|
||
|
|
NULL, /* exit master */
|
||
|
|
NGX_MODULE_V1_PADDING
|
||
|
|
};
|
||
|
|
|
||
|
|
|
||
|
|
static void *
|
||
|
|
ngx_rtmp_gop_create_app_conf(ngx_conf_t *cf)
|
||
|
|
{
|
||
|
|
ngx_rtmp_gop_app_conf_t *gacf;
|
||
|
|
|
||
|
|
gacf = ngx_pcalloc(cf->pool, sizeof(ngx_rtmp_gop_app_conf_t));
|
||
|
|
if (gacf == NULL) {
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
gacf->cache_time = NGX_CONF_UNSET_MSEC;
|
||
|
|
gacf->low_latency = NGX_CONF_UNSET;
|
||
|
|
gacf->send_all = NGX_CONF_UNSET;
|
||
|
|
gacf->fix_timestamp = NGX_CONF_UNSET_MSEC;
|
||
|
|
gacf->zero_start = NGX_CONF_UNSET;
|
||
|
|
|
||
|
|
return gacf;
|
||
|
|
}
|
||
|
|
|
||
|
|
static char *
|
||
|
|
ngx_rtmp_gop_merge_app_conf(ngx_conf_t *cf, void *parent, void *child)
|
||
|
|
{
|
||
|
|
ngx_rtmp_gop_app_conf_t *prev = parent;
|
||
|
|
ngx_rtmp_gop_app_conf_t *conf = child;
|
||
|
|
|
||
|
|
ngx_conf_merge_msec_value(conf->cache_time, prev->cache_time, 0);
|
||
|
|
ngx_conf_merge_value(conf->low_latency, prev->low_latency, 0);
|
||
|
|
ngx_conf_merge_value(conf->send_all, prev->send_all, 0);
|
||
|
|
ngx_conf_merge_msec_value(conf->fix_timestamp, prev->fix_timestamp, 10000);
|
||
|
|
ngx_conf_merge_value(conf->zero_start, prev->zero_start, 0);
|
||
|
|
|
||
|
|
return NGX_CONF_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
static ngx_int_t
|
||
|
|
ngx_rtmp_gop_link_frame(ngx_rtmp_session_t *s, ngx_rtmp_frame_t *frame)
|
||
|
|
{
|
||
|
|
ngx_uint_t nmsg;
|
||
|
|
ngx_rtmp_live_chunk_stream_t *cs;
|
||
|
|
ngx_uint_t csidx;
|
||
|
|
ngx_rtmp_live_ctx_t *lctx;
|
||
|
|
ngx_rtmp_gop_ctx_t *ctx;
|
||
|
|
uint32_t delta;
|
||
|
|
ngx_rtmp_gop_app_conf_t *gacf;
|
||
|
|
|
||
|
|
if (frame == NULL) {
|
||
|
|
return NGX_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
gacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_gop_module);
|
||
|
|
if (gacf->fix_timestamp) {
|
||
|
|
lctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_live_module);
|
||
|
|
csidx = !(frame->hdr.type == NGX_RTMP_MSG_VIDEO);
|
||
|
|
|
||
|
|
cs = &lctx->cs[csidx];
|
||
|
|
|
||
|
|
delta = frame->hdr.timestamp > cs->last_timestamp ?
|
||
|
|
frame->hdr.timestamp - cs->last_timestamp :
|
||
|
|
cs->last_timestamp - frame->hdr.timestamp;
|
||
|
|
|
||
|
|
if (delta > gacf->fix_timestamp) {
|
||
|
|
delta = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!gacf->zero_start && cs->timestamp == 0) {
|
||
|
|
cs->timestamp = frame->hdr.timestamp;
|
||
|
|
} else if (frame->hdr.timestamp > cs->last_timestamp) {
|
||
|
|
cs->timestamp += delta;
|
||
|
|
} else if (cs->timestamp >= delta) {
|
||
|
|
cs->timestamp -= delta;
|
||
|
|
}
|
||
|
|
|
||
|
|
cs->last_timestamp = frame->hdr.timestamp;
|
||
|
|
|
||
|
|
ngx_log_error(NGX_LOG_DEBUG, s->log, 0,
|
||
|
|
"gop: link_frame| type %d, delta %d,"
|
||
|
|
" timestamp %uD, fixed timestamp %uD",
|
||
|
|
frame->hdr.type, delta, frame->hdr.timestamp, cs->timestamp);
|
||
|
|
|
||
|
|
frame->hdr.timestamp = cs->timestamp;
|
||
|
|
if (frame->hdr.type == NGX_RTMP_MSG_AMF_META) {
|
||
|
|
frame->hdr.timestamp = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
nmsg = (s->out_last - s->out_pos) % s->out_queue + 1;
|
||
|
|
|
||
|
|
if (nmsg >= s->out_queue) {
|
||
|
|
ngx_log_error(NGX_LOG_ERR, s->log, 0,
|
||
|
|
"link frame nmsg(%ui) >= out_queue(%O)", nmsg, s->out_queue);
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
|
||
|
|
ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_gop_module);
|
||
|
|
|
||
|
|
if (frame->hdr.type == NGX_RTMP_MSG_AUDIO && frame->av_header) {
|
||
|
|
ctx->latest_aac_header = frame;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (frame->hdr.type == NGX_RTMP_MSG_VIDEO && frame->av_header) {
|
||
|
|
ctx->latest_avc_header = frame;
|
||
|
|
}
|
||
|
|
|
||
|
|
s->out[s->out_last] = frame;
|
||
|
|
s->out_last = ngx_rtmp_gop_next(s, s->out_last);
|
||
|
|
|
||
|
|
ngx_rtmp_shared_acquire_frame(frame);
|
||
|
|
|
||
|
|
return NGX_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
ngx_rtmp_gop_set_avframe_tag(ngx_rtmp_frame_t *frame)
|
||
|
|
{
|
||
|
|
ngx_chain_t *cl;
|
||
|
|
|
||
|
|
if (frame->hdr.type != NGX_RTMP_MSG_AUDIO &&
|
||
|
|
frame->hdr.type != NGX_RTMP_MSG_VIDEO)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
cl = frame->chain;
|
||
|
|
|
||
|
|
frame->av_header = ngx_rtmp_is_codec_header(cl);
|
||
|
|
frame->keyframe = (frame->hdr.type == NGX_RTMP_MSG_VIDEO)
|
||
|
|
? (ngx_rtmp_get_video_frame_type(cl) == NGX_RTMP_VIDEO_KEY_FRAME)
|
||
|
|
: 0;
|
||
|
|
|
||
|
|
if (frame->av_header) {
|
||
|
|
frame->mandatory = 1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
ngx_rtmp_gop_reset_avheader(ngx_rtmp_gop_ctx_t *ctx,
|
||
|
|
ngx_rtmp_frame_t *frame)
|
||
|
|
{
|
||
|
|
if (frame->hdr.type == NGX_RTMP_MSG_AUDIO) {
|
||
|
|
if (ctx->aac_header) {
|
||
|
|
ngx_rtmp_shared_free_frame(ctx->aac_header);
|
||
|
|
}
|
||
|
|
ctx->aac_header = frame;
|
||
|
|
} else {
|
||
|
|
if (ctx->avc_header) {
|
||
|
|
ngx_rtmp_shared_free_frame(ctx->avc_header);
|
||
|
|
}
|
||
|
|
ctx->avc_header = frame;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
ngx_rtmp_gop_reset_gop(ngx_rtmp_session_t *s, ngx_rtmp_gop_ctx_t *ctx,
|
||
|
|
ngx_rtmp_frame_t *frame)
|
||
|
|
{
|
||
|
|
ngx_rtmp_gop_app_conf_t *gacf;
|
||
|
|
ngx_rtmp_frame_t *f, *next_keyframe;
|
||
|
|
size_t pos;
|
||
|
|
ngx_uint_t nmsg;
|
||
|
|
|
||
|
|
/* reset av_header at the front of cache */
|
||
|
|
for (pos = ctx->gop_pos; pos != ctx->gop_last;
|
||
|
|
pos = ngx_rtmp_gop_next(s, pos))
|
||
|
|
{
|
||
|
|
if (ctx->cache[pos]->av_header) {
|
||
|
|
ngx_rtmp_gop_reset_avheader(ctx, ctx->cache[pos]);
|
||
|
|
ctx->gop_pos = ngx_rtmp_gop_next(s, ctx->gop_pos);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
f = ctx->cache[pos];
|
||
|
|
if (f == NULL) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
gacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_gop_module);
|
||
|
|
|
||
|
|
/* only audio in cache */
|
||
|
|
if (ctx->keyframe == NULL) {
|
||
|
|
if (frame->hdr.timestamp - ctx->cache[ctx->gop_pos]->hdr.timestamp
|
||
|
|
> gacf->cache_time)
|
||
|
|
{
|
||
|
|
ngx_rtmp_shared_free_frame(f);
|
||
|
|
ctx->cache[ctx->gop_pos] = NULL;
|
||
|
|
ctx->gop_pos = ngx_rtmp_gop_next(s, ctx->gop_pos);
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* only video of video + audio */
|
||
|
|
next_keyframe = ctx->keyframe->next;
|
||
|
|
|
||
|
|
/* only one gop in cache */
|
||
|
|
if (next_keyframe == NULL) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
nmsg = (ctx->gop_last - ctx->gop_pos) % s->out_queue + 2;
|
||
|
|
if (nmsg >= s->out_queue) {
|
||
|
|
goto reset;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (frame->hdr.type == NGX_RTMP_MSG_AUDIO) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (frame->hdr.type == NGX_RTMP_MSG_VIDEO && frame->hdr.timestamp
|
||
|
|
- next_keyframe->hdr.timestamp < gacf->cache_time)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
reset:
|
||
|
|
for (pos = ctx->gop_pos; ctx->cache[pos] != next_keyframe;
|
||
|
|
pos = ngx_rtmp_gop_next(s, pos))
|
||
|
|
{
|
||
|
|
f = ctx->cache[pos];
|
||
|
|
|
||
|
|
if (f->av_header) {
|
||
|
|
ngx_rtmp_gop_reset_avheader(ctx, f);
|
||
|
|
} else {
|
||
|
|
ngx_rtmp_shared_free_frame(f);
|
||
|
|
}
|
||
|
|
|
||
|
|
ctx->cache[pos] = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
ctx->keyframe = next_keyframe;
|
||
|
|
ctx->gop_pos = pos;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
ngx_rtmp_gop_print_cache(ngx_rtmp_session_t *s, ngx_rtmp_gop_ctx_t *ctx)
|
||
|
|
{
|
||
|
|
#if (NGX_DEBUG)
|
||
|
|
ngx_rtmp_frame_t *frame;
|
||
|
|
u_char content[10240], *p;
|
||
|
|
size_t pos;
|
||
|
|
|
||
|
|
ngx_memzero(content, sizeof(content));
|
||
|
|
|
||
|
|
p = content;
|
||
|
|
for (pos = ctx->gop_pos; pos != ctx->gop_last;
|
||
|
|
pos = ngx_rtmp_gop_next(s, pos))
|
||
|
|
{
|
||
|
|
frame = ctx->cache[pos];
|
||
|
|
switch (frame->hdr.type) {
|
||
|
|
case NGX_RTMP_MSG_AUDIO:
|
||
|
|
*p++ = 'A';
|
||
|
|
break;
|
||
|
|
case NGX_RTMP_MSG_VIDEO:
|
||
|
|
*p++ = 'V';
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
*p++ = 'O';
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (frame->keyframe) {
|
||
|
|
*p++ = 'I';
|
||
|
|
}
|
||
|
|
|
||
|
|
if (frame->av_header) {
|
||
|
|
*p++ = 'H';
|
||
|
|
}
|
||
|
|
|
||
|
|
*p++ = ' ';
|
||
|
|
}
|
||
|
|
|
||
|
|
ngx_log_debug5(NGX_LOG_DEBUG_RTMP, s->log, 0,
|
||
|
|
"[%z %z] [%p %p] %s", ctx->gop_pos, ctx->gop_last, ctx->aac_header,
|
||
|
|
ctx->avc_header, content);
|
||
|
|
#endif
|
||
|
|
}
|
||
|
|
|
||
|
|
ngx_int_t
|
||
|
|
ngx_rtmp_gop_cache(ngx_rtmp_session_t *s, ngx_rtmp_frame_t *frame)
|
||
|
|
{
|
||
|
|
ngx_rtmp_gop_app_conf_t *gacf;
|
||
|
|
ngx_rtmp_gop_ctx_t *ctx;
|
||
|
|
ngx_rtmp_frame_t **keyframe;
|
||
|
|
ngx_uint_t nmsg;
|
||
|
|
|
||
|
|
gacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_gop_module);
|
||
|
|
if (gacf->cache_time == 0) {
|
||
|
|
return NGX_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_gop_module);
|
||
|
|
if (ctx == NULL) {
|
||
|
|
ctx = ngx_pcalloc(s->pool, sizeof(ngx_rtmp_gop_ctx_t)
|
||
|
|
+ s->out_queue * sizeof(ngx_rtmp_frame_t *));
|
||
|
|
if (ctx == NULL) {
|
||
|
|
return NGX_ERROR;
|
||
|
|
}
|
||
|
|
ngx_rtmp_set_ctx(s, ctx, ngx_rtmp_gop_module);
|
||
|
|
}
|
||
|
|
|
||
|
|
nmsg = (ctx->gop_last - ctx->gop_pos) % s->out_queue + 1;
|
||
|
|
if (nmsg >= s->out_queue) {
|
||
|
|
ngx_log_error(NGX_LOG_ERR, s->log, 0,
|
||
|
|
"cache frame nmsg(%ui) >= out_queue(%z)", nmsg, s->out_queue);
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
|
||
|
|
ngx_rtmp_gop_set_avframe_tag(frame);
|
||
|
|
|
||
|
|
ngx_log_debug5(NGX_LOG_DEBUG_RTMP, s->log, 0,
|
||
|
|
"cache frame: %ud[%d %d], %ud, %ud",
|
||
|
|
frame->hdr.type, frame->keyframe, frame->av_header,
|
||
|
|
frame->hdr.timestamp, frame->hdr.mlen);
|
||
|
|
|
||
|
|
if (frame->hdr.type == NGX_RTMP_MSG_AUDIO && frame->av_header) {
|
||
|
|
ctx->latest_aac_header = frame;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (frame->hdr.type == NGX_RTMP_MSG_VIDEO && frame->av_header) {
|
||
|
|
ctx->latest_avc_header = frame;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* first video frame is not intra_frame or video header */
|
||
|
|
if (ctx->keyframe == NULL && frame->hdr.type == NGX_RTMP_MSG_VIDEO
|
||
|
|
&& !frame->keyframe && !frame->av_header)
|
||
|
|
{
|
||
|
|
return NGX_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* video intra_frame */
|
||
|
|
if (frame->keyframe && !frame->av_header) {
|
||
|
|
for (keyframe = &ctx->keyframe; *keyframe;
|
||
|
|
keyframe = &((*keyframe)->next));
|
||
|
|
*keyframe = frame;
|
||
|
|
}
|
||
|
|
|
||
|
|
ctx->cache[ctx->gop_last] = frame;
|
||
|
|
ctx->gop_last = ngx_rtmp_gop_next(s, ctx->gop_last);
|
||
|
|
|
||
|
|
ngx_rtmp_shared_acquire_frame(frame);
|
||
|
|
|
||
|
|
ngx_rtmp_gop_reset_gop(s, ctx, frame);
|
||
|
|
|
||
|
|
ngx_rtmp_gop_print_cache(s, ctx);
|
||
|
|
|
||
|
|
return NGX_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
static ngx_int_t
|
||
|
|
ngx_rtmp_gop_send_meta(ngx_rtmp_session_t *s, ngx_rtmp_session_t *ss)
|
||
|
|
{
|
||
|
|
ngx_rtmp_gop_ctx_t *ssctx;
|
||
|
|
ngx_rtmp_codec_ctx_t *cctx;
|
||
|
|
|
||
|
|
ssctx = ngx_rtmp_get_module_ctx(ss, ngx_rtmp_gop_module);
|
||
|
|
cctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_codec_module);
|
||
|
|
|
||
|
|
/* meta */
|
||
|
|
if (ssctx->meta_version != cctx->meta_version
|
||
|
|
&& ngx_rtmp_gop_link_frame(ss, cctx->meta) == NGX_AGAIN)
|
||
|
|
{
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
ssctx->meta_version = cctx->meta_version;
|
||
|
|
|
||
|
|
return NGX_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
static ngx_int_t
|
||
|
|
ngx_rtmp_gop_send_gop(ngx_rtmp_session_t *s, ngx_rtmp_session_t *ss)
|
||
|
|
{
|
||
|
|
ngx_rtmp_gop_app_conf_t *gacf;
|
||
|
|
ngx_rtmp_gop_ctx_t *sctx, *ssctx;
|
||
|
|
ngx_rtmp_frame_t *frame;
|
||
|
|
size_t pos;
|
||
|
|
|
||
|
|
gacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_gop_module);
|
||
|
|
|
||
|
|
sctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_gop_module);
|
||
|
|
ssctx = ngx_rtmp_get_module_ctx(ss, ngx_rtmp_gop_module);
|
||
|
|
|
||
|
|
/* already send gop */
|
||
|
|
if (ssctx->send_gop == 3) {
|
||
|
|
return NGX_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ssctx->send_gop == 0) {
|
||
|
|
if (ngx_rtmp_gop_send_meta(s, ss) == NGX_AGAIN) {
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
|
||
|
|
ngx_rtmp_send_message(ss, NULL, 0);
|
||
|
|
|
||
|
|
ssctx->send_gop = 1;
|
||
|
|
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* link frame in s to ss */
|
||
|
|
if (ssctx->send_gop == 1) {
|
||
|
|
ssctx->gop_pos = sctx->gop_pos;
|
||
|
|
if (sctx->cache[ssctx->gop_pos] == NULL) {
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (sctx->aac_header) {
|
||
|
|
if (ngx_rtmp_gop_link_frame(ss, sctx->aac_header) == NGX_AGAIN) {
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (sctx->avc_header) {
|
||
|
|
if (ngx_rtmp_gop_link_frame(ss, sctx->avc_header) == NGX_AGAIN) {
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ssctx->send_gop = 2;
|
||
|
|
ssctx->first_timestamp = sctx->cache[ssctx->gop_pos]->hdr.timestamp;
|
||
|
|
} else {
|
||
|
|
if (sctx->cache[ssctx->gop_pos] == NULL) {
|
||
|
|
ssctx->gop_pos = sctx->gop_pos;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pos = ssctx->gop_pos;
|
||
|
|
frame = sctx->cache[pos];
|
||
|
|
while (frame) {
|
||
|
|
if (!gacf->send_all &&
|
||
|
|
frame->hdr.timestamp - ssctx->first_timestamp >= gacf->cache_time)
|
||
|
|
{
|
||
|
|
ssctx->send_gop = 3;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ngx_rtmp_gop_link_frame(ss, frame) == NGX_AGAIN) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
pos = ngx_rtmp_gop_next(s, pos);
|
||
|
|
frame = sctx->cache[pos];
|
||
|
|
}
|
||
|
|
|
||
|
|
if (frame == NULL) { /* send all frame in cache */
|
||
|
|
ssctx->send_gop = 3;
|
||
|
|
}
|
||
|
|
|
||
|
|
ssctx->gop_pos = pos;
|
||
|
|
ngx_rtmp_send_message(ss, NULL, 0);
|
||
|
|
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
|
||
|
|
ngx_int_t
|
||
|
|
ngx_rtmp_gop_send(ngx_rtmp_session_t *s, ngx_rtmp_session_t *ss)
|
||
|
|
{
|
||
|
|
ngx_rtmp_gop_app_conf_t *gacf;
|
||
|
|
ngx_rtmp_gop_ctx_t *sctx, *ssctx;
|
||
|
|
ngx_rtmp_frame_t *frame;
|
||
|
|
size_t pos;
|
||
|
|
|
||
|
|
gacf = ngx_rtmp_get_module_app_conf(s, ngx_rtmp_gop_module);
|
||
|
|
if (gacf->cache_time == 0) {
|
||
|
|
return NGX_DECLINED;
|
||
|
|
}
|
||
|
|
|
||
|
|
sctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_gop_module);
|
||
|
|
if (sctx == NULL) { /* publisher doesn't publish av frame */
|
||
|
|
return NGX_DECLINED;
|
||
|
|
}
|
||
|
|
|
||
|
|
ssctx = ngx_rtmp_get_module_ctx(ss, ngx_rtmp_gop_module);
|
||
|
|
if (ssctx == NULL) {
|
||
|
|
ssctx = ngx_pcalloc(ss->pool, sizeof(ngx_rtmp_gop_ctx_t));
|
||
|
|
if (ssctx == NULL) {
|
||
|
|
return NGX_ERROR;
|
||
|
|
}
|
||
|
|
ngx_rtmp_set_ctx(ss, ssctx, ngx_rtmp_gop_module);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ngx_rtmp_gop_send_gop(s, ss) == NGX_AGAIN) {
|
||
|
|
return NGX_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
/* send frame by frame */
|
||
|
|
if (ngx_rtmp_gop_send_meta(s, ss) == NGX_AGAIN) {
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
|
||
|
|
pos = ngx_rtmp_gop_prev(s, sctx->gop_last);
|
||
|
|
/* new frame is video key frame */
|
||
|
|
if (sctx->cache[pos]->keyframe && !sctx->cache[pos]->av_header) {
|
||
|
|
if (gacf->low_latency && pos != ssctx->gop_pos) {
|
||
|
|
ssctx->gop_pos = pos;
|
||
|
|
|
||
|
|
ss->out_pos = ss->out_last;
|
||
|
|
|
||
|
|
ngx_log_error(NGX_LOG_INFO, ss->log, 0,
|
||
|
|
"gop, low latency, chase to new keyframe");
|
||
|
|
|
||
|
|
if (sctx->latest_aac_header
|
||
|
|
&& sctx->latest_aac_header != ssctx->latest_aac_header)
|
||
|
|
{
|
||
|
|
if (ngx_rtmp_gop_link_frame(ss, sctx->latest_aac_header)
|
||
|
|
== NGX_AGAIN)
|
||
|
|
{
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (sctx->latest_avc_header
|
||
|
|
&& sctx->latest_avc_header != ssctx->latest_avc_header)
|
||
|
|
{
|
||
|
|
if (ngx_rtmp_gop_link_frame(ss, sctx->latest_avc_header)
|
||
|
|
== NGX_AGAIN)
|
||
|
|
{
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
if (sctx->cache[ssctx->gop_pos] == NULL) {
|
||
|
|
ngx_log_error(NGX_LOG_ERR, ss->log, 0,
|
||
|
|
"gop, current gop pos is NULL, "
|
||
|
|
"skip to new postion [pos %d last %d] %d",
|
||
|
|
sctx->gop_pos, sctx->gop_last, ssctx->gop_pos);
|
||
|
|
|
||
|
|
if (sctx->aac_header
|
||
|
|
&& sctx->aac_header != ssctx->latest_aac_header)
|
||
|
|
{
|
||
|
|
if (ngx_rtmp_gop_link_frame(ss, sctx->aac_header)
|
||
|
|
== NGX_AGAIN)
|
||
|
|
{
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (sctx->avc_header
|
||
|
|
&& sctx->avc_header != ssctx->latest_avc_header)
|
||
|
|
{
|
||
|
|
if (ngx_rtmp_gop_link_frame(ss, sctx->avc_header)
|
||
|
|
== NGX_AGAIN)
|
||
|
|
{
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
ssctx->gop_pos = sctx->gop_pos;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
frame = sctx->cache[ssctx->gop_pos];
|
||
|
|
if (ngx_rtmp_gop_link_frame(ss, frame) == NGX_AGAIN) {
|
||
|
|
return NGX_AGAIN;
|
||
|
|
}
|
||
|
|
|
||
|
|
ssctx->gop_pos = ngx_rtmp_gop_next(s, ssctx->gop_pos);
|
||
|
|
ngx_rtmp_send_message(ss, NULL, 0);
|
||
|
|
|
||
|
|
return NGX_OK;
|
||
|
|
}
|
||
|
|
|
||
|
|
static ngx_int_t
|
||
|
|
ngx_rtmp_gop_close_stream(ngx_rtmp_session_t *s, ngx_rtmp_close_stream_t *v)
|
||
|
|
{
|
||
|
|
ngx_rtmp_gop_ctx_t *ctx;
|
||
|
|
ngx_rtmp_live_ctx_t *lctx;
|
||
|
|
|
||
|
|
ctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_gop_module);
|
||
|
|
if (ctx == NULL) {
|
||
|
|
goto next;
|
||
|
|
}
|
||
|
|
|
||
|
|
lctx = ngx_rtmp_get_module_ctx(s, ngx_rtmp_live_module);
|
||
|
|
|
||
|
|
if (!lctx->publishing) {
|
||
|
|
goto next;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ctx->avc_header) {
|
||
|
|
ngx_rtmp_shared_free_frame(ctx->avc_header);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ctx->aac_header) {
|
||
|
|
ngx_rtmp_shared_free_frame(ctx->aac_header);
|
||
|
|
}
|
||
|
|
|
||
|
|
/* free cache in publisher */
|
||
|
|
while (ctx->gop_pos != ctx->gop_last) {
|
||
|
|
ngx_rtmp_shared_free_frame(ctx->cache[ctx->gop_pos]);
|
||
|
|
ctx->gop_pos = ngx_rtmp_gop_next(s, ctx->gop_pos);
|
||
|
|
}
|
||
|
|
|
||
|
|
next:
|
||
|
|
return next_close_stream(s, v);
|
||
|
|
}
|
||
|
|
|
||
|
|
static ngx_int_t
|
||
|
|
ngx_rtmp_gop_postconfiguration(ngx_conf_t *cf)
|
||
|
|
{
|
||
|
|
next_close_stream = ngx_rtmp_close_stream;
|
||
|
|
ngx_rtmp_close_stream = ngx_rtmp_gop_close_stream;
|
||
|
|
|
||
|
|
return NGX_OK;
|
||
|
|
}
|