3 * Copyright (c) 2003 The FFmpeg Project
5 * This demuxer will generate a 1 byte extradata for VP6F content.
7 * - upper 4bits: difference between encoded width and visible width
8 * - lower 4bits: difference between encoded height and visible height
10 * This file is part of FFmpeg.
12 * FFmpeg is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU Lesser General Public
14 * License as published by the Free Software Foundation; either
15 * version 2.1 of the License, or (at your option) any later version.
17 * FFmpeg is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * Lesser General Public License for more details.
22 * You should have received a copy of the GNU Lesser General Public
23 * License along with FFmpeg; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 #include "libavcodec/bytestream.h"
28 #include "libavcodec/mpeg4audio.h"
33 int wrong_dts
; ///< wrong dts due to negative cts
36 static int flv_probe(AVProbeData
*p
)
41 if (d
[0] == 'F' && d
[1] == 'L' && d
[2] == 'V' && d
[3] < 5 && d
[5]==0) {
42 return AVPROBE_SCORE_MAX
;
48 * Builds a Speex header.
49 * This is not needed for the libavcodec libspeex decoder, but is needed for
50 * stream copy and for decoders which require a header.
52 static void flv_build_speex_header(uint8_t *extradata
)
54 memset(extradata
, 0, 80);
55 bytestream_put_buffer(&extradata
, "Speex ", 8); // speex_string
56 bytestream_put_buffer(&extradata
, "1.2rc1", 6); // speex_version
57 extradata
+= 14; // speex_version padding
58 bytestream_put_le32(&extradata
, 1); // speex_version_id
59 bytestream_put_le32(&extradata
, 80); // header_size
60 bytestream_put_le32(&extradata
, 16000); // rate
61 bytestream_put_le32(&extradata
, 1); // mode
62 bytestream_put_le32(&extradata
, 4); // mode_bitstream_version
63 bytestream_put_le32(&extradata
, 1); // nb_channels
64 bytestream_put_le32(&extradata
, -1); // bitrate
65 bytestream_put_le32(&extradata
, 320); // frame_size
67 // frames_per_packet = 0
73 static void flv_set_audio_codec(AVFormatContext
*s
, AVStream
*astream
, int flv_codecid
) {
74 AVCodecContext
*acodec
= astream
->codec
;
76 //no distinction between S16 and S8 PCM codec flags
78 acodec
->codec_id
= acodec
->bits_per_coded_sample
== 8 ? CODEC_ID_PCM_S8
:
79 #ifdef WORDS_BIGENDIAN
85 case FLV_CODECID_PCM_LE
:
86 acodec
->codec_id
= acodec
->bits_per_coded_sample
== 8 ? CODEC_ID_PCM_S8
: CODEC_ID_PCM_S16LE
; break;
87 case FLV_CODECID_AAC
: acodec
->codec_id
= CODEC_ID_AAC
; break;
88 case FLV_CODECID_ADPCM
: acodec
->codec_id
= CODEC_ID_ADPCM_SWF
; break;
89 case FLV_CODECID_SPEEX
:
90 acodec
->codec_id
= CODEC_ID_SPEEX
;
91 acodec
->sample_rate
= 16000;
92 acodec
->extradata
= av_mallocz(80 + FF_INPUT_BUFFER_PADDING_SIZE
);
93 if (acodec
->extradata
) {
94 acodec
->extradata_size
= 80;
95 flv_build_speex_header(acodec
->extradata
);
97 av_log(s
, AV_LOG_WARNING
, "Unable to create Speex extradata\n");
100 case FLV_CODECID_MP3
: acodec
->codec_id
= CODEC_ID_MP3
; astream
->need_parsing
= AVSTREAM_PARSE_FULL
; break;
101 case FLV_CODECID_NELLYMOSER_8KHZ_MONO
:
102 acodec
->sample_rate
= 8000; //in case metadata does not otherwise declare samplerate
103 case FLV_CODECID_NELLYMOSER
:
104 acodec
->codec_id
= CODEC_ID_NELLYMOSER
;
107 av_log(s
, AV_LOG_INFO
, "Unsupported audio codec (%x)\n", flv_codecid
>> FLV_AUDIO_CODECID_OFFSET
);
108 acodec
->codec_tag
= flv_codecid
>> FLV_AUDIO_CODECID_OFFSET
;
112 static int flv_set_video_codec(AVFormatContext
*s
, AVStream
*vstream
, int flv_codecid
) {
113 AVCodecContext
*vcodec
= vstream
->codec
;
114 switch(flv_codecid
) {
115 case FLV_CODECID_H263
: vcodec
->codec_id
= CODEC_ID_FLV1
; break;
116 case FLV_CODECID_SCREEN
: vcodec
->codec_id
= CODEC_ID_FLASHSV
; break;
117 case FLV_CODECID_VP6
: vcodec
->codec_id
= CODEC_ID_VP6F
;
118 case FLV_CODECID_VP6A
:
119 if(flv_codecid
== FLV_CODECID_VP6A
)
120 vcodec
->codec_id
= CODEC_ID_VP6A
;
121 if(vcodec
->extradata_size
!= 1) {
122 vcodec
->extradata_size
= 1;
123 vcodec
->extradata
= av_malloc(1);
125 vcodec
->extradata
[0] = get_byte(s
->pb
);
126 return 1; // 1 byte body size adjustment for flv_read_packet()
127 case FLV_CODECID_H264
:
128 vcodec
->codec_id
= CODEC_ID_H264
;
129 return 3; // not 4, reading packet type will consume one byte
131 av_log(s
, AV_LOG_INFO
, "Unsupported video codec (%x)\n", flv_codecid
);
132 vcodec
->codec_tag
= flv_codecid
;
138 static int amf_get_string(ByteIOContext
*ioc
, char *buffer
, int buffsize
) {
139 int length
= get_be16(ioc
);
140 if(length
>= buffsize
) {
141 url_fskip(ioc
, length
);
145 get_buffer(ioc
, buffer
, length
);
147 buffer
[length
] = '\0';
152 static int amf_parse_object(AVFormatContext
*s
, AVStream
*astream
, AVStream
*vstream
, const char *key
, int64_t max_pos
, int depth
) {
153 AVCodecContext
*acodec
, *vcodec
;
155 AMFDataType amf_type
;
162 amf_type
= get_byte(ioc
);
165 case AMF_DATA_TYPE_NUMBER
:
166 num_val
= av_int2dbl(get_be64(ioc
)); break;
167 case AMF_DATA_TYPE_BOOL
:
168 num_val
= get_byte(ioc
); break;
169 case AMF_DATA_TYPE_STRING
:
170 if(amf_get_string(ioc
, str_val
, sizeof(str_val
)) < 0)
173 case AMF_DATA_TYPE_OBJECT
: {
176 while(url_ftell(ioc
) < max_pos
- 2 && (keylen
= get_be16(ioc
))) {
177 url_fskip(ioc
, keylen
); //skip key string
178 if(amf_parse_object(s
, NULL
, NULL
, NULL
, max_pos
, depth
+ 1) < 0)
179 return -1; //if we couldn't skip, bomb out.
181 if(get_byte(ioc
) != AMF_END_OF_OBJECT
)
185 case AMF_DATA_TYPE_NULL
:
186 case AMF_DATA_TYPE_UNDEFINED
:
187 case AMF_DATA_TYPE_UNSUPPORTED
:
188 break; //these take up no additional space
189 case AMF_DATA_TYPE_MIXEDARRAY
:
190 url_fskip(ioc
, 4); //skip 32-bit max array index
191 while(url_ftell(ioc
) < max_pos
- 2 && amf_get_string(ioc
, str_val
, sizeof(str_val
)) > 0) {
192 //this is the only case in which we would want a nested parse to not skip over the object
193 if(amf_parse_object(s
, astream
, vstream
, str_val
, max_pos
, depth
+ 1) < 0)
196 if(get_byte(ioc
) != AMF_END_OF_OBJECT
)
199 case AMF_DATA_TYPE_ARRAY
: {
200 unsigned int arraylen
, i
;
202 arraylen
= get_be32(ioc
);
203 for(i
= 0; i
< arraylen
&& url_ftell(ioc
) < max_pos
- 1; i
++) {
204 if(amf_parse_object(s
, NULL
, NULL
, NULL
, max_pos
, depth
+ 1) < 0)
205 return -1; //if we couldn't skip, bomb out.
209 case AMF_DATA_TYPE_DATE
:
210 url_fskip(ioc
, 8 + 2); //timestamp (double) and UTC offset (int16)
212 default: //unsupported type, we couldn't skip
216 if(depth
== 1 && key
) { //only look for metadata values when we are not nested and key != NULL
217 acodec
= astream
? astream
->codec
: NULL
;
218 vcodec
= vstream
? vstream
->codec
: NULL
;
220 if(amf_type
== AMF_DATA_TYPE_BOOL
) {
221 if(!strcmp(key
, "stereo") && acodec
) acodec
->channels
= num_val
> 0 ? 2 : 1;
222 } else if(amf_type
== AMF_DATA_TYPE_NUMBER
) {
223 if(!strcmp(key
, "duration")) s
->duration
= num_val
* AV_TIME_BASE
;
224 // else if(!strcmp(key, "width") && vcodec && num_val > 0) vcodec->width = num_val;
225 // else if(!strcmp(key, "height") && vcodec && num_val > 0) vcodec->height = num_val;
226 else if(!strcmp(key
, "videodatarate") && vcodec
&& 0 <= (int)(num_val
* 1024.0))
227 vcodec
->bit_rate
= num_val
* 1024.0;
228 else if(!strcmp(key
, "audiocodecid") && acodec
&& 0 <= (int)num_val
)
229 flv_set_audio_codec(s
, astream
, (int)num_val
<< FLV_AUDIO_CODECID_OFFSET
);
230 else if(!strcmp(key
, "videocodecid") && vcodec
&& 0 <= (int)num_val
)
231 flv_set_video_codec(s
, vstream
, (int)num_val
);
232 else if(!strcmp(key
, "audiosamplesize") && acodec
&& 0 < (int)num_val
) {
233 acodec
->bits_per_coded_sample
= num_val
;
234 //we may have to rewrite a previously read codecid because FLV only marks PCM endianness.
235 if(num_val
== 8 && (acodec
->codec_id
== CODEC_ID_PCM_S16BE
|| acodec
->codec_id
== CODEC_ID_PCM_S16LE
))
236 acodec
->codec_id
= CODEC_ID_PCM_S8
;
238 else if(!strcmp(key
, "audiosamplerate") && acodec
&& num_val
>= 0) {
239 //some tools, like FLVTool2, write consistently approximate metadata sample rates
240 if (!acodec
->sample_rate
) {
241 switch((int)num_val
) {
242 case 44000: acodec
->sample_rate
= 44100 ; break;
243 case 22000: acodec
->sample_rate
= 22050 ; break;
244 case 11000: acodec
->sample_rate
= 11025 ; break;
245 case 5000 : acodec
->sample_rate
= 5512 ; break;
246 default : acodec
->sample_rate
= num_val
;
256 static int flv_read_metabody(AVFormatContext
*s
, int64_t next_pos
) {
258 AVStream
*stream
, *astream
, *vstream
;
261 char buffer
[11]; //only needs to hold the string "onMetaData". Anything longer is something we don't want.
267 //first object needs to be "onMetaData" string
268 type
= get_byte(ioc
);
269 if(type
!= AMF_DATA_TYPE_STRING
|| amf_get_string(ioc
, buffer
, sizeof(buffer
)) < 0 || strcmp(buffer
, "onMetaData"))
272 //find the streams now so that amf_parse_object doesn't need to do the lookup every time it is called.
273 for(i
= 0; i
< s
->nb_streams
; i
++) {
274 stream
= s
->streams
[i
];
275 if (stream
->codec
->codec_type
== CODEC_TYPE_AUDIO
) astream
= stream
;
276 else if(stream
->codec
->codec_type
== CODEC_TYPE_VIDEO
) vstream
= stream
;
279 //parse the second object (we want a mixed array)
280 if(amf_parse_object(s
, astream
, vstream
, buffer
, next_pos
, 0) < 0)
286 static AVStream
*create_stream(AVFormatContext
*s
, int is_audio
){
287 AVStream
*st
= av_new_stream(s
, is_audio
);
290 st
->codec
->codec_type
= is_audio
? CODEC_TYPE_AUDIO
: CODEC_TYPE_VIDEO
;
291 av_set_pts_info(st
, 32, 1, 1000); /* 32 bit pts in ms */
295 static int flv_read_header(AVFormatContext
*s
,
296 AVFormatParameters
*ap
)
301 flags
= get_byte(s
->pb
);
302 /* old flvtool cleared this field */
303 /* FIXME: better fix needed */
305 flags
= FLV_HEADER_FLAG_HASVIDEO
| FLV_HEADER_FLAG_HASAUDIO
;
306 av_log(s
, AV_LOG_WARNING
, "Broken FLV file, which says no streams present, this might fail\n");
309 if((flags
& (FLV_HEADER_FLAG_HASVIDEO
|FLV_HEADER_FLAG_HASAUDIO
))
310 != (FLV_HEADER_FLAG_HASVIDEO
|FLV_HEADER_FLAG_HASAUDIO
))
311 s
->ctx_flags
|= AVFMTCTX_NOHEADER
;
313 if(flags
& FLV_HEADER_FLAG_HASVIDEO
){
314 if(!create_stream(s
, 0))
315 return AVERROR(ENOMEM
);
317 if(flags
& FLV_HEADER_FLAG_HASAUDIO
){
318 if(!create_stream(s
, 1))
319 return AVERROR(ENOMEM
);
322 offset
= get_be32(s
->pb
);
323 url_fseek(s
->pb
, offset
, SEEK_SET
);
330 static int flv_get_extradata(AVFormatContext
*s
, AVStream
*st
, int size
)
332 av_free(st
->codec
->extradata
);
333 st
->codec
->extradata
= av_mallocz(size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
334 if (!st
->codec
->extradata
)
335 return AVERROR(ENOMEM
);
336 st
->codec
->extradata_size
= size
;
337 get_buffer(s
->pb
, st
->codec
->extradata
, st
->codec
->extradata_size
);
341 static int flv_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
343 FLVContext
*flv
= s
->priv_data
;
344 int ret
, i
, type
, size
, flags
, is_audio
;
346 int64_t dts
, pts
= AV_NOPTS_VALUE
;
350 pos
= url_ftell(s
->pb
);
351 url_fskip(s
->pb
, 4); /* size of previous packet */
352 type
= get_byte(s
->pb
);
353 size
= get_be24(s
->pb
);
354 dts
= get_be24(s
->pb
);
355 dts
|= get_byte(s
->pb
) << 24;
356 // av_log(s, AV_LOG_DEBUG, "type:%d, size:%d, dts:%d\n", type, size, dts);
359 url_fskip(s
->pb
, 3); /* stream id, always 0 */
365 next
= size
+ url_ftell(s
->pb
);
367 if (type
== FLV_TAG_TYPE_AUDIO
) {
369 flags
= get_byte(s
->pb
);
371 } else if (type
== FLV_TAG_TYPE_VIDEO
) {
373 flags
= get_byte(s
->pb
);
375 if ((flags
& 0xf0) == 0x50) /* video info / command frame */
378 if (type
== FLV_TAG_TYPE_META
&& size
> 13+1+4 && 0)
379 flv_read_metabody(s
, next
);
380 else /* skip packet */
381 av_log(s
, AV_LOG_DEBUG
, "skipping flv packet: type %d, size %d, flags %d\n", type
, size
, flags
);
383 url_fseek(s
->pb
, next
, SEEK_SET
);
387 /* skip empty data packets */
391 /* now find stream */
392 for(i
=0;i
<s
->nb_streams
;i
++) {
394 if (st
->id
== is_audio
)
397 if(i
== s
->nb_streams
){
398 av_log(s
, AV_LOG_ERROR
, "invalid stream\n");
399 st
= create_stream(s
, is_audio
);
400 s
->ctx_flags
&= ~AVFMTCTX_NOHEADER
;
402 // av_log(s, AV_LOG_DEBUG, "%d %X %d \n", is_audio, flags, st->discard);
403 if( (st
->discard
>= AVDISCARD_NONKEY
&& !((flags
& FLV_VIDEO_FRAMETYPE_MASK
) == FLV_FRAME_KEY
|| is_audio
))
404 ||(st
->discard
>= AVDISCARD_BIDIR
&& ((flags
& FLV_VIDEO_FRAMETYPE_MASK
) == FLV_FRAME_DISP_INTER
&& !is_audio
))
405 || st
->discard
>= AVDISCARD_ALL
407 url_fseek(s
->pb
, next
, SEEK_SET
);
410 if ((flags
& FLV_VIDEO_FRAMETYPE_MASK
) == FLV_FRAME_KEY
)
411 av_add_index_entry(st
, pos
, dts
, size
, 0, AVINDEX_KEYFRAME
);
415 // if not streamed and no duration from metadata then seek to end to find the duration from the timestamps
416 if(!url_is_streamed(s
->pb
) && s
->duration
==AV_NOPTS_VALUE
){
418 const int64_t pos
= url_ftell(s
->pb
);
419 const int64_t fsize
= url_fsize(s
->pb
);
420 url_fseek(s
->pb
, fsize
-4, SEEK_SET
);
421 size
= get_be32(s
->pb
);
422 url_fseek(s
->pb
, fsize
-3-size
, SEEK_SET
);
423 if(size
== get_be24(s
->pb
) + 11){
424 s
->duration
= get_be24(s
->pb
) * (int64_t)AV_TIME_BASE
/ 1000;
426 url_fseek(s
->pb
, pos
, SEEK_SET
);
430 if(!st
->codec
->channels
|| !st
->codec
->sample_rate
|| !st
->codec
->bits_per_coded_sample
) {
431 st
->codec
->channels
= (flags
& FLV_AUDIO_CHANNEL_MASK
) == FLV_STEREO
? 2 : 1;
432 st
->codec
->sample_rate
= (44100 << ((flags
& FLV_AUDIO_SAMPLERATE_MASK
) >> FLV_AUDIO_SAMPLERATE_OFFSET
) >> 3);
433 st
->codec
->bits_per_coded_sample
= (flags
& FLV_AUDIO_SAMPLESIZE_MASK
) ? 16 : 8;
435 if(!st
->codec
->codec_id
){
436 flv_set_audio_codec(s
, st
, flags
& FLV_AUDIO_CODECID_MASK
);
439 size
-= flv_set_video_codec(s
, st
, flags
& FLV_VIDEO_CODECID_MASK
);
442 if (st
->codec
->codec_id
== CODEC_ID_AAC
||
443 st
->codec
->codec_id
== CODEC_ID_H264
) {
444 int type
= get_byte(s
->pb
);
446 if (st
->codec
->codec_id
== CODEC_ID_H264
) {
447 int32_t cts
= (get_be24(s
->pb
)+0xff800000)^0xff800000; // sign extension
449 if (cts
< 0) { // dts are wrong
451 av_log(s
, AV_LOG_WARNING
, "negative cts, previous timestamps might be wrong\n");
454 dts
= AV_NOPTS_VALUE
;
457 if ((ret
= flv_get_extradata(s
, st
, size
)) < 0)
459 if (st
->codec
->codec_id
== CODEC_ID_AAC
) {
460 MPEG4AudioConfig cfg
;
461 ff_mpeg4audio_get_config(&cfg
, st
->codec
->extradata
,
462 st
->codec
->extradata_size
);
463 if (cfg
.chan_config
> 7)
465 st
->codec
->channels
= ff_mpeg4audio_channels
[cfg
.chan_config
];
466 st
->codec
->sample_rate
= cfg
.sample_rate
;
467 dprintf(s
, "mp4a config channels %d sample rate %d\n",
468 st
->codec
->channels
, st
->codec
->sample_rate
);
471 return AVERROR(EAGAIN
);
475 /* skip empty data packets */
477 return AVERROR(EAGAIN
);
479 ret
= av_get_packet(s
->pb
, pkt
, size
);
483 /* note: we need to modify the packet size here to handle the last
487 pkt
->pts
= pts
== AV_NOPTS_VALUE
? dts
: pts
;
488 pkt
->stream_index
= st
->index
;
490 if (is_audio
|| ((flags
& FLV_VIDEO_FRAMETYPE_MASK
) == FLV_FRAME_KEY
))
491 pkt
->flags
|= PKT_FLAG_KEY
;
496 AVInputFormat flv_demuxer
= {
498 NULL_IF_CONFIG_SMALL("FLV format"),
504 .value
= CODEC_ID_FLV1
,