falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

Merge remote-tracking branch 'qatar/master' 

* qatar/master:
  librtmp: return AVERROR_UNKNOWN instead of -1.
  librtmp: don't abuse a variable for two unrelated things.
  librtmp: add rtmp_app and rtmp_playpath private options.
  bmv: add stricter checks for invalid decoded length
  avpacket: fix duplicating side data.
  flv: support stream text data as onTextData

Conflicts:
	libavcodec/bmv.c
	libavformat/flvdec.c
	libavformat/flvenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
tags/n1.0
Michael Niedermayer 13 years ago
parent
e10eac910a 19dfbf1915
commit
7d82020fcb
5 changed files with 252 additions and 74 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +1
    -1
      libavcodec/avpacket.c
  2. +8
    -4
      libavcodec/bmv.c
  3. +92
    -26
      libavformat/flvdec.c
  4. +60
    -17
      libavformat/flvenc.c
  5. +91
    -26
      libavformat/librtmp.c

+ 1
- 1
libavcodec/avpacket.c View File

@@ -152,7 +152,7 @@ int av_dup_packet(AVPacket *pkt)
pkt->side_data_elems * sizeof(*pkt->side_data)); pkt->side_data_elems * sizeof(*pkt->side_data));
for (i = 0; i < pkt->side_data_elems; i++) for (i = 0; i < pkt->side_data_elems; i++)
DUP_DATA(pkt->side_data[i].data, tmp_pkt.side_data[i].data, DUP_DATA(pkt->side_data[i].data, tmp_pkt.side_data[i].data,
pkt->side_data[i].size, 1);
tmp_pkt.side_data[i].size, 1);
} }
} }
return 0; return 0;


+ 8
- 4
libavcodec/bmv.c View File

