Skip to content

F
ffmpeg
Commit ae48547a authored by Michael Niedermayer's avatar Michael Niedermayer
Browse files
Options

Merge commit 'e4529df9' 

* commit 'e4529df9':
  flvdec: K&R formatting cosmetics

Conflicts:
	libavformat/flvdec.c
Merged-by: 's avatarMichael Niedermayer <michaelni@gmx.at>
parents cb73f840 e4529df9
Hide whitespace changes
Inline Side-by-side
Showing with 410 additions and 339 deletions
libavformat/flvdec.c
View file @ ae48547a
...@@ -41,12 +41,12 @@ ...@@ -41,12 +41,12 @@
typedef struct { typedef struct {
const AVClass *class; ///< Class for private options. const AVClass *class; ///< Class for private options.
int trust_metadata; ///< configure streams according onMetaData int trust_metadata; ///< configure streams according onMetaData
int wrong_dts; ///< wrong dts due to negative cts int wrong_dts; ///< wrong dts due to negative cts
uint8_t *new_extradata[FLV_STREAM_TYPE_NB]; uint8_t *new_extradata[FLV_STREAM_TYPE_NB];
int new_extradata_size[FLV_STREAM_TYPE_NB]; int new_extradata_size[FLV_STREAM_TYPE_NB];
int last_sample_rate; int last_sample_rate;
int last_channels; int last_channels;
struct { struct {
int64_t dts; int64_t dts;
int64_t pos; int64_t pos;
...@@ -61,7 +61,11 @@ static int flv_probe(AVProbeData *p) ...@@ -61,7 +61,11 @@ static int flv_probe(AVProbeData *p)
const uint8_t *d; const uint8_t *d;
d = p->buf; d = p->buf;
if (d[0] == 'F' && d[1] == 'L' && d[2] == 'V' && d[3] < 5 && d[5]==0 && AV_RB32(d+5)>8) { if (d[0] == 'F' &&
d[1] == 'L' &&
d[2] == 'V' &&
d[3] < 5 && d[5] == 0 &&
AV_RB32(d + 5) > 8) {
return AVPROBE_SCORE_MAX; return AVPROBE_SCORE_MAX;
} }
return 0; return 0;
...@@ -73,7 +77,7 @@ static AVStream *create_stream(AVFormatContext *s, int codec_type) ...@@ -73,7 +77,7 @@ static AVStream *create_stream(AVFormatContext *s, int codec_type)
if (!st) if (!st)
return NULL; return NULL;
st->codec->codec_type = codec_type; st->codec->codec_type = codec_type;
if(s->nb_streams>=3 ||( s->nb_streams==2 if (s->nb_streams>=3 ||( s->nb_streams==2
&& s->streams[0]->codec->codec_type != AVMEDIA_TYPE_DATA && s->streams[0]->codec->codec_type != AVMEDIA_TYPE_DATA
&& s->streams[1]->codec->codec_type != AVMEDIA_TYPE_DATA)) && s->streams[1]->codec->codec_type != AVMEDIA_TYPE_DATA))
s->ctx_flags &= ~AVFMTCTX_NOHEADER; s->ctx_flags &= ~AVFMTCTX_NOHEADER;
...@@ -81,10 +85,11 @@ static AVStream *create_stream(AVFormatContext *s, int codec_type) ...@@ -81,10 +85,11 @@ static AVStream *create_stream(AVFormatContext *s, int codec_type)
avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */ avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
return st; return st;
} }
static int flv_same_audio_codec(AVCodecContext *acodec, int flags) static int flv_same_audio_codec(AVCodecContext *acodec, int flags)
{ {
int bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8; int bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
int flv_codecid = flags & FLV_AUDIO_CODECID_MASK; int flv_codecid = flags & FLV_AUDIO_CODECID_MASK;
int codec_id; int codec_id;
if (!acodec->codec_id && !acodec->codec_tag) if (!acodec->codec_id && !acodec->codec_tag)
...@@ -93,18 +98,21 @@ static int flv_same_audio_codec(AVCodecContext *acodec, int flags) ...@@ -93,18 +98,21 @@ static int flv_same_audio_codec(AVCodecContext *acodec, int flags)
if (acodec->bits_per_coded_sample != bits_per_coded_sample) if (acodec->bits_per_coded_sample != bits_per_coded_sample)
return 0; return 0;
switch(flv_codecid) { switch (flv_codecid) {
//no distinction between S16 and S8 PCM codec flags // no distinction between S16 and S8 PCM codec flags
case FLV_CODECID_PCM: case FLV_CODECID_PCM:
codec_id = bits_per_coded_sample == 8 ? AV_CODEC_ID_PCM_U8 : codec_id = bits_per_coded_sample == 8
? AV_CODEC_ID_PCM_U8
#if HAVE_BIGENDIAN #if HAVE_BIGENDIAN
AV_CODEC_ID_PCM_S16BE; : AV_CODEC_ID_PCM_S16BE;
#else #else
AV_CODEC_ID_PCM_S16LE; : AV_CODEC_ID_PCM_S16LE;
#endif #endif
return codec_id == acodec->codec_id; return codec_id == acodec->codec_id;
case FLV_CODECID_PCM_LE: case FLV_CODECID_PCM_LE:
codec_id = bits_per_coded_sample == 8 ? AV_CODEC_ID_PCM_U8 : AV_CODEC_ID_PCM_S16LE; codec_id = bits_per_coded_sample == 8
? AV_CODEC_ID_PCM_U8
: AV_CODEC_ID_PCM_S16LE;
return codec_id == acodec->codec_id; return codec_id == acodec->codec_id;
case FLV_CODECID_AAC: case FLV_CODECID_AAC:
return acodec->codec_id == AV_CODEC_ID_AAC; return acodec->codec_id == AV_CODEC_ID_AAC;
...@@ -120,57 +128,72 @@ static int flv_same_audio_codec(AVCodecContext *acodec, int flags) ...@@ -120,57 +128,72 @@ static int flv_same_audio_codec(AVCodecContext *acodec, int flags)
return acodec->codec_id == AV_CODEC_ID_NELLYMOSER; return acodec->codec_id == AV_CODEC_ID_NELLYMOSER;
case FLV_CODECID_PCM_MULAW: case FLV_CODECID_PCM_MULAW:
return acodec->sample_rate == 8000 && return acodec->sample_rate == 8000 &&
acodec->codec_id == AV_CODEC_ID_PCM_MULAW; acodec->codec_id == AV_CODEC_ID_PCM_MULAW;
case FLV_CODECID_PCM_ALAW: case FLV_CODECID_PCM_ALAW:
return acodec->sample_rate == 8000 && return acodec->sample_rate == 8000 &&
acodec->codec_id == AV_CODEC_ID_PCM_ALAW; acodec->codec_id == AV_CODEC_ID_PCM_ALAW;
default: default:
return acodec->codec_tag == (flv_codecid >> FLV_AUDIO_CODECID_OFFSET); return acodec->codec_tag == (flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
} }
} }
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,
switch(flv_codecid) { AVCodecContext *acodec, int flv_codecid)
//no distinction between S16 and S8 PCM codec flags {
case FLV_CODECID_PCM: switch (flv_codecid) {
acodec->codec_id = acodec->bits_per_coded_sample == 8 ? AV_CODEC_ID_PCM_U8 : // no distinction between S16 and S8 PCM codec flags
case FLV_CODECID_PCM:
acodec->codec_id = acodec->bits_per_coded_sample == 8
? AV_CODEC_ID_PCM_U8
#if HAVE_BIGENDIAN #if HAVE_BIGENDIAN
AV_CODEC_ID_PCM_S16BE; : AV_CODEC_ID_PCM_S16BE;
#else #else
AV_CODEC_ID_PCM_S16LE; : AV_CODEC_ID_PCM_S16LE;
#endif #endif
break; break;
case FLV_CODECID_PCM_LE: case FLV_CODECID_PCM_LE:
acodec->codec_id = acodec->bits_per_coded_sample == 8 ? AV_CODEC_ID_PCM_U8 : AV_CODEC_ID_PCM_S16LE; break; acodec->codec_id = acodec->bits_per_coded_sample == 8
case FLV_CODECID_AAC : acodec->codec_id = AV_CODEC_ID_AAC; break; ? AV_CODEC_ID_PCM_U8
case FLV_CODECID_ADPCM: acodec->codec_id = AV_CODEC_ID_ADPCM_SWF; break; : AV_CODEC_ID_PCM_S16LE;
case FLV_CODECID_SPEEX: break;
acodec->codec_id = AV_CODEC_ID_SPEEX; case FLV_CODECID_AAC:
acodec->sample_rate = 16000; acodec->codec_id = AV_CODEC_ID_AAC;
break; break;
case FLV_CODECID_MP3 : acodec->codec_id = AV_CODEC_ID_MP3 ; astream->need_parsing = AVSTREAM_PARSE_FULL; break; case FLV_CODECID_ADPCM:
case FLV_CODECID_NELLYMOSER_8KHZ_MONO: acodec->codec_id = AV_CODEC_ID_ADPCM_SWF;
acodec->sample_rate = 8000; //in case metadata does not otherwise declare samplerate break;
acodec->codec_id = AV_CODEC_ID_NELLYMOSER; case FLV_CODECID_SPEEX:
break; acodec->codec_id = AV_CODEC_ID_SPEEX;
case FLV_CODECID_NELLYMOSER_16KHZ_MONO: acodec->sample_rate = 16000;
acodec->sample_rate = 16000; break;
acodec->codec_id = AV_CODEC_ID_NELLYMOSER; case FLV_CODECID_MP3:
break; acodec->codec_id = AV_CODEC_ID_MP3;
case FLV_CODECID_NELLYMOSER: astream->need_parsing = AVSTREAM_PARSE_FULL;
acodec->codec_id = AV_CODEC_ID_NELLYMOSER; break;
break; case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
case FLV_CODECID_PCM_MULAW: // in case metadata does not otherwise declare samplerate
acodec->sample_rate = 8000; acodec->sample_rate = 8000;
acodec->codec_id = AV_CODEC_ID_PCM_MULAW; acodec->codec_id = AV_CODEC_ID_NELLYMOSER;
break; break;
case FLV_CODECID_PCM_ALAW: case FLV_CODECID_NELLYMOSER_16KHZ_MONO:
acodec->sample_rate = 8000; acodec->sample_rate = 16000;
acodec->codec_id = AV_CODEC_ID_PCM_ALAW; acodec->codec_id = AV_CODEC_ID_NELLYMOSER;
break; break;
default: case FLV_CODECID_NELLYMOSER:
av_log(s, AV_LOG_INFO, "Unsupported audio codec (%x)\n", flv_codecid >> FLV_AUDIO_CODECID_OFFSET); acodec->codec_id = AV_CODEC_ID_NELLYMOSER;
acodec->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET; break;
case FLV_CODECID_PCM_MULAW:
acodec->sample_rate = 8000;
acodec->codec_id = AV_CODEC_ID_PCM_MULAW;
break;
case FLV_CODECID_PCM_ALAW:
acodec->sample_rate = 8000;
acodec->codec_id = AV_CODEC_ID_PCM_ALAW;
break;
default:
av_log(s, AV_LOG_INFO, "Unsupported audio codec (%x)\n",
flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
acodec->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET;
} }
} }
...@@ -182,63 +205,75 @@ static int flv_same_video_codec(AVCodecContext *vcodec, int flags) ...@@ -182,63 +205,75 @@ static int flv_same_video_codec(AVCodecContext *vcodec, int flags)
return 1; return 1;
switch (flv_codecid) { switch (flv_codecid) {
case FLV_CODECID_H263: case FLV_CODECID_H263:
return vcodec->codec_id == AV_CODEC_ID_FLV1; return vcodec->codec_id == AV_CODEC_ID_FLV1;
case FLV_CODECID_SCREEN: case FLV_CODECID_SCREEN:
return vcodec->codec_id == AV_CODEC_ID_FLASHSV; return vcodec->codec_id == AV_CODEC_ID_FLASHSV;
case FLV_CODECID_SCREEN2: case FLV_CODECID_SCREEN2:
return vcodec->codec_id == AV_CODEC_ID_FLASHSV2; return vcodec->codec_id == AV_CODEC_ID_FLASHSV2;
case FLV_CODECID_VP6: case FLV_CODECID_VP6:
return vcodec->codec_id == AV_CODEC_ID_VP6F; return vcodec->codec_id == AV_CODEC_ID_VP6F;
case FLV_CODECID_VP6A: case FLV_CODECID_VP6A:
return vcodec->codec_id == AV_CODEC_ID_VP6A; return vcodec->codec_id == AV_CODEC_ID_VP6A;
case FLV_CODECID_H264: case FLV_CODECID_H264:
return vcodec->codec_id == AV_CODEC_ID_H264; return vcodec->codec_id == AV_CODEC_ID_H264;
default: default:
return vcodec->codec_tag == flv_codecid; return vcodec->codec_tag == flv_codecid;
} }
} }
static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream, int flv_codecid, int read) { static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream,
int flv_codecid, int read)
{
AVCodecContext *vcodec = vstream->codec; AVCodecContext *vcodec = vstream->codec;
switch(flv_codecid) { switch (flv_codecid) {
case FLV_CODECID_H263 : vcodec->codec_id = AV_CODEC_ID_FLV1 ; break; case FLV_CODECID_H263:
case FLV_CODECID_REALH263: vcodec->codec_id = AV_CODEC_ID_H263 ; break; // Really mean it this time vcodec->codec_id = AV_CODEC_ID_FLV1;
case FLV_CODECID_SCREEN: vcodec->codec_id = AV_CODEC_ID_FLASHSV; break; break;
case FLV_CODECID_SCREEN2: vcodec->codec_id = AV_CODEC_ID_FLASHSV2; break; case FLV_CODECID_REALH263:
case FLV_CODECID_VP6 : vcodec->codec_id = AV_CODEC_ID_VP6F ; vcodec->codec_id = AV_CODEC_ID_H263;
case FLV_CODECID_VP6A : break; // Really mean it this time
if(flv_codecid == FLV_CODECID_VP6A) case FLV_CODECID_SCREEN:
vcodec->codec_id = AV_CODEC_ID_VP6A; vcodec->codec_id = AV_CODEC_ID_FLASHSV;
if (read) { break;
if (vcodec->extradata_size != 1) { case FLV_CODECID_SCREEN2:
vcodec->extradata = av_malloc(1 + FF_INPUT_BUFFER_PADDING_SIZE); vcodec->codec_id = AV_CODEC_ID_FLASHSV2;
if (vcodec->extradata) break;
vcodec->extradata_size = 1; case FLV_CODECID_VP6:
} vcodec->codec_id = AV_CODEC_ID_VP6F;
case FLV_CODECID_VP6A:
if (flv_codecid == FLV_CODECID_VP6A)
vcodec->codec_id = AV_CODEC_ID_VP6A;
if (read) {
if (vcodec->extradata_size != 1) {
vcodec->extradata = av_malloc(1 + FF_INPUT_BUFFER_PADDING_SIZE);
if (vcodec->extradata) if (vcodec->extradata)
vcodec->extradata[0] = avio_r8(s->pb); vcodec->extradata_size = 1;
else
avio_skip(s->pb, 1);
} }
return 1; // 1 byte body size adjustment for flv_read_packet() if (vcodec->extradata)
case FLV_CODECID_H264: vcodec->extradata[0] = avio_r8(s->pb);
vcodec->codec_id = AV_CODEC_ID_H264; else
return 3; // not 4, reading packet type will consume one byte avio_skip(s->pb, 1);
case FLV_CODECID_MPEG4: }
vcodec->codec_id = AV_CODEC_ID_MPEG4; return 1; // 1 byte body size adjustment for flv_read_packet()
return 3; case FLV_CODECID_H264:
default: vcodec->codec_id = AV_CODEC_ID_H264;
av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid); return 3; // not 4, reading packet type will consume one byte
vcodec->codec_tag = flv_codecid; case FLV_CODECID_MPEG4:
vcodec->codec_id = AV_CODEC_ID_MPEG4;
return 3;
default:
av_log(s, AV_LOG_INFO, "Unsupported video codec (%x)\n", flv_codecid);
vcodec->codec_tag = flv_codecid;
} }
return 0; return 0;
} }
static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize) { static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize)
{
int length = avio_rb16(ioc); int length = avio_rb16(ioc);
if(length >= buffsize) { if (length >= buffsize) {
avio_skip(ioc, length); avio_skip(ioc, length);
return -1; return -1;
} }
...@@ -250,16 +285,18 @@ static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize) { ...@@ -250,16 +285,18 @@ static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize) {
return length; return length;
} }
static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc, AVStream *vstream, int64_t max_pos) { static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc,
FLVContext *flv = s->priv_data; AVStream *vstream, int64_t max_pos)
{
FLVContext *flv = s->priv_data;
unsigned int timeslen = 0, fileposlen = 0, i; unsigned int timeslen = 0, fileposlen = 0, i;
char str_val[256]; char str_val[256];
int64_t *times = NULL; int64_t *times = NULL;
int64_t *filepositions = NULL; int64_t *filepositions = NULL;
int ret = AVERROR(ENOSYS); int ret = AVERROR(ENOSYS);
int64_t initial_pos = avio_tell(ioc); int64_t initial_pos = avio_tell(ioc);
if(vstream->nb_index_entries>0){ if (vstream->nb_index_entries>0) {
av_log(s, AV_LOG_WARNING, "Skiping duplicate index\n"); av_log(s, AV_LOG_WARNING, "Skiping duplicate index\n");
return 0; return 0;
} }
...@@ -267,8 +304,9 @@ static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc, AVStream ...@@ -267,8 +304,9 @@ static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc, AVStream
if (s->flags & AVFMT_FLAG_IGNIDX) if (s->flags & AVFMT_FLAG_IGNIDX)
return 0; return 0;
while (avio_tell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) { while (avio_tell(ioc) < max_pos - 2 &&
int64_t** current_array; amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
int64_t **current_array;
unsigned int arraylen; unsigned int arraylen;
// Expect array object in context // Expect array object in context
...@@ -276,16 +314,19 @@ static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc, AVStream ...@@ -276,16 +314,19 @@ static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc, AVStream
break; break;
arraylen = avio_rb32(ioc); arraylen = avio_rb32(ioc);
if(arraylen>>28) if (arraylen>>28)
break; break;
if (!strcmp(KEYFRAMES_TIMESTAMP_TAG , str_val) && !times){ if (!strcmp(KEYFRAMES_TIMESTAMP_TAG , str_val) && !times) {
current_array= &times; current_array = &times;
timeslen= arraylen; timeslen = arraylen;
}else if (!strcmp(KEYFRAMES_BYTEOFFSET_TAG, str_val) && !filepositions){ } else if (!strcmp(KEYFRAMES_BYTEOFFSET_TAG, str_val) &&
current_array= &filepositions; !filepositions) {
fileposlen= arraylen; current_array = &filepositions;
}else // unexpected metatag inside keyframes, will not use such metadata for indexing fileposlen = arraylen;
} else
// unexpected metatag inside keyframes, will not use such
// metadata for indexing
break; break;
if (!(*current_array = av_mallocz(sizeof(**current_array) * arraylen))) { if (!(*current_array = av_mallocz(sizeof(**current_array) * arraylen))) {
...@@ -308,12 +349,12 @@ static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc, AVStream ...@@ -308,12 +349,12 @@ static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc, AVStream
if (timeslen == fileposlen && fileposlen>1 && max_pos <= filepositions[0]) { if (timeslen == fileposlen && fileposlen>1 && max_pos <= filepositions[0]) {
for (i = 0; i < fileposlen; i++) { for (i = 0; i < fileposlen; i++) {
av_add_index_entry(vstream, filepositions[i], times[i]*1000, av_add_index_entry(vstream, filepositions[i], times[i] * 1000,
0, 0, AVINDEX_KEYFRAME); 0, 0, AVINDEX_KEYFRAME);
if (i < 2) { if (i < 2) {
flv->validate_index[i].pos = filepositions[i]; flv->validate_index[i].pos = filepositions[i];
flv->validate_index[i].dts = times[i] * 1000; flv->validate_index[i].dts = times[i] * 1000;
flv->validate_count = i + 1; flv->validate_count = i + 1;
} }
} }
} else { } else {
...@@ -328,7 +369,10 @@ finish: ...@@ -328,7 +369,10 @@ finish:
return ret; return ret;
} }
static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vstream, const char *key, int64_t max_pos, int depth) { static int amf_parse_object(AVFormatContext *s, AVStream *astream,
AVStream *vstream, const char *key,
int64_t max_pos, int depth)
{
AVCodecContext *acodec, *vcodec; AVCodecContext *acodec, *vcodec;
FLVContext *flv = s->priv_data; FLVContext *flv = s->priv_data;
AVIOContext *ioc; AVIOContext *ioc;
...@@ -336,74 +380,85 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst ...@@ -336,74 +380,85 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst
char str_val[256]; char str_val[256];
double num_val; double num_val;
num_val = 0; num_val = 0;
ioc = s->pb; ioc = s->pb;
amf_type = avio_r8(ioc); amf_type = avio_r8(ioc);
switch(amf_type) { switch (amf_type) {
case AMF_DATA_TYPE_NUMBER: case AMF_DATA_TYPE_NUMBER:
num_val = av_int2double(avio_rb64(ioc)); break; num_val = av_int2double(avio_rb64(ioc));
case AMF_DATA_TYPE_BOOL: break;
num_val = avio_r8(ioc); break; case AMF_DATA_TYPE_BOOL:
case AMF_DATA_TYPE_STRING: num_val = avio_r8(ioc);
if(amf_get_string(ioc, str_val, sizeof(str_val)) < 0) break;
return -1; case AMF_DATA_TYPE_STRING:
break; if (amf_get_string(ioc, str_val, sizeof(str_val)) < 0)
case AMF_DATA_TYPE_OBJECT: return -1;
if ((vstream || astream) && ioc->seekable && key && !strcmp(KEYFRAMES_TAG, key) && depth == 1) break;
if (parse_keyframes_index(s, ioc, vstream ? vstream : astream, case AMF_DATA_TYPE_OBJECT:
max_pos) < 0) if ((vstream || astream) && key &&
av_log(s, AV_LOG_ERROR, "Keyframe index parsing failed\n"); ioc->seekable &&
!strcmp(KEYFRAMES_TAG, key) && depth == 1)
while (avio_tell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) { if (parse_keyframes_index(s, ioc, vstream ? vstream : astream,
if (amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0) max_pos) < 0)
return -1; //if we couldn't skip, bomb out. av_log(s, AV_LOG_ERROR, "Keyframe index parsing failed\n");
}
if(avio_r8(ioc) != AMF_END_OF_OBJECT) while (avio_tell(ioc) < max_pos - 2 &&
return -1; amf_get_string(ioc, str_val, sizeof(str_val)) > 0)
break; if (amf_parse_object(s, astream, vstream, str_val, max_pos,
case AMF_DATA_TYPE_NULL: depth + 1) < 0)
case AMF_DATA_TYPE_UNDEFINED: return -1; // if we couldn't skip, bomb out.
case AMF_DATA_TYPE_UNSUPPORTED: if (avio_r8(ioc) != AMF_END_OF_OBJECT)
break; //these take up no additional space return -1;
case AMF_DATA_TYPE_MIXEDARRAY: break;
avio_skip(ioc, 4); //skip 32-bit max array index case AMF_DATA_TYPE_NULL:
while(avio_tell(ioc) < max_pos - 2 && amf_get_string(ioc, str_val, sizeof(str_val)) > 0) { case AMF_DATA_TYPE_UNDEFINED:
//this is the only case in which we would want a nested parse to not skip over the object case AMF_DATA_TYPE_UNSUPPORTED:
if(amf_parse_object(s, astream, vstream, str_val, max_pos, depth + 1) < 0) break; // these take up no additional space
return -1; case AMF_DATA_TYPE_MIXEDARRAY:
} avio_skip(ioc, 4); // skip 32-bit max array index
if(avio_r8(ioc) != AMF_END_OF_OBJECT) while (avio_tell(ioc) < max_pos - 2 &&
amf_get_string(ioc, str_val, sizeof(str_val)) > 0)
// this is the only case in which we would want a nested
// parse to not skip over the object
if (amf_parse_object(s, astream, vstream, str_val, max_pos,
depth + 1) < 0)
return -1; return -1;
break; if (avio_r8(ioc) != AMF_END_OF_OBJECT)
case AMF_DATA_TYPE_ARRAY: {
unsigned int arraylen, i;
arraylen = avio_rb32(ioc);
for(i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++) {
if(amf_parse_object(s, NULL, NULL, NULL, max_pos, depth + 1) < 0)
return -1; //if we couldn't skip, bomb out.
}
}
break;
case AMF_DATA_TYPE_DATE:
avio_skip(ioc, 8 + 2); //timestamp (double) and UTC offset (int16)
break;
default: //unsupported type, we couldn't skip
return -1; return -1;
break;
case AMF_DATA_TYPE_ARRAY:
{
unsigned int arraylen, i;
arraylen = avio_rb32(ioc);
for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++)
if (amf_parse_object(s, NULL, NULL, NULL, max_pos,
depth + 1) < 0)
return -1; // if we couldn't skip, bomb out.
}
break;
case AMF_DATA_TYPE_DATE:
avio_skip(ioc, 8 + 2); // timestamp (double) and UTC offset (int16)
break;
default: // unsupported type, we couldn't skip
return -1;
} }
if(depth == 1 && key) { //only look for metadata values when we are not nested and key != NULL // only look for metadata values when we are not nested and key != NULL
if (depth == 1 && key) {
acodec = astream ? astream->codec : NULL; acodec = astream ? astream->codec : NULL;
vcodec = vstream ? vstream->codec : NULL; vcodec = vstream ? vstream->codec : NULL;
if (amf_type == AMF_DATA_TYPE_NUMBER || amf_type == AMF_DATA_TYPE_BOOL) { if (amf_type == AMF_DATA_TYPE_NUMBER ||
amf_type == AMF_DATA_TYPE_BOOL) {
if (!strcmp(key, "duration")) if (!strcmp(key, "duration"))
s->duration = num_val * AV_TIME_BASE; s->duration = num_val * AV_TIME_BASE;
else if (!strcmp(key, "videodatarate") && vcodec && 0 <= (int)(num_val * 1024.0)) else if (!strcmp(key, "videodatarate") && vcodec &&
0 <= (int)(num_val * 1024.0))
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")) { else if (!strcmp(key, "datastream")) {
AVStream *st = create_stream(s, AVMEDIA_TYPE_DATA); AVStream *st = create_stream(s, AVMEDIA_TYPE_DATA);
...@@ -413,25 +468,21 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst ...@@ -413,25 +468,21 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst
} else if (flv->trust_metadata) { } else if (flv->trust_metadata) {
if (!strcmp(key, "videocodecid") && vcodec) { if (!strcmp(key, "videocodecid") && vcodec) {
flv_set_video_codec(s, vstream, num_val, 0); flv_set_video_codec(s, vstream, num_val, 0);
} else } else if (!strcmp(key, "audiocodecid") && acodec) {
if (!strcmp(key, "audiocodecid") && acodec) {
int id = ((int)num_val) << FLV_AUDIO_CODECID_OFFSET; int id = ((int)num_val) << FLV_AUDIO_CODECID_OFFSET;
flv_set_audio_codec(s, astream, acodec, id); flv_set_audio_codec(s, astream, acodec, id);
} else } else if (!strcmp(key, "audiosamplerate") && acodec) {
if (!strcmp(key, "audiosamplerate") && acodec) {
acodec->sample_rate = num_val; acodec->sample_rate = num_val;
} else if (!strcmp(key, "audiosamplesize") && acodec) { } else if (!strcmp(key, "audiosamplesize") && acodec) {
acodec->bits_per_coded_sample = num_val; acodec->bits_per_coded_sample = num_val;
} else if (!strcmp(key, "stereo") && acodec) { } else if (!strcmp(key, "stereo") && acodec) {
acodec->channels = num_val + 1; acodec->channels = num_val + 1;
acodec->channel_layout = acodec->channels == 2 ? acodec->channel_layout = acodec->channels == 2 ?
AV_CH_LAYOUT_STEREO : AV_CH_LAYOUT_STEREO :
AV_CH_LAYOUT_MONO; AV_CH_LAYOUT_MONO;
} else } else if (!strcmp(key, "width") && vcodec) {
if (!strcmp(key, "width") && vcodec) {
vcodec->width = num_val; vcodec->width = num_val;
} else } else if (!strcmp(key, "height") && vcodec) {
if (!strcmp(key, "height") && vcodec) {
vcodec->height = num_val; vcodec->height = num_val;
} }
} }
...@@ -456,10 +507,11 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst ...@@ -456,10 +507,11 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst
!strcmp(key, "audiocodecid")) !strcmp(key, "audiocodecid"))
return 0; return 0;
if(amf_type == AMF_DATA_TYPE_BOOL) { if (amf_type == AMF_DATA_TYPE_BOOL) {
av_strlcpy(str_val, num_val > 0 ? "true" : "false", sizeof(str_val)); av_strlcpy(str_val, num_val > 0 ? "true" : "false",
sizeof(str_val));
av_dict_set(&s->metadata, key, str_val, 0); av_dict_set(&s->metadata, key, str_val, 0);
} else if(amf_type == AMF_DATA_TYPE_NUMBER) { } else if (amf_type == AMF_DATA_TYPE_NUMBER) {
snprintf(str_val, sizeof(str_val), "%.f", num_val); snprintf(str_val, sizeof(str_val), "%.f", num_val);
av_dict_set(&s->metadata, key, str_val, 0); av_dict_set(&s->metadata, key, str_val, 0);
} else if (amf_type == AMF_DATA_TYPE_STRING) } else if (amf_type == AMF_DATA_TYPE_STRING)
...@@ -469,17 +521,22 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst ...@@ -469,17 +521,22 @@ static int amf_parse_object(AVFormatContext *s, AVStream *astream, AVStream *vst
return 0; return 0;
} }
static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) { static int flv_read_metabody(AVFormatContext *s, int64_t next_pos)
{
AMFDataType type; AMFDataType type;
AVStream *stream, *astream, *vstream, *dstream; AVStream *stream, *astream, *vstream, *dstream;
AVIOContext *ioc; AVIOContext *ioc;
int i; int i;
char buffer[11]; //only needs to hold the string "onMetaData". Anything longer is something we don't want. // only needs to hold the string "onMetaData".
// Anything longer is something we don't want.
char buffer[11];
vstream = astream = dstream = NULL; astream = NULL;
ioc = s->pb; vstream = NULL;
dstream = NULL;
ioc = s->pb;
//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 || if (type != AMF_DATA_TYPE_STRING ||
amf_get_string(ioc, buffer, sizeof(buffer)) < 0) amf_get_string(ioc, buffer, sizeof(buffer)) < 0)
...@@ -491,16 +548,20 @@ static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) { ...@@ -491,16 +548,20 @@ static int flv_read_metabody(AVFormatContext *s, int64_t next_pos) {
if (strcmp(buffer, "onMetaData")) 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
for(i = 0; i < s->nb_streams; i++) { // the lookup every time it is called.
for (i = 0; i < s->nb_streams; i++) {
stream = s->streams[i]; stream = s->streams[i];
if(stream->codec->codec_type == AVMEDIA_TYPE_VIDEO) vstream = stream; if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO)
else if(stream->codec->codec_type == AVMEDIA_TYPE_AUDIO) astream = stream; vstream = stream;
else if(stream->codec->codec_type == AVMEDIA_TYPE_DATA) dstream = stream; else if (stream->codec->codec_type == AVMEDIA_TYPE_AUDIO)
astream = stream;
else if (stream->codec->codec_type == AVMEDIA_TYPE_DATA)
dstream = stream;
} }
//parse the second object (we want a mixed array) // parse the second object (we want a mixed array)
if(amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0) if (amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0)
return -1; return -1;
return 0; return 0;
...@@ -516,19 +577,19 @@ static int flv_read_header(AVFormatContext *s) ...@@ -516,19 +577,19 @@ static int flv_read_header(AVFormatContext *s)
/* FIXME: better fix needed */ /* FIXME: better fix needed */
if (!flags) { if (!flags) {
flags = FLV_HEADER_FLAG_HASVIDEO | FLV_HEADER_FLAG_HASAUDIO; flags = FLV_HEADER_FLAG_HASVIDEO | FLV_HEADER_FLAG_HASAUDIO;
av_log(s, AV_LOG_WARNING, "Broken FLV file, which says no streams present, this might fail\n"); av_log(s, AV_LOG_WARNING,
"Broken FLV file, which says no streams present, "
"this might fail\n");
} }
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, AVMEDIA_TYPE_VIDEO)) if (!create_stream(s, 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, AVMEDIA_TYPE_AUDIO))
if(!create_stream(s, 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
// create that stream if it's encountered. // create that stream if it's encountered.
...@@ -545,7 +606,7 @@ static int flv_read_close(AVFormatContext *s) ...@@ -545,7 +606,7 @@ static int flv_read_close(AVFormatContext *s)
{ {
int i; int i;
FLVContext *flv = s->priv_data; FLVContext *flv = s->priv_data;
for(i=0; i<FLV_STREAM_TYPE_NB; i++) for (i=0; i<FLV_STREAM_TYPE_NB; i++)
av_freep(&flv->new_extradata[i]); av_freep(&flv->new_extradata[i]);
return 0; return 0;
} }
...@@ -565,7 +626,8 @@ static int flv_queue_extradata(FLVContext *flv, AVIOContext *pb, int stream, ...@@ -565,7 +626,8 @@ static int flv_queue_extradata(FLVContext *flv, AVIOContext *pb, int stream,
int size) int size)
{ {
av_free(flv->new_extradata[stream]); av_free(flv->new_extradata[stream]);
flv->new_extradata[stream] = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE); flv->new_extradata[stream] = av_mallocz(size +
FF_INPUT_BUFFER_PADDING_SIZE);
if (!flv->new_extradata[stream]) if (!flv->new_extradata[stream])
return AVERROR(ENOMEM); return AVERROR(ENOMEM);
flv->new_extradata_size[stream] = size; flv->new_extradata_size[stream] = size;
...@@ -576,26 +638,25 @@ static int flv_queue_extradata(FLVContext *flv, AVIOContext *pb, int stream, ...@@ -576,26 +638,25 @@ static int flv_queue_extradata(FLVContext *flv, AVIOContext *pb, int stream,
static void clear_index_entries(AVFormatContext *s, int64_t pos) static void clear_index_entries(AVFormatContext *s, int64_t pos)
{ {
int i, j, out; int i, j, out;
av_log(s, AV_LOG_WARNING, "Found invalid index entries, clearing the index.\n"); av_log(s, AV_LOG_WARNING,
"Found invalid index entries, clearing the index.\n");
for (i = 0; i < s->nb_streams; i++) { for (i = 0; i < s->nb_streams; i++) {
AVStream *st = s->streams[i]; AVStream *st = s->streams[i];
/* Remove all index entries that point to >= pos */ /* Remove all index entries that point to >= pos */
out = 0; out = 0;
for (j = 0; j < st->nb_index_entries; j++) { for (j = 0; j < st->nb_index_entries; j++)
if (st->index_entries[j].pos < pos) if (st->index_entries[j].pos < pos)
st->index_entries[out++] = st->index_entries[j]; st->index_entries[out++] = st->index_entries[j];
}
st->nb_index_entries = out; st->nb_index_entries = out;
} }
} }
static int flv_data_packet(AVFormatContext *s, AVPacket *pkt, static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,
int64_t dts, int64_t next) int64_t dts, int64_t next)
{ {
int ret = AVERROR_INVALIDDATA, i; int ret = AVERROR_INVALIDDATA, i;
AVIOContext *pb = s->pb; AVIOContext *pb = s->pb;
AVStream *st = NULL; AVStream *st = NULL;
AMFDataType type; AMFDataType type;
char buf[20]; char buf[20];
int length; int length;
...@@ -611,13 +672,13 @@ static int flv_data_packet(AVFormatContext *s, AVPacket *pkt, ...@@ -611,13 +672,13 @@ static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,
goto out; goto out;
amf_get_string(pb, buf, sizeof(buf)); amf_get_string(pb, buf, sizeof(buf));
//FIXME parse it as codec_id // FIXME parse it as codec_id
amf_get_string(pb, buf, sizeof(buf)); amf_get_string(pb, buf, sizeof(buf));
if (strcmp(buf, "text") || avio_r8(pb) != AMF_DATA_TYPE_STRING) if (strcmp(buf, "text") || avio_r8(pb) != AMF_DATA_TYPE_STRING)
goto out; goto out;
length = avio_rb16(pb); length = avio_rb16(pb);
ret = av_get_packet(s->pb, pkt, length); ret = av_get_packet(s->pb, pkt, length);
if (ret < 0) { if (ret < 0) {
ret = AVERROR(EIO); ret = AVERROR(EIO);
goto out; goto out;
...@@ -641,9 +702,10 @@ static int flv_data_packet(AVFormatContext *s, AVPacket *pkt, ...@@ -641,9 +702,10 @@ static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,
pkt->size = ret; pkt->size = ret;
pkt->stream_index = st->index; pkt->stream_index = st->index;
pkt->flags |= AV_PKT_FLAG_KEY; pkt->flags |= AV_PKT_FLAG_KEY;
avio_seek(s->pb, next + 4, SEEK_SET); avio_seek(s->pb, next + 4, SEEK_SET);
out: out:
return ret; return ret;
} }
...@@ -657,127 +719,127 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt) ...@@ -657,127 +719,127 @@ static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
int64_t dts, pts = AV_NOPTS_VALUE; int64_t dts, pts = AV_NOPTS_VALUE;
int av_uninit(channels); int av_uninit(channels);
int av_uninit(sample_rate); int av_uninit(sample_rate);
AVStream *st = NULL; AVStream *st = NULL;
for(;;avio_skip(s->pb, 4)){ /* pkt size is repeated at end. skip it */ /* pkt size is repeated at end. skip it */
pos = avio_tell(s->pb); for (;; avio_skip(s->pb, 4)) {
type = avio_r8(s->pb); pos = avio_tell(s->pb);
size = avio_rb24(s->pb); type = avio_r8(s->pb);
dts = avio_rb24(s->pb); size = avio_rb24(s->pb);
dts |= avio_r8(s->pb) << 24; dts = avio_rb24(s->pb);
av_dlog(s, "type:%d, size:%d, dts:%"PRId64"\n", type, size, dts); dts |= avio_r8(s->pb) << 24;
if (url_feof(s->pb)) av_dlog(s, "type:%d, size:%d, dts:%"PRId64"\n", type, size, dts);
return AVERROR_EOF; if (url_feof(s->pb))
avio_skip(s->pb, 3); /* stream id, always 0 */ return AVERROR_EOF;
flags = 0; avio_skip(s->pb, 3); /* stream id, always 0 */
flags = 0;
if (flv->validate_next < flv->validate_count) {
int64_t validate_pos = flv->validate_index[flv->validate_next].pos; if (flv->validate_next < flv->validate_count) {
if (pos == validate_pos) { int64_t validate_pos = flv->validate_index[flv->validate_next].pos;
if (FFABS(dts - flv->validate_index[flv->validate_next].dts) <= if (pos == validate_pos) {
VALIDATE_INDEX_TS_THRESH) { if (FFABS(dts - flv->validate_index[flv->validate_next].dts) <=
flv->validate_next++; VALIDATE_INDEX_TS_THRESH) {
} else { flv->validate_next++;
} else {
clear_index_entries(s, validate_pos);
flv->validate_count = 0;
}
} else if (pos > validate_pos) {
clear_index_entries(s, validate_pos); clear_index_entries(s, validate_pos);
flv->validate_count = 0; flv->validate_count = 0;
} }
} else if (pos > validate_pos) {
clear_index_entries(s, validate_pos);
flv->validate_count = 0;
} }
}
if(size == 0) if (size == 0)
continue; continue;
next= size + avio_tell(s->pb); next = size + avio_tell(s->pb);
if (type == FLV_TAG_TYPE_AUDIO) { if (type == FLV_TAG_TYPE_AUDIO) {
stream_type=FLV_STREAM_TYPE_AUDIO; stream_type = FLV_STREAM_TYPE_AUDIO;
flags = avio_r8(s->pb); flags = avio_r8(s->pb);
size--; size--;
} else if (type == FLV_TAG_TYPE_VIDEO) { } else if (type == FLV_TAG_TYPE_VIDEO) {
stream_type=FLV_STREAM_TYPE_VIDEO; stream_type = FLV_STREAM_TYPE_VIDEO;
flags = avio_r8(s->pb); flags = avio_r8(s->pb);
size--; size--;
if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_VIDEO_INFO_CMD) if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_VIDEO_INFO_CMD)
goto skip;
} else if (type == FLV_TAG_TYPE_META) {
stream_type=FLV_STREAM_TYPE_DATA;
if (size > 13+1+4 && dts == 0) { // Header-type metadata stuff
meta_pos = avio_tell(s->pb);
if (flv_read_metabody(s, next) == 0){
goto skip; goto skip;
} else if (type == FLV_TAG_TYPE_META) {
stream_type=FLV_STREAM_TYPE_DATA;
if (size > 13 + 1 + 4 && dts == 0) { // Header-type metadata stuff
meta_pos = avio_tell(s->pb);
if (flv_read_metabody(s, next) == 0) {
goto skip;
}
avio_seek(s->pb, meta_pos, SEEK_SET);
} }
avio_seek(s->pb, meta_pos, SEEK_SET); } else {
av_log(s, AV_LOG_DEBUG,
"skipping flv packet: type %d, size %d, flags %d\n",
type, size, flags);
skip:
avio_seek(s->pb, next, SEEK_SET);
continue;
} }
} else {
av_log(s, AV_LOG_DEBUG, "skipping flv packet: type %d, size %d, flags %d\n", type, size, flags);
skip:
avio_seek(s->pb, next, SEEK_SET);
continue;
}
/* skip empty data packets */
if (!size)
continue;
/* now find stream */ /* skip empty data packets */
for(i=0;i<s->nb_streams;i++) { if (!size)
st = s->streams[i]; continue;
if (stream_type == FLV_STREAM_TYPE_AUDIO) {
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && /* now find stream */
(s->audio_codec_id || flv_same_audio_codec(st->codec, flags))) { for (i = 0; i < s->nb_streams; i++) {
break; st = s->streams[i];
} if (stream_type == FLV_STREAM_TYPE_AUDIO) {
} else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
if (stream_type == FLV_STREAM_TYPE_VIDEO) { (s->audio_codec_id || flv_same_audio_codec(st->codec, flags)))
if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && break;
(s->video_codec_id || flv_same_video_codec(st->codec, flags))) { } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {
break; if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
(s->video_codec_id || flv_same_video_codec(st->codec, flags)))
break;
} else if (stream_type == FLV_STREAM_TYPE_DATA) {
if (st->codec->codec_type == AVMEDIA_TYPE_DATA)
break;
} }
} else if (stream_type == FLV_STREAM_TYPE_DATA) {
if (st->codec->codec_type == AVMEDIA_TYPE_DATA)
break;
} }
} if (i == s->nb_streams) {
if(i == s->nb_streams){ static const enum AVMediaType stream_types[] = {AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_DATA};
static const enum AVMediaType stream_types[] = {AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_DATA}; 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_types[stream_type]);
st = create_stream(s, if (!st)
stream_types[stream_type]); return AVERROR(ENOMEM);
if (!st)
return AVERROR(ENOMEM);
}
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)))
||(st->discard >= AVDISCARD_BIDIR && ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_DISP_INTER && (stream_type == FLV_STREAM_TYPE_VIDEO)))
|| st->discard >= AVDISCARD_ALL
) {
avio_seek(s->pb, next, SEEK_SET);
continue;
}
if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || stream_type == FLV_STREAM_TYPE_AUDIO)
av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);
break;
} }
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)))
||(st->discard >= AVDISCARD_BIDIR && ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_DISP_INTER && (stream_type == FLV_STREAM_TYPE_VIDEO)))
|| st->discard >= AVDISCARD_ALL
){
avio_seek(s->pb, next, SEEK_SET);
continue;
}
if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || stream_type == FLV_STREAM_TYPE_AUDIO)
av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);
break;
}
// if not streamed and no duration from metadata then seek to end to find the duration from the timestamps // if not streamed and no duration from metadata then seek to end to find
if(s->pb->seekable && (!s->duration || s->duration==AV_NOPTS_VALUE) && !flv->searched_for_end){ // the duration from the timestamps
if (s->pb->seekable && (!s->duration || s->duration == AV_NOPTS_VALUE) && !flv->searched_for_end) {
int size; int size;
const int64_t pos= avio_tell(s->pb); const int64_t pos = avio_tell(s->pb);
int64_t fsize= avio_size(s->pb); int64_t fsize = avio_size(s->pb);
retry_duration: retry_duration:
avio_seek(s->pb, fsize-4, SEEK_SET); avio_seek(s->pb, fsize - 4, SEEK_SET);
size= avio_rb32(s->pb); size = avio_rb32(s->pb);
avio_seek(s->pb, fsize-3-size, SEEK_SET); avio_seek(s->pb, fsize - 3 - size, SEEK_SET);
if(size == avio_rb24(s->pb) + 11){ if (size == avio_rb24(s->pb) + 11) {
uint32_t ts = avio_rb24(s->pb); uint32_t ts = avio_rb24(s->pb);
ts |= avio_r8(s->pb) << 24; ts |= avio_r8(s->pb) << 24;
if(ts) if (ts)
s->duration = ts * (int64_t)AV_TIME_BASE / 1000; s->duration = ts * (int64_t)AV_TIME_BASE / 1000;
else if (fsize >= 8 && fsize - 8 >= size){ else if (fsize >= 8 && fsize - 8 >= size) {
fsize -= size+4; fsize -= size+4;
goto retry_duration; goto retry_duration;
} }
...@@ -787,29 +849,35 @@ retry_duration: ...@@ -787,29 +849,35 @@ retry_duration:
flv->searched_for_end = 1; flv->searched_for_end = 1;
} }
if(stream_type == FLV_STREAM_TYPE_AUDIO){ if (stream_type == FLV_STREAM_TYPE_AUDIO) {
int bits_per_coded_sample; int bits_per_coded_sample;
channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1; channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;
sample_rate = (44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >> FLV_AUDIO_SAMPLERATE_OFFSET) >> 3); sample_rate = 44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >>
FLV_AUDIO_SAMPLERATE_OFFSET) >> 3;
bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8; bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
if(!st->codec->channels || !st->codec->sample_rate || !st->codec->bits_per_coded_sample) { if (!st->codec->channels || !st->codec->sample_rate ||
!st->codec->bits_per_coded_sample) {
st->codec->channels = channels; st->codec->channels = channels;
st->codec->channel_layout = channels == 1 ? AV_CH_LAYOUT_MONO : st->codec->channel_layout = channels == 1
AV_CH_LAYOUT_STEREO; ? AV_CH_LAYOUT_MONO
: AV_CH_LAYOUT_STEREO;
st->codec->sample_rate = sample_rate; st->codec->sample_rate = sample_rate;
st->codec->bits_per_coded_sample = bits_per_coded_sample; st->codec->bits_per_coded_sample = bits_per_coded_sample;
} }
if(!st->codec->codec_id){ if (!st->codec->codec_id) {
flv_set_audio_codec(s, st, st->codec, flags & FLV_AUDIO_CODECID_MASK); flv_set_audio_codec(s, st, st->codec,
flv->last_sample_rate = sample_rate = st->codec->sample_rate; flags & FLV_AUDIO_CODECID_MASK);
flv->last_channels = channels = st->codec->channels; flv->last_sample_rate =
sample_rate = st->codec->sample_rate;
flv->last_channels =
channels = st->codec->channels;
} else { } else {
AVCodecContext ctx; AVCodecContext ctx;
ctx.sample_rate = sample_rate; ctx.sample_rate = sample_rate;
flv_set_audio_codec(s, st, &ctx, flags & FLV_AUDIO_CODECID_MASK); flv_set_audio_codec(s, st, &ctx, flags & FLV_AUDIO_CODECID_MASK);
sample_rate = ctx.sample_rate; sample_rate = ctx.sample_rate;
} }
} else if(stream_type == FLV_STREAM_TYPE_VIDEO) { } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {
size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK, 1); size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK, 1);
} }
...@@ -819,11 +887,13 @@ retry_duration: ...@@ -819,11 +887,13 @@ retry_duration:
int type = avio_r8(s->pb); int type = avio_r8(s->pb);
size--; size--;
if (st->codec->codec_id == AV_CODEC_ID_H264 || st->codec->codec_id == AV_CODEC_ID_MPEG4) { if (st->codec->codec_id == AV_CODEC_ID_H264 || st->codec->codec_id == AV_CODEC_ID_MPEG4) {
int32_t cts = (avio_rb24(s->pb)+0xff800000)^0xff800000; // sign extension // sign extension
int32_t cts = (avio_rb24(s->pb) + 0xff800000) ^ 0xff800000;
pts = dts + cts; pts = dts + cts;
if (cts < 0) { // dts are wrong if (cts < 0) { // dts are wrong
flv->wrong_dts = 1; flv->wrong_dts = 1;
av_log(s, AV_LOG_WARNING, "negative cts, previous timestamps might be wrong\n"); av_log(s, AV_LOG_WARNING,
"negative cts, previous timestamps might be wrong\n");
} }
if (flv->wrong_dts) if (flv->wrong_dts)
dts = AV_NOPTS_VALUE; dts = AV_NOPTS_VALUE;
...@@ -841,7 +911,7 @@ retry_duration: ...@@ -841,7 +911,7 @@ retry_duration:
MPEG4AudioConfig cfg; MPEG4AudioConfig cfg;
if (avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata, if (avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata,
st->codec->extradata_size * 8, 1) >= 0) { st->codec->extradata_size * 8, 1) >= 0) {
st->codec->channels = cfg.channels; st->codec->channels = cfg.channels;
st->codec->channel_layout = 0; st->codec->channel_layout = 0;
if (cfg.ext_sample_rate) if (cfg.ext_sample_rate)
st->codec->sample_rate = cfg.ext_sample_rate; st->codec->sample_rate = cfg.ext_sample_rate;
...@@ -863,11 +933,11 @@ retry_duration: ...@@ -863,11 +933,11 @@ retry_duration:
goto leave; goto leave;
} }
ret= av_get_packet(s->pb, pkt, size); ret = av_get_packet(s->pb, pkt, size);
if (ret < 0) if (ret < 0)
return ret; return ret;
pkt->dts = dts; pkt->dts = dts;
pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts; pkt->pts = pts == AV_NOPTS_VALUE ? dts : pts;
pkt->stream_index = st->index; pkt->stream_index = st->index;
if (flv->new_extradata[stream_type]) { if (flv->new_extradata[stream_type]) {
uint8_t *side = av_packet_new_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA, uint8_t *side = av_packet_new_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,
...@@ -879,8 +949,9 @@ retry_duration: ...@@ -879,8 +949,9 @@ retry_duration:
flv->new_extradata_size[stream_type] = 0; flv->new_extradata_size[stream_type] = 0;
} }
} }
if (stream_type == FLV_STREAM_TYPE_AUDIO && (sample_rate != flv->last_sample_rate || if (stream_type == FLV_STREAM_TYPE_AUDIO &&
channels != flv->last_channels)) { (sample_rate != flv->last_sample_rate ||
channels != flv->last_channels)) {
flv->last_sample_rate = sample_rate; flv->last_sample_rate = sample_rate;
flv->last_channels = channels; flv->last_channels = channels;
ff_add_param_change(pkt, channels, 0, sample_rate, 0, 0); ff_add_param_change(pkt, channels, 0, sample_rate, 0, 0);
...@@ -897,7 +968,7 @@ leave: ...@@ -897,7 +968,7 @@ leave:
} }
static int flv_read_seek(AVFormatContext *s, int stream_index, static int flv_read_seek(AVFormatContext *s, int stream_index,
int64_t ts, int flags) int64_t ts, int flags)
{ {
FLVContext *flv = s->priv_data; FLVContext *flv = s->priv_data;
flv->validate_count = 0; flv->validate_count = 0;
...@@ -907,7 +978,7 @@ static int flv_read_seek(AVFormatContext *s, int stream_index, ...@@ -907,7 +978,7 @@ static int flv_read_seek(AVFormatContext *s, int stream_index,
#define OFFSET(x) offsetof(FLVContext, x) #define OFFSET(x) offsetof(FLVContext, x)
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
static const AVOption options[] = { static const AVOption options[] = {
{ "flv_metadata", "Allocate streams according the onMetaData array", OFFSET(trust_metadata), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD}, { "flv_metadata", "Allocate streams according the onMetaData array", OFFSET(trust_metadata), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },
{ NULL } { NULL }
}; };
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment