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 "libavutil/avstring.h"
28 #include "libavutil/channel_layout.h"
29 #include "libavutil/dict.h"
30 #include "libavutil/opt.h"
31 #include "libavutil/intfloat.h"
32 #include "libavutil/mathematics.h"
33 #include "libavcodec/bytestream.h"
34 #include "libavcodec/mpeg4audio.h"
37 #include "avio_internal.h"
40 #define VALIDATE_INDEX_TS_THRESH 2500
43 const AVClass
*class; ///< Class for private options.
44 int trust_metadata
; ///< configure streams according onMetaData
45 int wrong_dts
; ///< wrong dts due to negative cts
46 uint8_t *new_extradata
[FLV_STREAM_TYPE_NB
];
47 int new_extradata_size
[FLV_STREAM_TYPE_NB
];
59 static int probe(AVProbeData
*p
, int live
)
61 const uint8_t *d
= p
->buf
;
62 unsigned offset
= AV_RB32(d
+ 5);
67 d
[3] < 5 && d
[5] == 0 &&
68 offset
+ 100 < p
->buf_size
&&
70 int is_live
= !memcmp(d
+ offset
+ 40, "NGINX RTMP", 10);
73 return AVPROBE_SCORE_MAX
;
78 static int flv_probe(AVProbeData
*p
)
83 static int live_flv_probe(AVProbeData
*p
)
88 static AVStream
*create_stream(AVFormatContext
*s
, int codec_type
)
90 AVStream
*st
= avformat_new_stream(s
, NULL
);
93 st
->codec
->codec_type
= codec_type
;
94 if (s
->nb_streams
>=3 ||( s
->nb_streams
==2
95 && s
->streams
[0]->codec
->codec_type
!= AVMEDIA_TYPE_DATA
96 && s
->streams
[1]->codec
->codec_type
!= AVMEDIA_TYPE_DATA
))
97 s
->ctx_flags
&= ~AVFMTCTX_NOHEADER
;
99 avpriv_set_pts_info(st
, 32, 1, 1000); /* 32 bit pts in ms */
103 static int flv_same_audio_codec(AVCodecContext
*acodec
, int flags
)
105 int bits_per_coded_sample
= (flags
& FLV_AUDIO_SAMPLESIZE_MASK
) ? 16 : 8;
106 int flv_codecid
= flags
& FLV_AUDIO_CODECID_MASK
;
109 if (!acodec
->codec_id
&& !acodec
->codec_tag
)
112 if (acodec
->bits_per_coded_sample
!= bits_per_coded_sample
)
115 switch (flv_codecid
) {
116 // no distinction between S16 and S8 PCM codec flags
117 case FLV_CODECID_PCM
:
118 codec_id
= bits_per_coded_sample
== 8
121 : AV_CODEC_ID_PCM_S16BE
;
123 : AV_CODEC_ID_PCM_S16LE
;
125 return codec_id
== acodec
->codec_id
;
126 case FLV_CODECID_PCM_LE
:
127 codec_id
= bits_per_coded_sample
== 8
129 : AV_CODEC_ID_PCM_S16LE
;
130 return codec_id
== acodec
->codec_id
;
131 case FLV_CODECID_AAC
:
132 return acodec
->codec_id
== AV_CODEC_ID_AAC
;
133 case FLV_CODECID_ADPCM
:
134 return acodec
->codec_id
== AV_CODEC_ID_ADPCM_SWF
;
135 case FLV_CODECID_SPEEX
:
136 return acodec
->codec_id
== AV_CODEC_ID_SPEEX
;
137 case FLV_CODECID_MP3
:
138 return acodec
->codec_id
== AV_CODEC_ID_MP3
;
139 case FLV_CODECID_NELLYMOSER_8KHZ_MONO
:
140 case FLV_CODECID_NELLYMOSER_16KHZ_MONO
:
141 case FLV_CODECID_NELLYMOSER
:
142 return acodec
->codec_id
== AV_CODEC_ID_NELLYMOSER
;
143 case FLV_CODECID_PCM_MULAW
:
144 return acodec
->sample_rate
== 8000 &&
145 acodec
->codec_id
== AV_CODEC_ID_PCM_MULAW
;
146 case FLV_CODECID_PCM_ALAW
:
147 return acodec
->sample_rate
== 8000 &&
148 acodec
->codec_id
== AV_CODEC_ID_PCM_ALAW
;
150 return acodec
->codec_tag
== (flv_codecid
>> FLV_AUDIO_CODECID_OFFSET
);
154 static void flv_set_audio_codec(AVFormatContext
*s
, AVStream
*astream
,
155 AVCodecContext
*acodec
, int flv_codecid
)
157 switch (flv_codecid
) {
158 // no distinction between S16 and S8 PCM codec flags
159 case FLV_CODECID_PCM
:
160 acodec
->codec_id
= acodec
->bits_per_coded_sample
== 8
163 : AV_CODEC_ID_PCM_S16BE
;
165 : AV_CODEC_ID_PCM_S16LE
;
168 case FLV_CODECID_PCM_LE
:
169 acodec
->codec_id
= acodec
->bits_per_coded_sample
== 8
171 : AV_CODEC_ID_PCM_S16LE
;
173 case FLV_CODECID_AAC
:
174 acodec
->codec_id
= AV_CODEC_ID_AAC
;
176 case FLV_CODECID_ADPCM
:
177 acodec
->codec_id
= AV_CODEC_ID_ADPCM_SWF
;
179 case FLV_CODECID_SPEEX
:
180 acodec
->codec_id
= AV_CODEC_ID_SPEEX
;
181 acodec
->sample_rate
= 16000;
183 case FLV_CODECID_MP3
:
184 acodec
->codec_id
= AV_CODEC_ID_MP3
;
185 astream
->need_parsing
= AVSTREAM_PARSE_FULL
;
187 case FLV_CODECID_NELLYMOSER_8KHZ_MONO
:
188 // in case metadata does not otherwise declare samplerate
189 acodec
->sample_rate
= 8000;
190 acodec
->codec_id
= AV_CODEC_ID_NELLYMOSER
;
192 case FLV_CODECID_NELLYMOSER_16KHZ_MONO
:
193 acodec
->sample_rate
= 16000;
194 acodec
->codec_id
= AV_CODEC_ID_NELLYMOSER
;
196 case FLV_CODECID_NELLYMOSER
:
197 acodec
->codec_id
= AV_CODEC_ID_NELLYMOSER
;
199 case FLV_CODECID_PCM_MULAW
:
200 acodec
->sample_rate
= 8000;
201 acodec
->codec_id
= AV_CODEC_ID_PCM_MULAW
;
203 case FLV_CODECID_PCM_ALAW
:
204 acodec
->sample_rate
= 8000;
205 acodec
->codec_id
= AV_CODEC_ID_PCM_ALAW
;
208 avpriv_request_sample(s
, "Audio codec (%x)",
209 flv_codecid
>> FLV_AUDIO_CODECID_OFFSET
);
210 acodec
->codec_tag
= flv_codecid
>> FLV_AUDIO_CODECID_OFFSET
;
214 static int flv_same_video_codec(AVCodecContext
*vcodec
, int flags
)
216 int flv_codecid
= flags
& FLV_VIDEO_CODECID_MASK
;
218 if (!vcodec
->codec_id
&& !vcodec
->codec_tag
)
221 switch (flv_codecid
) {
222 case FLV_CODECID_H263
:
223 return vcodec
->codec_id
== AV_CODEC_ID_FLV1
;
224 case FLV_CODECID_SCREEN
:
225 return vcodec
->codec_id
== AV_CODEC_ID_FLASHSV
;
226 case FLV_CODECID_SCREEN2
:
227 return vcodec
->codec_id
== AV_CODEC_ID_FLASHSV2
;
228 case FLV_CODECID_VP6
:
229 return vcodec
->codec_id
== AV_CODEC_ID_VP6F
;
230 case FLV_CODECID_VP6A
:
231 return vcodec
->codec_id
== AV_CODEC_ID_VP6A
;
232 case FLV_CODECID_H264
:
233 return vcodec
->codec_id
== AV_CODEC_ID_H264
;
235 return vcodec
->codec_tag
== flv_codecid
;
239 static int flv_set_video_codec(AVFormatContext
*s
, AVStream
*vstream
,
240 int flv_codecid
, int read
)
242 AVCodecContext
*vcodec
= vstream
->codec
;
243 switch (flv_codecid
) {
244 case FLV_CODECID_H263
:
245 vcodec
->codec_id
= AV_CODEC_ID_FLV1
;
247 case FLV_CODECID_REALH263
:
248 vcodec
->codec_id
= AV_CODEC_ID_H263
;
249 break; // Really mean it this time
250 case FLV_CODECID_SCREEN
:
251 vcodec
->codec_id
= AV_CODEC_ID_FLASHSV
;
253 case FLV_CODECID_SCREEN2
:
254 vcodec
->codec_id
= AV_CODEC_ID_FLASHSV2
;
256 case FLV_CODECID_VP6
:
257 vcodec
->codec_id
= AV_CODEC_ID_VP6F
;
258 case FLV_CODECID_VP6A
:
259 if (flv_codecid
== FLV_CODECID_VP6A
)
260 vcodec
->codec_id
= AV_CODEC_ID_VP6A
;
262 if (vcodec
->extradata_size
!= 1) {
263 ff_alloc_extradata(vcodec
, 1);
265 if (vcodec
->extradata
)
266 vcodec
->extradata
[0] = avio_r8(s
->pb
);
270 return 1; // 1 byte body size adjustment for flv_read_packet()
271 case FLV_CODECID_H264
:
272 vcodec
->codec_id
= AV_CODEC_ID_H264
;
273 vstream
->need_parsing
= AVSTREAM_PARSE_HEADERS
;
274 return 3; // not 4, reading packet type will consume one byte
275 case FLV_CODECID_MPEG4
:
276 vcodec
->codec_id
= AV_CODEC_ID_MPEG4
;
279 avpriv_request_sample(s
, "Video codec (%x)", flv_codecid
);
280 vcodec
->codec_tag
= flv_codecid
;
286 static int amf_get_string(AVIOContext
*ioc
, char *buffer
, int buffsize
)
288 int length
= avio_rb16(ioc
);
289 if (length
>= buffsize
) {
290 avio_skip(ioc
, length
);
294 avio_read(ioc
, buffer
, length
);
296 buffer
[length
] = '\0';
301 static int parse_keyframes_index(AVFormatContext
*s
, AVIOContext
*ioc
,
302 AVStream
*vstream
, int64_t max_pos
)
304 FLVContext
*flv
= s
->priv_data
;
305 unsigned int timeslen
= 0, fileposlen
= 0, i
;
307 int64_t *times
= NULL
;
308 int64_t *filepositions
= NULL
;
309 int ret
= AVERROR(ENOSYS
);
310 int64_t initial_pos
= avio_tell(ioc
);
312 if (vstream
->nb_index_entries
>0) {
313 av_log(s
, AV_LOG_WARNING
, "Skipping duplicate index\n");
317 if (s
->flags
& AVFMT_FLAG_IGNIDX
)
320 while (avio_tell(ioc
) < max_pos
- 2 &&
321 amf_get_string(ioc
, str_val
, sizeof(str_val
)) > 0) {
322 int64_t **current_array
;
323 unsigned int arraylen
;
325 // Expect array object in context
326 if (avio_r8(ioc
) != AMF_DATA_TYPE_ARRAY
)
329 arraylen
= avio_rb32(ioc
);
333 if (!strcmp(KEYFRAMES_TIMESTAMP_TAG
, str_val
) && !times
) {
334 current_array
= ×
;
336 } else if (!strcmp(KEYFRAMES_BYTEOFFSET_TAG
, str_val
) &&
338 current_array
= &filepositions
;
339 fileposlen
= arraylen
;
341 // unexpected metatag inside keyframes, will not use such
342 // metadata for indexing
345 if (!(*current_array
= av_mallocz(sizeof(**current_array
) * arraylen
))) {
346 ret
= AVERROR(ENOMEM
);
350 for (i
= 0; i
< arraylen
&& avio_tell(ioc
) < max_pos
- 1; i
++) {
351 if (avio_r8(ioc
) != AMF_DATA_TYPE_NUMBER
)
353 current_array
[0][i
] = av_int2double(avio_rb64(ioc
));
355 if (times
&& filepositions
) {
356 // All done, exiting at a position allowing amf_parse_object
357 // to finish parsing the object
363 if (timeslen
== fileposlen
&& fileposlen
>1 && max_pos
<= filepositions
[0]) {
364 for (i
= 0; i
< fileposlen
; i
++) {
365 av_add_index_entry(vstream
, filepositions
[i
], times
[i
] * 1000,
366 0, 0, AVINDEX_KEYFRAME
);
368 flv
->validate_index
[i
].pos
= filepositions
[i
];
369 flv
->validate_index
[i
].dts
= times
[i
] * 1000;
370 flv
->validate_count
= i
+ 1;
375 av_log(s
, AV_LOG_WARNING
, "Invalid keyframes object, skipping.\n");
380 av_freep(&filepositions
);
381 avio_seek(ioc
, initial_pos
, SEEK_SET
);
385 static int amf_parse_object(AVFormatContext
*s
, AVStream
*astream
,
386 AVStream
*vstream
, const char *key
,
387 int64_t max_pos
, int depth
)
389 AVCodecContext
*acodec
, *vcodec
;
390 FLVContext
*flv
= s
->priv_data
;
392 AMFDataType amf_type
;
398 amf_type
= avio_r8(ioc
);
401 case AMF_DATA_TYPE_NUMBER
:
402 num_val
= av_int2double(avio_rb64(ioc
));
404 case AMF_DATA_TYPE_BOOL
:
405 num_val
= avio_r8(ioc
);
407 case AMF_DATA_TYPE_STRING
:
408 if (amf_get_string(ioc
, str_val
, sizeof(str_val
)) < 0)
411 case AMF_DATA_TYPE_OBJECT
:
412 if ((vstream
|| astream
) && key
&&
414 !strcmp(KEYFRAMES_TAG
, key
) && depth
== 1)
415 if (parse_keyframes_index(s
, ioc
, vstream
? vstream
: astream
,
417 av_log(s
, AV_LOG_ERROR
, "Keyframe index parsing failed\n");
419 while (avio_tell(ioc
) < max_pos
- 2 &&
420 amf_get_string(ioc
, str_val
, sizeof(str_val
)) > 0)
421 if (amf_parse_object(s
, astream
, vstream
, str_val
, max_pos
,
423 return -1; // if we couldn't skip, bomb out.
424 if (avio_r8(ioc
) != AMF_END_OF_OBJECT
)
427 case AMF_DATA_TYPE_NULL
:
428 case AMF_DATA_TYPE_UNDEFINED
:
429 case AMF_DATA_TYPE_UNSUPPORTED
:
430 break; // these take up no additional space
431 case AMF_DATA_TYPE_MIXEDARRAY
:
432 avio_skip(ioc
, 4); // skip 32-bit max array index
433 while (avio_tell(ioc
) < max_pos
- 2 &&
434 amf_get_string(ioc
, str_val
, sizeof(str_val
)) > 0)
435 // this is the only case in which we would want a nested
436 // parse to not skip over the object
437 if (amf_parse_object(s
, astream
, vstream
, str_val
, max_pos
,
440 if (avio_r8(ioc
) != AMF_END_OF_OBJECT
)
443 case AMF_DATA_TYPE_ARRAY
:
445 unsigned int arraylen
, i
;
447 arraylen
= avio_rb32(ioc
);
448 for (i
= 0; i
< arraylen
&& avio_tell(ioc
) < max_pos
- 1; i
++)
449 if (amf_parse_object(s
, NULL
, NULL
, NULL
, max_pos
,
451 return -1; // if we couldn't skip, bomb out.
454 case AMF_DATA_TYPE_DATE
:
455 avio_skip(ioc
, 8 + 2); // timestamp (double) and UTC offset (int16)
457 default: // unsupported type, we couldn't skip
462 // stream info doesn't live any deeper than the first object
464 acodec
= astream
? astream
->codec
: NULL
;
465 vcodec
= vstream
? vstream
->codec
: NULL
;
467 if (amf_type
== AMF_DATA_TYPE_NUMBER
||
468 amf_type
== AMF_DATA_TYPE_BOOL
) {
469 if (!strcmp(key
, "duration"))
470 s
->duration
= num_val
* AV_TIME_BASE
;
471 else if (!strcmp(key
, "videodatarate") && vcodec
&&
472 0 <= (int)(num_val
* 1024.0))
473 vcodec
->bit_rate
= num_val
* 1024.0;
474 else if (!strcmp(key
, "audiodatarate") && acodec
&&
475 0 <= (int)(num_val
* 1024.0))
476 acodec
->bit_rate
= num_val
* 1024.0;
477 else if (!strcmp(key
, "datastream")) {
478 AVStream
*st
= create_stream(s
, AVMEDIA_TYPE_DATA
);
480 return AVERROR(ENOMEM
);
481 st
->codec
->codec_id
= AV_CODEC_ID_TEXT
;
482 } else if (flv
->trust_metadata
) {
483 if (!strcmp(key
, "videocodecid") && vcodec
) {
484 flv_set_video_codec(s
, vstream
, num_val
, 0);
485 } else if (!strcmp(key
, "audiocodecid") && acodec
) {
486 int id
= ((int)num_val
) << FLV_AUDIO_CODECID_OFFSET
;
487 flv_set_audio_codec(s
, astream
, acodec
, id
);
488 } else if (!strcmp(key
, "audiosamplerate") && acodec
) {
489 acodec
->sample_rate
= num_val
;
490 } else if (!strcmp(key
, "audiosamplesize") && acodec
) {
491 acodec
->bits_per_coded_sample
= num_val
;
492 } else if (!strcmp(key
, "stereo") && acodec
) {
493 acodec
->channels
= num_val
+ 1;
494 acodec
->channel_layout
= acodec
->channels
== 2 ?
495 AV_CH_LAYOUT_STEREO
:
497 } else if (!strcmp(key
, "width") && vcodec
) {
498 vcodec
->width
= num_val
;
499 } else if (!strcmp(key
, "height") && vcodec
) {
500 vcodec
->height
= num_val
;
506 if (amf_type
== AMF_DATA_TYPE_OBJECT
&& s
->nb_streams
== 1 &&
507 ((!acodec
&& !strcmp(key
, "audiocodecid")) ||
508 (!vcodec
&& !strcmp(key
, "videocodecid"))))
509 s
->ctx_flags
&= ~AVFMTCTX_NOHEADER
; //If there is either audio/video missing, codecid will be an empty object
511 if (!strcmp(key
, "duration") ||
512 !strcmp(key
, "filesize") ||
513 !strcmp(key
, "width") ||
514 !strcmp(key
, "height") ||
515 !strcmp(key
, "videodatarate") ||
516 !strcmp(key
, "framerate") ||
517 !strcmp(key
, "videocodecid") ||
518 !strcmp(key
, "audiodatarate") ||
519 !strcmp(key
, "audiosamplerate") ||
520 !strcmp(key
, "audiosamplesize") ||
521 !strcmp(key
, "stereo") ||
522 !strcmp(key
, "audiocodecid") ||
523 !strcmp(key
, "datastream"))
526 s
->event_flags
|= AVFMT_EVENT_FLAG_METADATA_UPDATED
;
527 if (amf_type
== AMF_DATA_TYPE_BOOL
) {
528 av_strlcpy(str_val
, num_val
> 0 ? "true" : "false",
530 av_dict_set(&s
->metadata
, key
, str_val
, 0);
531 } else if (amf_type
== AMF_DATA_TYPE_NUMBER
) {
532 snprintf(str_val
, sizeof(str_val
), "%.f", num_val
);
533 av_dict_set(&s
->metadata
, key
, str_val
, 0);
534 } else if (amf_type
== AMF_DATA_TYPE_STRING
)
535 av_dict_set(&s
->metadata
, key
, str_val
, 0);
541 static int flv_read_metabody(AVFormatContext
*s
, int64_t next_pos
)
544 AVStream
*stream
, *astream
, *vstream
;
545 AVStream av_unused
*dstream
;
548 // only needs to hold the string "onMetaData".
549 // Anything longer is something we don't want.
557 // first object needs to be "onMetaData" string
559 if (type
!= AMF_DATA_TYPE_STRING
||
560 amf_get_string(ioc
, buffer
, sizeof(buffer
)) < 0)
563 if (!strcmp(buffer
, "onTextData"))
566 if (strcmp(buffer
, "onMetaData") && strcmp(buffer
, "onCuePoint"))
569 // find the streams now so that amf_parse_object doesn't need to do
570 // the lookup every time it is called.
571 for (i
= 0; i
< s
->nb_streams
; i
++) {
572 stream
= s
->streams
[i
];
573 if (stream
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
)
575 else if (stream
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
)
577 else if (stream
->codec
->codec_type
== AVMEDIA_TYPE_DATA
)
581 // parse the second object (we want a mixed array)
582 if (amf_parse_object(s
, astream
, vstream
, buffer
, next_pos
, 0) < 0)
588 static int flv_read_header(AVFormatContext
*s
)
593 flags
= avio_r8(s
->pb
);
595 s
->ctx_flags
|= AVFMTCTX_NOHEADER
;
597 if (flags
& FLV_HEADER_FLAG_HASVIDEO
)
598 if (!create_stream(s
, AVMEDIA_TYPE_VIDEO
))
599 return AVERROR(ENOMEM
);
600 if (flags
& FLV_HEADER_FLAG_HASAUDIO
)
601 if (!create_stream(s
, AVMEDIA_TYPE_AUDIO
))
602 return AVERROR(ENOMEM
);
603 // Flag doesn't indicate whether or not there is script-data present. Must
604 // create that stream if it's encountered.
606 offset
= avio_rb32(s
->pb
);
607 avio_seek(s
->pb
, offset
, SEEK_SET
);
615 static int flv_read_close(AVFormatContext
*s
)
618 FLVContext
*flv
= s
->priv_data
;
619 for (i
=0; i
<FLV_STREAM_TYPE_NB
; i
++)
620 av_freep(&flv
->new_extradata
[i
]);
624 static int flv_get_extradata(AVFormatContext
*s
, AVStream
*st
, int size
)
626 av_free(st
->codec
->extradata
);
627 if (ff_get_extradata(st
->codec
, s
->pb
, size
) < 0)
628 return AVERROR(ENOMEM
);
632 static int flv_queue_extradata(FLVContext
*flv
, AVIOContext
*pb
, int stream
,
635 av_free(flv
->new_extradata
[stream
]);
636 flv
->new_extradata
[stream
] = av_mallocz(size
+
637 FF_INPUT_BUFFER_PADDING_SIZE
);
638 if (!flv
->new_extradata
[stream
])
639 return AVERROR(ENOMEM
);
640 flv
->new_extradata_size
[stream
] = size
;
641 avio_read(pb
, flv
->new_extradata
[stream
], size
);
645 static void clear_index_entries(AVFormatContext
*s
, int64_t pos
)
648 av_log(s
, AV_LOG_WARNING
,
649 "Found invalid index entries, clearing the index.\n");
650 for (i
= 0; i
< s
->nb_streams
; i
++) {
651 AVStream
*st
= s
->streams
[i
];
652 /* Remove all index entries that point to >= pos */
654 for (j
= 0; j
< st
->nb_index_entries
; j
++)
655 if (st
->index_entries
[j
].pos
< pos
)
656 st
->index_entries
[out
++] = st
->index_entries
[j
];
657 st
->nb_index_entries
= out
;
661 static int amf_skip_tag(AVIOContext
*pb
, AMFDataType type
)
663 int nb
= -1, ret
, parse_name
= 1;
666 case AMF_DATA_TYPE_NUMBER
:
669 case AMF_DATA_TYPE_BOOL
:
672 case AMF_DATA_TYPE_STRING
:
673 avio_skip(pb
, avio_rb16(pb
));
675 case AMF_DATA_TYPE_ARRAY
:
677 case AMF_DATA_TYPE_MIXEDARRAY
:
679 case AMF_DATA_TYPE_OBJECT
:
680 while(!pb
->eof_reached
&& (nb
-- > 0 || type
!= AMF_DATA_TYPE_ARRAY
)) {
682 int size
= avio_rb16(pb
);
689 if ((ret
= amf_skip_tag(pb
, avio_r8(pb
))) < 0)
693 case AMF_DATA_TYPE_NULL
:
694 case AMF_DATA_TYPE_OBJECT_END
:
697 return AVERROR_INVALIDDATA
;
702 static int flv_data_packet(AVFormatContext
*s
, AVPacket
*pkt
,
703 int64_t dts
, int64_t next
)
705 AVIOContext
*pb
= s
->pb
;
708 int ret
= AVERROR_INVALIDDATA
;
711 switch (avio_r8(pb
)) {
712 case AMF_DATA_TYPE_MIXEDARRAY
:
713 avio_seek(pb
, 4, SEEK_CUR
);
714 case AMF_DATA_TYPE_OBJECT
:
720 while ((ret
= amf_get_string(pb
, buf
, sizeof(buf
))) > 0) {
721 AMFDataType type
= avio_r8(pb
);
722 if (type
== AMF_DATA_TYPE_STRING
&& !strcmp(buf
, "text")) {
723 length
= avio_rb16(pb
);
724 ret
= av_get_packet(pb
, pkt
, length
);
730 if ((ret
= amf_skip_tag(pb
, type
)) < 0)
736 ret
= AVERROR_INVALIDDATA
;
740 for (i
= 0; i
< s
->nb_streams
; i
++) {
742 if (st
->codec
->codec_type
== AVMEDIA_TYPE_DATA
)
746 if (i
== s
->nb_streams
) {
747 st
= create_stream(s
, AVMEDIA_TYPE_DATA
);
749 return AVERROR(ENOMEM
);
750 st
->codec
->codec_id
= AV_CODEC_ID_TEXT
;
757 pkt
->stream_index
= st
->index
;
758 pkt
->flags
|= AV_PKT_FLAG_KEY
;
761 avio_seek(s
->pb
, next
+ 4, SEEK_SET
);
766 static int flv_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
768 FLVContext
*flv
= s
->priv_data
;
769 int ret
, i
, type
, size
, flags
;
771 int64_t next
, pos
, meta_pos
;
772 int64_t dts
, pts
= AV_NOPTS_VALUE
;
773 int av_uninit(channels
);
774 int av_uninit(sample_rate
);
777 /* pkt size is repeated at end. skip it */
778 for (;; avio_skip(s
->pb
, 4)) {
779 pos
= avio_tell(s
->pb
);
780 type
= (avio_r8(s
->pb
) & 0x1F);
781 size
= avio_rb24(s
->pb
);
782 dts
= avio_rb24(s
->pb
);
783 dts
|= avio_r8(s
->pb
) << 24;
784 av_dlog(s
, "type:%d, size:%d, dts:%"PRId64
" pos:%"PRId64
"\n", type
, size
, dts
, avio_tell(s
->pb
));
785 if (avio_feof(s
->pb
))
787 avio_skip(s
->pb
, 3); /* stream id, always 0 */
790 if (flv
->validate_next
< flv
->validate_count
) {
791 int64_t validate_pos
= flv
->validate_index
[flv
->validate_next
].pos
;
792 if (pos
== validate_pos
) {
793 if (FFABS(dts
- flv
->validate_index
[flv
->validate_next
].dts
) <=
794 VALIDATE_INDEX_TS_THRESH
) {
795 flv
->validate_next
++;
797 clear_index_entries(s
, validate_pos
);
798 flv
->validate_count
= 0;
800 } else if (pos
> validate_pos
) {
801 clear_index_entries(s
, validate_pos
);
802 flv
->validate_count
= 0;
809 next
= size
+ avio_tell(s
->pb
);
811 if (type
== FLV_TAG_TYPE_AUDIO
) {
812 stream_type
= FLV_STREAM_TYPE_AUDIO
;
813 flags
= avio_r8(s
->pb
);
815 } else if (type
== FLV_TAG_TYPE_VIDEO
) {
816 stream_type
= FLV_STREAM_TYPE_VIDEO
;
817 flags
= avio_r8(s
->pb
);
819 if ((flags
& FLV_VIDEO_FRAMETYPE_MASK
) == FLV_FRAME_VIDEO_INFO_CMD
)
821 } else if (type
== FLV_TAG_TYPE_META
) {
822 stream_type
=FLV_STREAM_TYPE_DATA
;
823 if (size
> 13 + 1 + 4 && dts
== 0) { // Header-type metadata stuff
824 meta_pos
= avio_tell(s
->pb
);
825 if (flv_read_metabody(s
, next
) == 0) {
828 avio_seek(s
->pb
, meta_pos
, SEEK_SET
);
831 av_log(s
, AV_LOG_DEBUG
,
832 "Skipping flv packet: type %d, size %d, flags %d.\n",
835 avio_seek(s
->pb
, next
, SEEK_SET
);
839 /* skip empty data packets */
843 /* now find stream */
844 for (i
= 0; i
< s
->nb_streams
; i
++) {
846 if (stream_type
== FLV_STREAM_TYPE_AUDIO
) {
847 if (st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
&&
848 (s
->audio_codec_id
|| flv_same_audio_codec(st
->codec
, flags
)))
850 } else if (stream_type
== FLV_STREAM_TYPE_VIDEO
) {
851 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
&&
852 (s
->video_codec_id
|| flv_same_video_codec(st
->codec
, flags
)))
854 } else if (stream_type
== FLV_STREAM_TYPE_DATA
) {
855 if (st
->codec
->codec_type
== AVMEDIA_TYPE_DATA
)
859 if (i
== s
->nb_streams
) {
860 static const enum AVMediaType stream_types
[] = {AVMEDIA_TYPE_VIDEO
, AVMEDIA_TYPE_AUDIO
, AVMEDIA_TYPE_DATA
};
861 av_log(s
, AV_LOG_WARNING
, "Stream discovered after head already parsed\n");
862 st
= create_stream(s
, stream_types
[stream_type
]);
864 return AVERROR(ENOMEM
);
867 av_dlog(s
, "%d %X %d \n", stream_type
, flags
, st
->discard
);
869 if ((flags
& FLV_VIDEO_FRAMETYPE_MASK
) == FLV_FRAME_KEY
||
870 stream_type
== FLV_STREAM_TYPE_AUDIO
)
871 av_add_index_entry(st
, pos
, dts
, size
, 0, AVINDEX_KEYFRAME
);
873 if ( (st
->discard
>= AVDISCARD_NONKEY
&& !((flags
& FLV_VIDEO_FRAMETYPE_MASK
) == FLV_FRAME_KEY
|| (stream_type
== FLV_STREAM_TYPE_AUDIO
)))
874 ||(st
->discard
>= AVDISCARD_BIDIR
&& ((flags
& FLV_VIDEO_FRAMETYPE_MASK
) == FLV_FRAME_DISP_INTER
&& (stream_type
== FLV_STREAM_TYPE_VIDEO
)))
875 || st
->discard
>= AVDISCARD_ALL
877 avio_seek(s
->pb
, next
, SEEK_SET
);
883 // if not streamed and no duration from metadata then seek to end to find
884 // the duration from the timestamps
885 if (s
->pb
->seekable
&& (!s
->duration
|| s
->duration
== AV_NOPTS_VALUE
) && !flv
->searched_for_end
) {
887 const int64_t pos
= avio_tell(s
->pb
);
888 // Read the last 4 bytes of the file, this should be the size of the
889 // previous FLV tag. Use the timestamp of its payload as duration.
890 int64_t fsize
= avio_size(s
->pb
);
892 avio_seek(s
->pb
, fsize
- 4, SEEK_SET
);
893 size
= avio_rb32(s
->pb
);
894 // Seek to the start of the last FLV tag at position (fsize - 4 - size)
895 // but skip the byte indicating the type.
896 avio_seek(s
->pb
, fsize
- 3 - size
, SEEK_SET
);
897 if (size
== avio_rb24(s
->pb
) + 11) {
898 uint32_t ts
= avio_rb24(s
->pb
);
899 ts
|= avio_r8(s
->pb
) << 24;
901 s
->duration
= ts
* (int64_t)AV_TIME_BASE
/ 1000;
902 else if (fsize
>= 8 && fsize
- 8 >= size
) {
908 avio_seek(s
->pb
, pos
, SEEK_SET
);
909 flv
->searched_for_end
= 1;
912 if (stream_type
== FLV_STREAM_TYPE_AUDIO
) {
913 int bits_per_coded_sample
;
914 channels
= (flags
& FLV_AUDIO_CHANNEL_MASK
) == FLV_STEREO
? 2 : 1;
915 sample_rate
= 44100 << ((flags
& FLV_AUDIO_SAMPLERATE_MASK
) >>
916 FLV_AUDIO_SAMPLERATE_OFFSET
) >> 3;
917 bits_per_coded_sample
= (flags
& FLV_AUDIO_SAMPLESIZE_MASK
) ? 16 : 8;
918 if (!st
->codec
->channels
|| !st
->codec
->sample_rate
||
919 !st
->codec
->bits_per_coded_sample
) {
920 st
->codec
->channels
= channels
;
921 st
->codec
->channel_layout
= channels
== 1
923 : AV_CH_LAYOUT_STEREO
;
924 st
->codec
->sample_rate
= sample_rate
;
925 st
->codec
->bits_per_coded_sample
= bits_per_coded_sample
;
927 if (!st
->codec
->codec_id
) {
928 flv_set_audio_codec(s
, st
, st
->codec
,
929 flags
& FLV_AUDIO_CODECID_MASK
);
930 flv
->last_sample_rate
=
931 sample_rate
= st
->codec
->sample_rate
;
933 channels
= st
->codec
->channels
;
935 AVCodecContext ctx
= {0};
936 ctx
.sample_rate
= sample_rate
;
937 ctx
.bits_per_coded_sample
= bits_per_coded_sample
;
938 flv_set_audio_codec(s
, st
, &ctx
, flags
& FLV_AUDIO_CODECID_MASK
);
939 sample_rate
= ctx
.sample_rate
;
941 } else if (stream_type
== FLV_STREAM_TYPE_VIDEO
) {
942 size
-= flv_set_video_codec(s
, st
, flags
& FLV_VIDEO_CODECID_MASK
, 1);
945 if (st
->codec
->codec_id
== AV_CODEC_ID_AAC
||
946 st
->codec
->codec_id
== AV_CODEC_ID_H264
||
947 st
->codec
->codec_id
== AV_CODEC_ID_MPEG4
) {
948 int type
= avio_r8(s
->pb
);
950 if (st
->codec
->codec_id
== AV_CODEC_ID_H264
|| st
->codec
->codec_id
== AV_CODEC_ID_MPEG4
) {
952 int32_t cts
= (avio_rb24(s
->pb
) + 0xff800000) ^ 0xff800000;
954 if (cts
< 0) { // dts might be wrong
956 av_log(s
, AV_LOG_WARNING
,
957 "Negative cts, previous timestamps might be wrong.\n");
959 } else if (FFABS(dts
- pts
) > 1000*60*15) {
960 av_log(s
, AV_LOG_WARNING
,
961 "invalid timestamps %"PRId64
" %"PRId64
"\n", dts
, pts
);
962 dts
= pts
= AV_NOPTS_VALUE
;
965 if (type
== 0 && (!st
->codec
->extradata
|| st
->codec
->codec_id
== AV_CODEC_ID_AAC
||
966 st
->codec
->codec_id
== AV_CODEC_ID_H264
)) {
967 AVDictionaryEntry
*t
;
969 if (st
->codec
->extradata
) {
970 if ((ret
= flv_queue_extradata(flv
, s
->pb
, stream_type
, size
)) < 0)
972 ret
= AVERROR(EAGAIN
);
975 if ((ret
= flv_get_extradata(s
, st
, size
)) < 0)
978 /* Workaround for buggy Omnia A/XE encoder */
979 t
= av_dict_get(s
->metadata
, "Encoder", NULL
, 0);
980 if (st
->codec
->codec_id
== AV_CODEC_ID_AAC
&& t
&& !strcmp(t
->value
, "Omnia A/XE"))
981 st
->codec
->extradata_size
= 2;
983 if (st
->codec
->codec_id
== AV_CODEC_ID_AAC
&& 0) {
984 MPEG4AudioConfig cfg
;
986 if (avpriv_mpeg4audio_get_config(&cfg
, st
->codec
->extradata
,
987 st
->codec
->extradata_size
* 8, 1) >= 0) {
988 st
->codec
->channels
= cfg
.channels
;
989 st
->codec
->channel_layout
= 0;
990 if (cfg
.ext_sample_rate
)
991 st
->codec
->sample_rate
= cfg
.ext_sample_rate
;
993 st
->codec
->sample_rate
= cfg
.sample_rate
;
994 av_dlog(s
, "mp4a config channels %d sample rate %d\n",
995 st
->codec
->channels
, st
->codec
->sample_rate
);
999 ret
= AVERROR(EAGAIN
);
1004 /* skip empty data packets */
1006 ret
= AVERROR(EAGAIN
);
1010 ret
= av_get_packet(s
->pb
, pkt
, size
);
1014 pkt
->pts
= pts
== AV_NOPTS_VALUE
? dts
: pts
;
1015 pkt
->stream_index
= st
->index
;
1016 if (flv
->new_extradata
[stream_type
]) {
1017 uint8_t *side
= av_packet_new_side_data(pkt
, AV_PKT_DATA_NEW_EXTRADATA
,
1018 flv
->new_extradata_size
[stream_type
]);
1020 memcpy(side
, flv
->new_extradata
[stream_type
],
1021 flv
->new_extradata_size
[stream_type
]);
1022 av_freep(&flv
->new_extradata
[stream_type
]);
1023 flv
->new_extradata_size
[stream_type
] = 0;
1026 if (stream_type
== FLV_STREAM_TYPE_AUDIO
&&
1027 (sample_rate
!= flv
->last_sample_rate
||
1028 channels
!= flv
->last_channels
)) {
1029 flv
->last_sample_rate
= sample_rate
;
1030 flv
->last_channels
= channels
;
1031 ff_add_param_change(pkt
, channels
, 0, sample_rate
, 0, 0);
1034 if ( stream_type
== FLV_STREAM_TYPE_AUDIO
||
1035 ((flags
& FLV_VIDEO_FRAMETYPE_MASK
) == FLV_FRAME_KEY
) ||
1036 stream_type
== FLV_STREAM_TYPE_DATA
)
1037 pkt
->flags
|= AV_PKT_FLAG_KEY
;
1040 avio_skip(s
->pb
, 4);
1044 static int flv_read_seek(AVFormatContext
*s
, int stream_index
,
1045 int64_t ts
, int flags
)
1047 FLVContext
*flv
= s
->priv_data
;
1048 flv
->validate_count
= 0;
1049 return avio_seek_time(s
->pb
, stream_index
, ts
, flags
);
1052 #define OFFSET(x) offsetof(FLVContext, x)
1053 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1054 static const AVOption options
[] = {
1055 { "flv_metadata", "Allocate streams according to the onMetaData array", OFFSET(trust_metadata
), AV_OPT_TYPE_INT
, { .i64
= 0 }, 0, 1, VD
},
1059 static const AVClass flv_class
= {
1060 .class_name
= "flvdec",
1061 .item_name
= av_default_item_name
,
1063 .version
= LIBAVUTIL_VERSION_INT
,
1066 AVInputFormat ff_flv_demuxer
= {
1068 .long_name
= NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1069 .priv_data_size
= sizeof(FLVContext
),
1070 .read_probe
= flv_probe
,
1071 .read_header
= flv_read_header
,
1072 .read_packet
= flv_read_packet
,
1073 .read_seek
= flv_read_seek
,
1074 .read_close
= flv_read_close
,
1075 .extensions
= "flv",
1076 .priv_class
= &flv_class
,
1079 static const AVClass live_flv_class
= {
1080 .class_name
= "live_flvdec",
1081 .item_name
= av_default_item_name
,
1083 .version
= LIBAVUTIL_VERSION_INT
,
1086 AVInputFormat ff_live_flv_demuxer
= {
1088 .long_name
= NULL_IF_CONFIG_SMALL("live RTMP FLV (Flash Video)"),
1089 .priv_data_size
= sizeof(FLVContext
),
1090 .read_probe
= live_flv_probe
,
1091 .read_header
= flv_read_header
,
1092 .read_packet
= flv_read_packet
,
1093 .read_seek
= flv_read_seek
,
1094 .read_close
= flv_read_close
,
1095 .extensions
= "flv",
1096 .priv_class
= &live_flv_class
,
1097 .flags
= AVFMT_TS_DISCONT