@@ -143,16 +143,20 @@ static int decode_bmv_frame(const uint8_t *source, int src_len, uint8_t *frame,
switch (mode) { switch (mode) {
case 1: case 1:
if (forward) { if (forward) {
if (dst - frame + SCREEN_WIDE < -frame_off ||
frame_end - dst < frame_off + len)
if (dst - frame + SCREEN_WIDE < frame_off ||
dst - frame + SCREEN_WIDE + frame_off < 0 ||
frame_end - dst < frame_off + len ||
frame_end - dst < len)
return -1; return -1;
for (i = 0; i < len; i++) for (i = 0; i < len; i++)
dst[i] = dst[frame_off + i]; dst[i] = dst[frame_off + i];
dst += len; dst += len;
} else { } else {
dst -= len; dst -= len;
if (dst - frame + SCREEN_WIDE < -frame_off ||
frame_end - dst < frame_off + len)
if (dst - frame + SCREEN_WIDE < frame_off ||
dst - frame + SCREEN_WIDE + frame_off < 0 ||
frame_end - dst < frame_off + len ||
frame_end - dst < len)
return -1; return -1;
for (i = len - 1; i >= 0; i--) for (i = len - 1; i >= 0; i--)
dst[i] = dst[frame_off + i]; dst[i] = dst[frame_off + i];


+ 92
- 26
libavformat/flvdec.c View File

@@ -62,6 +62,21 @@ static int flv_probe(AVProbeData *p)
return 0; return 0;
} }


static AVStream *create_stream(AVFormatContext *s, int tag, int codec_type){
AVStream *st = avformat_new_stream(s, NULL);
if (!st)
return NULL;
st->id = tag;
st->codec->codec_type = codec_type;
if(s->nb_streams>=3 ||( s->nb_streams==2
&& s->streams[0]->codec->codec_type != AVMEDIA_TYPE_DATA
&& s->streams[1]->codec->codec_type != AVMEDIA_TYPE_DATA))
s->ctx_flags &= ~AVFMTCTX_NOHEADER;

avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
return st;
}

static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream, AVCodecContext *acodec, int flv_codecid) { static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream, AVCodecContext *acodec, int flv_codecid) {
switch(flv_codecid) { switch(flv_codecid) {
//no distinction between S16 and S8 PCM codec flags //no distinction between S16 and S8 PCM codec flags
@@ -298,6 +313,12 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst
vcodec->bit_rate = num_val * 1024.0; vcodec->bit_rate = num_val * 1024.0;
else if (!strcmp(key, "audiodatarate") && acodec && 0 <= (int)(num_val * 1024.0)) else if (!strcmp(key, "audiodatarate") && acodec && 0 <= (int)(num_val * 1024.0))
acodec->bit_rate = num_val * 1024.0; acodec->bit_rate = num_val * 1024.0;
else if (!strcmp(key, "datastream")) {
AVStream *st = create_stream(s, 2, AVMEDIA_TYPE_DATA);
if (!st)
return AVERROR(ENOMEM);
st->codec->codec_id = CODEC_ID_TEXT;
}
} }


if (amf_type == AMF_DATA_TYPE_OBJECT && s->nb_streams == 1 && if (amf_type == AMF_DATA_TYPE_OBJECT && s->nb_streams == 1 &&
@@ -344,7 +365,14 @@ static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) {


//first object needs to be "onMetaData" string //first object needs to be "onMetaData" string
type = avio_r8(ioc); type = avio_r8(ioc);
if(type != AMF_DATA_TYPE_STRING || amf_get_string(ioc, buffer, sizeof(buffer)) < 0 || strcmp(buffer, "onMetaData"))
if (type != AMF_DATA_TYPE_STRING ||
amf_get_string(ioc, buffer, sizeof(buffer)) < 0)
return -1;

if (!strcmp(buffer, "onTextData"))
return 1;

if (strcmp(buffer, "onMetaData"))
return -1; return -1;


//find the streams now so that amf_parse_object doesn't need to do the lookup every time it is called. //find the streams now so that amf_parse_object doesn't need to do the lookup every time it is called.
@@ -362,28 +390,6 @@ static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) {
return 0; return 0;
} }


static AVStream *create_stream(AVFormatContext *s, int stream_type){
AVStream *st = avformat_new_stream(s, NULL);
if (!st)
return NULL;
st->id = stream_type;
switch(stream_type) {
case FLV_STREAM_TYPE_VIDEO: st->codec->codec_type = AVMEDIA_TYPE_VIDEO; break;
case FLV_STREAM_TYPE_AUDIO: st->codec->codec_type = AVMEDIA_TYPE_AUDIO; break;
case FLV_STREAM_TYPE_DATA:
st->codec->codec_type = AVMEDIA_TYPE_DATA;
st->codec->codec_id = CODEC_ID_NONE; // Going to rely on copy for now
av_log(s, AV_LOG_DEBUG, "Data stream created\n");
}
if(s->nb_streams>=3 ||( s->nb_streams==2
&& s->streams[0]->codec->codec_type != AVMEDIA_TYPE_DATA
&& s->streams[1]->codec->codec_type != AVMEDIA_TYPE_DATA))
s->ctx_flags &= ~AVFMTCTX_NOHEADER;

avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
return st;
}

static int flv_read_header(AVFormatContext *s) static int flv_read_header(AVFormatContext *s)
{ {
int offset, flags; int offset, flags;
@@ -399,11 +405,11 @@ static int flv_read_header(AVFormatContext *s)
s->ctx_flags |= AVFMTCTX_NOHEADER; s->ctx_flags |= AVFMTCTX_NOHEADER;


if(flags & FLV_HEADER_FLAG_HASVIDEO){ if(flags & FLV_HEADER_FLAG_HASVIDEO){
if(!create_stream(s, FLV_STREAM_TYPE_VIDEO))
if(!create_stream(s, 0, AVMEDIA_TYPE_VIDEO))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
if(flags & FLV_HEADER_FLAG_HASAUDIO){ if(flags & FLV_HEADER_FLAG_HASAUDIO){
if(!create_stream(s, FLV_STREAM_TYPE_AUDIO))
if(!create_stream(s, 1, AVMEDIA_TYPE_AUDIO))
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
} }
// Flag doesn't indicate whether or not there is script-data present. Must // Flag doesn't indicate whether or not there is script-data present. Must
@@ -466,6 +472,65 @@ static void clear_index_entries(AVFormatContext *s, int64_t pos)
} }
} }



static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,
int64_t dts, int64_t next)
{
int ret = AVERROR_INVALIDDATA, i;
AVIOContext *pb = s->pb;
AVStream *st = NULL;
AMFDataType type;
char buf[20];
int length;

type = avio_r8(pb);
if (type == AMF_DATA_TYPE_MIXEDARRAY)
avio_seek(pb, 4, SEEK_CUR);
else if (type != AMF_DATA_TYPE_OBJECT)
goto out;

amf_get_string(pb, buf, sizeof(buf));
if (strcmp(buf, "type") || avio_r8(pb) != AMF_DATA_TYPE_STRING)
goto out;

amf_get_string(pb, buf, sizeof(buf));
//FIXME parse it as codec_id
amf_get_string(pb, buf, sizeof(buf));
if (strcmp(buf, "text") || avio_r8(pb) != AMF_DATA_TYPE_STRING)
goto out;

length = avio_rb16(pb);
ret = av_get_packet(s->pb, pkt, length);
if (ret < 0) {
ret = AVERROR(EIO);
goto out;
}

for (i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
if (st->id == 2)
break;
}

if (i == s->nb_streams) {
st = create_stream(s, 2, AVMEDIA_TYPE_DATA);
if (!st)
goto out;
st->codec->codec_id = CODEC_ID_TEXT;
}

pkt->dts = dts;
pkt->pts = dts;
pkt->size = ret;

pkt->stream_index = st->index;
pkt->flags |= AV_PKT_FLAG_KEY;

avio_seek(s->pb, next + 4, SEEK_SET);
out:
return ret;
}

static int flv_read_packet(AVFormatContext *s, AVPacket *pkt) static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
{ {
FLVContext *flv = s->priv_data; FLVContext *flv = s->priv_data;
@@ -548,7 +613,8 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
} }
if(i == s->nb_streams){ if(i == s->nb_streams){
av_log(s, AV_LOG_WARNING, "Stream discovered after head already parsed\n"); av_log(s, AV_LOG_WARNING, "Stream discovered after head already parsed\n");
st= create_stream(s, stream_type);
st = create_stream(s, stream_type,
(int[]){AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_DATA}[stream_type]);
} }
av_dlog(s, "%d %X %d \n", stream_type, flags, st->discard); av_dlog(s, "%d %X %d \n", stream_type, flags, st->discard);
if( (st->discard >= AVDISCARD_NONKEY && !((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || (stream_type == FLV_STREAM_TYPE_AUDIO))) if( (st->discard >= AVDISCARD_NONKEY && !((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || (stream_type == FLV_STREAM_TYPE_AUDIO)))


+ 60
- 17
libavformat/flvenc.c View File

@@ -182,7 +182,7 @@ static int flv_write_header(AVFormatContext *s)
{ {
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
FLVContext *flv = s->priv_data; FLVContext *flv = s->priv_data;
AVCodecContext *audio_enc = NULL, *video_enc = NULL;
AVCodecContext *audio_enc = NULL, *video_enc = NULL, *data_enc = NULL;
int i, metadata_count = 0; int i, metadata_count = 0;
double framerate = 0.0; double framerate = 0.0;
int64_t metadata_size_pos, data_size, metadata_count_pos; int64_t metadata_size_pos, data_size, metadata_count_pos;
@@ -191,7 +191,8 @@ static int flv_write_header(AVFormatContext *s)
for(i=0; i<s->nb_streams; i++){ for(i=0; i<s->nb_streams; i++){
AVCodecContext *enc = s->streams[i]->codec; AVCodecContext *enc = s->streams[i]->codec;
FLVStreamContext *sc; FLVStreamContext *sc;
if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
switch (enc->codec_type) {
case AVMEDIA_TYPE_VIDEO:
if (s->streams[i]->r_frame_rate.den && s->streams[i]->r_frame_rate.num) { if (s->streams[i]->r_frame_rate.den && s->streams[i]->r_frame_rate.num) {
framerate = av_q2d(s->streams[i]->r_frame_rate); framerate = av_q2d(s->streams[i]->r_frame_rate);
} else { } else {
@@ -202,10 +203,22 @@ static int flv_write_header(AVFormatContext *s)
av_log(s, AV_LOG_ERROR, "video codec not compatible with flv\n"); av_log(s, AV_LOG_ERROR, "video codec not compatible with flv\n");
return -1; return -1;
} }
} else if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
break;
case AVMEDIA_TYPE_AUDIO:
audio_enc = enc; audio_enc = enc;
if (get_audio_flags(s, enc) < 0) if (get_audio_flags(s, enc) < 0)
return -1;
return AVERROR_INVALIDDATA;
break;
case AVMEDIA_TYPE_DATA:
if (enc->codec_id != CODEC_ID_TEXT) {
av_log(s, AV_LOG_ERROR, "codec not compatible with flv\n");
return AVERROR_INVALIDDATA;
}
data_enc = enc;
break;
default:
av_log(s, AV_LOG_ERROR, "codec not compatible with flv\n");
return -1;
} }
avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */ avpriv_set_pts_info(s->streams[i], 32, 1, 1000); /* 32 bit pts in ms */


@@ -251,7 +264,11 @@ static int flv_write_header(AVFormatContext *s)
/* mixed array (hash) with size and string/type/data tuples */ /* mixed array (hash) with size and string/type/data tuples */
avio_w8(pb, AMF_DATA_TYPE_MIXEDARRAY); avio_w8(pb, AMF_DATA_TYPE_MIXEDARRAY);
metadata_count_pos = avio_tell(pb); metadata_count_pos = avio_tell(pb);
metadata_count = 5*!!video_enc + 5*!!audio_enc + 2; // +2 for duration and file size
metadata_count = 5 * !!video_enc +
5 * !!audio_enc +
1 * !!data_enc +
2; // +2 for duration and file size

avio_wb32(pb, metadata_count); avio_wb32(pb, metadata_count);


put_amf_string(pb, "duration"); put_amf_string(pb, "duration");
@@ -292,6 +309,11 @@ static int flv_write_header(AVFormatContext *s)
put_amf_double(pb, audio_enc->codec_tag); put_amf_double(pb, audio_enc->codec_tag);
} }


if (data_enc) {
put_amf_string(pb, "datastream");
put_amf_double(pb, 0.0);
}

while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) { while ((tag = av_dict_get(s->metadata, "", tag, AV_DICT_IGNORE_SUFFIX))) {
if( !strcmp(tag->key, "width") if( !strcmp(tag->key, "width")
||!strcmp(tag->key, "height") ||!strcmp(tag->key, "height")
@@ -416,7 +438,8 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
else else
flags_size= 1; flags_size= 1;


if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
switch (enc->codec_type) {
case AVMEDIA_TYPE_VIDEO:
avio_w8(pb, FLV_TAG_TYPE_VIDEO); avio_w8(pb, FLV_TAG_TYPE_VIDEO);


flags = enc->codec_tag; flags = enc->codec_tag;
@@ -426,20 +449,20 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
} }


flags |= pkt->flags & AV_PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER; flags |= pkt->flags & AV_PKT_FLAG_KEY ? FLV_FRAME_KEY : FLV_FRAME_INTER;
} else if (enc->codec_type == AVMEDIA_TYPE_AUDIO) {
break;
case AVMEDIA_TYPE_AUDIO:
flags = get_audio_flags(s, enc); flags = get_audio_flags(s, enc);


assert(size); assert(size);


avio_w8(pb, FLV_TAG_TYPE_AUDIO); avio_w8(pb, FLV_TAG_TYPE_AUDIO);
} else {
// In-band flv metadata ("scriptdata")
assert(enc->codec_type == AVMEDIA_TYPE_DATA);
break;
case AVMEDIA_TYPE_DATA:
avio_w8(pb, FLV_TAG_TYPE_META); avio_w8(pb, FLV_TAG_TYPE_META);
flags_size = 0;
flags = 0;
break;
default:
return AVERROR(EINVAL);
} }

if (enc->codec_id == CODEC_ID_H264 || enc->codec_id == CODEC_ID_MPEG4) { if (enc->codec_id == CODEC_ID_H264 || enc->codec_id == CODEC_ID_MPEG4) {
/* check if extradata looks like mp4 formated */ /* check if extradata looks like mp4 formated */
if (enc->extradata_size > 0 && *(uint8_t*)enc->extradata != 1) { if (enc->extradata_size > 0 && *(uint8_t*)enc->extradata != 1) {
@@ -476,9 +499,29 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)
avio_w8(pb,(ts >> 24) & 0x7F); // timestamps are 32bits _signed_ avio_w8(pb,(ts >> 24) & 0x7F); // timestamps are 32bits _signed_
avio_wb24(pb,flv->reserved); avio_wb24(pb,flv->reserved);


if(flags_size)
avio_w8(pb,flags);

if (enc->codec_type == AVMEDIA_TYPE_DATA) {
int data_size;
int metadata_size_pos = avio_tell(pb);
avio_w8(pb, AMF_DATA_TYPE_STRING);
put_amf_string(pb, "onTextData");
avio_w8(pb, AMF_DATA_TYPE_MIXEDARRAY);
avio_wb32(pb, 2);
put_amf_string(pb, "type");
avio_w8(pb, AMF_DATA_TYPE_STRING);
put_amf_string(pb, "Text");
put_amf_string(pb, "text");
avio_w8(pb, AMF_DATA_TYPE_STRING);
put_amf_string(pb, pkt->data);
put_amf_string(pb, "");
avio_w8(pb, AMF_END_OF_OBJECT);
/* write total size of tag */
data_size = avio_tell(pb) - metadata_size_pos;
avio_seek(pb, metadata_size_pos - 10, SEEK_SET);
avio_wb24(pb, data_size);
avio_seek(pb, data_size + 10 - 3, SEEK_CUR);
avio_wb32(pb, data_size + 11);
} else {
avio_w8(pb,flags);
if (enc->codec_id == CODEC_ID_VP6) if (enc->codec_id == CODEC_ID_VP6)
avio_w8(pb,0); avio_w8(pb,0);
if (enc->codec_id == CODEC_ID_VP6F || enc->codec_id == CODEC_ID_VP6A) if (enc->codec_id == CODEC_ID_VP6F || enc->codec_id == CODEC_ID_VP6A)
@@ -494,7 +537,7 @@ static int flv_write_packet(AVFormatContext *s, AVPacket *pkt)


avio_wb32(pb,size+flags_size+11); // previous tag size avio_wb32(pb,size+flags_size+11); // previous tag size
flv->duration = FFMAX(flv->duration, pkt->pts + flv->delay + pkt->duration); flv->duration = FFMAX(flv->duration, pkt->pts + flv->delay + pkt->duration);
}
avio_flush(pb); avio_flush(pb);


av_free(data); av_free(data);


+ 91
- 26
libavformat/librtmp.c View File

@@ -24,13 +24,22 @@
* RTMP protocol based on http://rtmpdump.mplayerhq.hu/ librtmp * RTMP protocol based on http://rtmpdump.mplayerhq.hu/ librtmp
*/ */


#include "libavutil/avstring.h"
#include "libavutil/mathematics.h" #include "libavutil/mathematics.h"
#include "libavutil/opt.h"
#include "avformat.h" #include "avformat.h"
#include "url.h" #include "url.h"


#include <librtmp/rtmp.h> #include <librtmp/rtmp.h>
#include <librtmp/log.h> #include <librtmp/log.h>


typedef struct LibRTMPContext {
const AVClass *class;
RTMP rtmp;
char *app;
char *playpath;
} LibRTMPContext;

static void rtmp_log(int level, const char *fmt, va_list args) static void rtmp_log(int level, const char *fmt, va_list args)
{ {
switch (level) { switch (level) {
@@ -49,7 +58,8 @@ static void rtmp_log(int level, const char *fmt, va_list args)


static int rtmp_close(URLContext *s) static int rtmp_close(URLContext *s)
{ {
RTMP *r = s->priv_data;
LibRTMPContext *ctx = s->priv_data;
RTMP *r = &ctx->rtmp;


RTMP_Close(r); RTMP_Close(r);
return 0; return 0;
@@ -69,24 +79,45 @@ static int rtmp_close(URLContext *s)
*/ */
static int rtmp_open(URLContext *s, const char *uri, int flags) static int rtmp_open(URLContext *s, const char *uri, int flags)
{ {
RTMP *r = s->priv_data;
int rc;
LibRTMPContext *ctx = s->priv_data;
RTMP *r = &ctx->rtmp;
int rc = 0, level;
char *filename = s->filename;


switch (av_log_get_level()) { switch (av_log_get_level()) {
default: default:
case AV_LOG_FATAL: rc = RTMP_LOGCRIT; break;
case AV_LOG_ERROR: rc = RTMP_LOGERROR; break;
case AV_LOG_WARNING: rc = RTMP_LOGWARNING; break;
case AV_LOG_INFO: rc = RTMP_LOGINFO; break;
case AV_LOG_VERBOSE: rc = RTMP_LOGDEBUG; break;
case AV_LOG_DEBUG: rc = RTMP_LOGDEBUG2; break;
case AV_LOG_FATAL: level = RTMP_LOGCRIT; break;
case AV_LOG_ERROR: level = RTMP_LOGERROR; break;
case AV_LOG_WARNING: level = RTMP_LOGWARNING; break;
case AV_LOG_INFO: level = RTMP_LOGINFO; break;
case AV_LOG_VERBOSE: level = RTMP_LOGDEBUG; break;
case AV_LOG_DEBUG: level = RTMP_LOGDEBUG2; break;
} }
RTMP_LogSetLevel(rc);
RTMP_LogSetLevel(level);
RTMP_LogSetCallback(rtmp_log); RTMP_LogSetCallback(rtmp_log);


if (ctx->app || ctx->playpath) {
int len = strlen(s->filename) + 1;
if (ctx->app) len += strlen(ctx->app) + sizeof(" app=");
if (ctx->playpath) len += strlen(ctx->playpath) + sizeof(" playpath=");

if (!(filename = av_malloc(len)))
return AVERROR(ENOMEM);

av_strlcpy(filename, s->filename, len);
if (ctx->app) {
av_strlcat(filename, " app=", len);
av_strlcat(filename, ctx->app, len);
}
if (ctx->playpath) {
av_strlcat(filename, " playpath=", len);
av_strlcat(filename, ctx->playpath, len);
}
}

RTMP_Init(r); RTMP_Init(r);
if (!RTMP_SetupURL(r, s->filename)) {
rc = -1;
if (!RTMP_SetupURL(r, filename)) {
rc = AVERROR_UNKNOWN;
goto fail; goto fail;
} }


@@ -94,43 +125,49 @@ static int rtmp_open(URLContext *s, const char *uri, int flags)
RTMP_EnableWrite(r); RTMP_EnableWrite(r);


if (!RTMP_Connect(r, NULL) || !RTMP_ConnectStream(r, 0)) { if (!RTMP_Connect(r, NULL) || !RTMP_ConnectStream(r, 0)) {
rc = -1;
rc = AVERROR_UNKNOWN;
goto fail; goto fail;
} }


s->is_streamed = 1; s->is_streamed = 1;
return 0;
rc = 0;
fail: fail:
if (filename != s->filename)
av_freep(&filename);
return rc; return rc;
} }


static int rtmp_write(URLContext *s, const uint8_t *buf, int size) static int rtmp_write(URLContext *s, const uint8_t *buf, int size)
{ {
RTMP *r = s->priv_data;
LibRTMPContext *ctx = s->priv_data;
RTMP *r = &ctx->rtmp;


return RTMP_Write(r, buf, size); return RTMP_Write(r, buf, size);
} }


static int rtmp_read(URLContext *s, uint8_t *buf, int size) static int rtmp_read(URLContext *s, uint8_t *buf, int size)
{ {
RTMP *r = s->priv_data;
LibRTMPContext *ctx = s->priv_data;
RTMP *r = &ctx->rtmp;


return RTMP_Read(r, buf, size); return RTMP_Read(r, buf, size);
} }


static int rtmp_read_pause(URLContext *s, int pause) static int rtmp_read_pause(URLContext *s, int pause)
{ {
RTMP *r = s->priv_data;
LibRTMPContext *ctx = s->priv_data;
RTMP *r = &ctx->rtmp;


if (!RTMP_Pause(r, pause)) if (!RTMP_Pause(r, pause))
return -1;
return AVERROR_UNKNOWN;
return 0; return 0;
} }


static int64_t rtmp_read_seek(URLContext *s, int stream_index, static int64_t rtmp_read_seek(URLContext *s, int stream_index,
int64_t timestamp, int flags) int64_t timestamp, int flags)
{ {
RTMP *r = s->priv_data;
LibRTMPContext *ctx = s->priv_data;
RTMP *r = &ctx->rtmp;


if (flags & AVSEEK_FLAG_BYTE) if (flags & AVSEEK_FLAG_BYTE)
return AVERROR(ENOSYS); return AVERROR(ENOSYS);
@@ -141,17 +178,36 @@ static int64_t rtmp_read_seek(URLContext *s, int stream_index,
flags & AVSEEK_FLAG_BACKWARD ? AV_ROUND_DOWN : AV_ROUND_UP); flags & AVSEEK_FLAG_BACKWARD ? AV_ROUND_DOWN : AV_ROUND_UP);


if (!RTMP_SendSeek(r, timestamp)) if (!RTMP_SendSeek(r, timestamp))
return -1;
return AVERROR_UNKNOWN;
return timestamp; return timestamp;
} }


static int rtmp_get_file_handle(URLContext *s) static int rtmp_get_file_handle(URLContext *s)
{ {
RTMP *r = s->priv_data;
LibRTMPContext *ctx = s->priv_data;
RTMP *r = &ctx->rtmp;


return RTMP_Socket(r); return RTMP_Socket(r);
} }


#define OFFSET(x) offsetof(LibRTMPContext, x)
#define DEC AV_OPT_FLAG_DECODING_PARAM
#define ENC AV_OPT_FLAG_ENCODING_PARAM
static const AVOption options[] = {
{"rtmp_app", "Name of application to connect to on the RTMP server", OFFSET(app), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
{"rtmp_playpath", "Stream identifier to play or to publish", OFFSET(playpath), AV_OPT_TYPE_STRING, {.str = NULL }, 0, 0, DEC|ENC},
{ NULL },
};

#define RTMP_CLASS(flavor)\
static const AVClass lib ## flavor ## _class = {\
.class_name = "lib" #flavor " protocol",\
.item_name = av_default_item_name,\
.option = options,\
.version = LIBAVUTIL_VERSION_INT,\
};

RTMP_CLASS(rtmp)
URLProtocol ff_librtmp_protocol = { URLProtocol ff_librtmp_protocol = {
.name = "rtmp", .name = "rtmp",
.url_open = rtmp_open, .url_open = rtmp_open,
@@ -161,10 +217,12 @@ URLProtocol ff_librtmp_protocol = {
.url_read_pause = rtmp_read_pause, .url_read_pause = rtmp_read_pause,
.url_read_seek = rtmp_read_seek, .url_read_seek = rtmp_read_seek,
.url_get_file_handle = rtmp_get_file_handle, .url_get_file_handle = rtmp_get_file_handle,
.priv_data_size = sizeof(RTMP),
.priv_data_size = sizeof(LibRTMPContext),
.priv_data_class = &librtmp_class,
.flags = URL_PROTOCOL_FLAG_NETWORK, .flags = URL_PROTOCOL_FLAG_NETWORK,
}; };


RTMP_CLASS(rtmpt)
URLProtocol ff_librtmpt_protocol = { URLProtocol ff_librtmpt_protocol = {
.name = "rtmpt", .name = "rtmpt",
.url_open = rtmp_open, .url_open = rtmp_open,
@@ -174,10 +232,12 @@ URLProtocol ff_librtmpt_protocol = {
.url_read_pause = rtmp_read_pause, .url_read_pause = rtmp_read_pause,
.url_read_seek = rtmp_read_seek, .url_read_seek = rtmp_read_seek,
.url_get_file_handle = rtmp_get_file_handle, .url_get_file_handle = rtmp_get_file_handle,
.priv_data_size = sizeof(RTMP),
.priv_data_size = sizeof(LibRTMPContext),
.priv_data_class = &librtmpt_class,
.flags = URL_PROTOCOL_FLAG_NETWORK, .flags = URL_PROTOCOL_FLAG_NETWORK,
}; };


RTMP_CLASS(rtmpe)
URLProtocol ff_librtmpe_protocol = { URLProtocol ff_librtmpe_protocol = {
.name = "rtmpe", .name = "rtmpe",
.url_open = rtmp_open, .url_open = rtmp_open,
@@ -187,10 +247,12 @@ URLProtocol ff_librtmpe_protocol = {
.url_read_pause = rtmp_read_pause, .url_read_pause = rtmp_read_pause,
.url_read_seek = rtmp_read_seek, .url_read_seek = rtmp_read_seek,
.url_get_file_handle = rtmp_get_file_handle, .url_get_file_handle = rtmp_get_file_handle,
.priv_data_size = sizeof(RTMP),
.priv_data_size = sizeof(LibRTMPContext),
.priv_data_class = &librtmpe_class,
.flags = URL_PROTOCOL_FLAG_NETWORK, .flags = URL_PROTOCOL_FLAG_NETWORK,
}; };


RTMP_CLASS(rtmpte)
URLProtocol ff_librtmpte_protocol = { URLProtocol ff_librtmpte_protocol = {
.name = "rtmpte", .name = "rtmpte",
.url_open = rtmp_open, .url_open = rtmp_open,
@@ -200,10 +262,12 @@ URLProtocol ff_librtmpte_protocol = {
.url_read_pause = rtmp_read_pause, .url_read_pause = rtmp_read_pause,
.url_read_seek = rtmp_read_seek, .url_read_seek = rtmp_read_seek,
.url_get_file_handle = rtmp_get_file_handle, .url_get_file_handle = rtmp_get_file_handle,
.priv_data_size = sizeof(RTMP),
.priv_data_size = sizeof(LibRTMPContext),
.priv_data_class = &librtmpte_class,
.flags = URL_PROTOCOL_FLAG_NETWORK, .flags = URL_PROTOCOL_FLAG_NETWORK,
}; };


RTMP_CLASS(rtmps)
URLProtocol ff_librtmps_protocol = { URLProtocol ff_librtmps_protocol = {
.name = "rtmps", .name = "rtmps",
.url_open = rtmp_open, .url_open = rtmp_open,
@@ -213,6 +277,7 @@ URLProtocol ff_librtmps_protocol = {
.url_read_pause = rtmp_read_pause, .url_read_pause = rtmp_read_pause,
.url_read_seek = rtmp_read_seek, .url_read_seek = rtmp_read_seek,
.url_get_file_handle = rtmp_get_file_handle, .url_get_file_handle = rtmp_get_file_handle,
.priv_data_size = sizeof(RTMP),
.priv_data_size = sizeof(LibRTMPContext),
.priv_data_class = &librtmps_class,
.flags = URL_PROTOCOL_FLAG_NETWORK, .flags = URL_PROTOCOL_FLAG_NETWORK,
}; };

Write Preview
Loading…
Cancel
Save