b11e3352c1c815572aee3f881a9f9cf81a575d5a
[ffmpeg.git] / libavformat / flvdec.c
1 /*
2  * FLV demuxer
3  * Copyright (c) 2003 The FFmpeg Project
4  *
5  * This demuxer will generate a 1 byte extradata for VP6F content.
6  * It is composed of:
7  *  - upper 4bits: difference between encoded width and visible width
8  *  - lower 4bits: difference between encoded height and visible height
9  *
10  * This file is part of FFmpeg.
11  *
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.
16  *
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.
21  *
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
25  */
26
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"
35 #include "avformat.h"
36 #include "internal.h"
37 #include "avio_internal.h"
38 #include "flv.h"
39
40 #define VALIDATE_INDEX_TS_THRESH 2500
41
42 typedef struct {
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];
48     int last_sample_rate;
49     int last_channels;
50     struct {
51         int64_t dts;
52         int64_t pos;
53     } validate_index[2];
54     int validate_next;
55     int validate_count;
56     int searched_for_end;
57 } FLVContext;
58
59 static int flv_probe(AVProbeData *p)
60 {
61     const uint8_t *d;
62
63     d = p->buf;
64     if (d[0] == 'F' &&
65         d[1] == 'L' &&
66         d[2] == 'V' &&
67         d[3] < 5 && d[5] == 0 &&
68         AV_RB32(d + 5) > 8) {
69         return AVPROBE_SCORE_MAX;
70     }
71     return 0;
72 }
73
74 static AVStream *create_stream(AVFormatContext *s, int codec_type)
75 {
76     AVStream *st = avformat_new_stream(s, NULL);
77     if (!st)
78         return NULL;
79     st->codec->codec_type = codec_type;
80     if (s->nb_streams>=3 ||(   s->nb_streams==2
81                            && s->streams[0]->codec->codec_type != AVMEDIA_TYPE_DATA
82                            && s->streams[1]->codec->codec_type != AVMEDIA_TYPE_DATA))
83         s->ctx_flags &= ~AVFMTCTX_NOHEADER;
84
85     avpriv_set_pts_info(st, 32, 1, 1000); /* 32 bit pts in ms */
86     return st;
87 }
88
89 static int flv_same_audio_codec(AVCodecContext *acodec, int flags)
90 {
91     int bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
92     int flv_codecid           = flags & FLV_AUDIO_CODECID_MASK;
93     int codec_id;
94
95     if (!acodec->codec_id && !acodec->codec_tag)
96         return 1;
97
98     if (acodec->bits_per_coded_sample != bits_per_coded_sample)
99         return 0;
100
101     switch (flv_codecid) {
102     // no distinction between S16 and S8 PCM codec flags
103     case FLV_CODECID_PCM:
104         codec_id = bits_per_coded_sample == 8
105                    ? AV_CODEC_ID_PCM_U8
106 #if HAVE_BIGENDIAN
107                    : AV_CODEC_ID_PCM_S16BE;
108 #else
109                    : AV_CODEC_ID_PCM_S16LE;
110 #endif
111         return codec_id == acodec->codec_id;
112     case FLV_CODECID_PCM_LE:
113         codec_id = bits_per_coded_sample == 8
114                    ? AV_CODEC_ID_PCM_U8
115                    : AV_CODEC_ID_PCM_S16LE;
116         return codec_id == acodec->codec_id;
117     case FLV_CODECID_AAC:
118         return acodec->codec_id == AV_CODEC_ID_AAC;
119     case FLV_CODECID_ADPCM:
120         return acodec->codec_id == AV_CODEC_ID_ADPCM_SWF;
121     case FLV_CODECID_SPEEX:
122         return acodec->codec_id == AV_CODEC_ID_SPEEX;
123     case FLV_CODECID_MP3:
124         return acodec->codec_id == AV_CODEC_ID_MP3;
125     case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
126     case FLV_CODECID_NELLYMOSER_16KHZ_MONO:
127     case FLV_CODECID_NELLYMOSER:
128         return acodec->codec_id == AV_CODEC_ID_NELLYMOSER;
129     case FLV_CODECID_PCM_MULAW:
130         return acodec->sample_rate == 8000 &&
131                acodec->codec_id    == AV_CODEC_ID_PCM_MULAW;
132     case FLV_CODECID_PCM_ALAW:
133         return acodec->sample_rate == 8000 &&
134                acodec->codec_id    == AV_CODEC_ID_PCM_ALAW;
135     default:
136         return acodec->codec_tag == (flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
137     }
138 }
139
140 static void flv_set_audio_codec(AVFormatContext *s, AVStream *astream,
141                                 AVCodecContext *acodec, int flv_codecid)
142 {
143     switch (flv_codecid) {
144     // no distinction between S16 and S8 PCM codec flags
145     case FLV_CODECID_PCM:
146         acodec->codec_id = acodec->bits_per_coded_sample == 8
147                            ? AV_CODEC_ID_PCM_U8
148 #if HAVE_BIGENDIAN
149                            : AV_CODEC_ID_PCM_S16BE;
150 #else
151                            : AV_CODEC_ID_PCM_S16LE;
152 #endif
153         break;
154     case FLV_CODECID_PCM_LE:
155         acodec->codec_id = acodec->bits_per_coded_sample == 8
156                            ? AV_CODEC_ID_PCM_U8
157                            : AV_CODEC_ID_PCM_S16LE;
158         break;
159     case FLV_CODECID_AAC:
160         acodec->codec_id = AV_CODEC_ID_AAC;
161         break;
162     case FLV_CODECID_ADPCM:
163         acodec->codec_id = AV_CODEC_ID_ADPCM_SWF;
164         break;
165     case FLV_CODECID_SPEEX:
166         acodec->codec_id    = AV_CODEC_ID_SPEEX;
167         acodec->sample_rate = 16000;
168         break;
169     case FLV_CODECID_MP3:
170         acodec->codec_id      = AV_CODEC_ID_MP3;
171         astream->need_parsing = AVSTREAM_PARSE_FULL;
172         break;
173     case FLV_CODECID_NELLYMOSER_8KHZ_MONO:
174         // in case metadata does not otherwise declare samplerate
175         acodec->sample_rate = 8000;
176         acodec->codec_id    = AV_CODEC_ID_NELLYMOSER;
177         break;
178     case FLV_CODECID_NELLYMOSER_16KHZ_MONO:
179         acodec->sample_rate = 16000;
180         acodec->codec_id    = AV_CODEC_ID_NELLYMOSER;
181         break;
182     case FLV_CODECID_NELLYMOSER:
183         acodec->codec_id = AV_CODEC_ID_NELLYMOSER;
184         break;
185     case FLV_CODECID_PCM_MULAW:
186         acodec->sample_rate = 8000;
187         acodec->codec_id    = AV_CODEC_ID_PCM_MULAW;
188         break;
189     case FLV_CODECID_PCM_ALAW:
190         acodec->sample_rate = 8000;
191         acodec->codec_id    = AV_CODEC_ID_PCM_ALAW;
192         break;
193     default:
194         avpriv_request_sample(s, "Audio codec (%x)",
195                flv_codecid >> FLV_AUDIO_CODECID_OFFSET);
196         acodec->codec_tag = flv_codecid >> FLV_AUDIO_CODECID_OFFSET;
197     }
198 }
199
200 static int flv_same_video_codec(AVCodecContext *vcodec, int flags)
201 {
202     int flv_codecid = flags & FLV_VIDEO_CODECID_MASK;
203
204     if (!vcodec->codec_id && !vcodec->codec_tag)
205         return 1;
206
207     switch (flv_codecid) {
208     case FLV_CODECID_H263:
209         return vcodec->codec_id == AV_CODEC_ID_FLV1;
210     case FLV_CODECID_SCREEN:
211         return vcodec->codec_id == AV_CODEC_ID_FLASHSV;
212     case FLV_CODECID_SCREEN2:
213         return vcodec->codec_id == AV_CODEC_ID_FLASHSV2;
214     case FLV_CODECID_VP6:
215         return vcodec->codec_id == AV_CODEC_ID_VP6F;
216     case FLV_CODECID_VP6A:
217         return vcodec->codec_id == AV_CODEC_ID_VP6A;
218     case FLV_CODECID_H264:
219         return vcodec->codec_id == AV_CODEC_ID_H264;
220     default:
221         return vcodec->codec_tag == flv_codecid;
222     }
223 }
224
225 static int flv_set_video_codec(AVFormatContext *s, AVStream *vstream,
226                                int flv_codecid, int read)
227 {
228     AVCodecContext *vcodec = vstream->codec;
229     switch (flv_codecid) {
230     case FLV_CODECID_H263:
231         vcodec->codec_id = AV_CODEC_ID_FLV1;
232         break;
233     case FLV_CODECID_REALH263:
234         vcodec->codec_id = AV_CODEC_ID_H263;
235         break; // Really mean it this time
236     case FLV_CODECID_SCREEN:
237         vcodec->codec_id = AV_CODEC_ID_FLASHSV;
238         break;
239     case FLV_CODECID_SCREEN2:
240         vcodec->codec_id = AV_CODEC_ID_FLASHSV2;
241         break;
242     case FLV_CODECID_VP6:
243         vcodec->codec_id = AV_CODEC_ID_VP6F;
244     case FLV_CODECID_VP6A:
245         if (flv_codecid == FLV_CODECID_VP6A)
246             vcodec->codec_id = AV_CODEC_ID_VP6A;
247         if (read) {
248             if (vcodec->extradata_size != 1) {
249                 ff_alloc_extradata(vcodec, 1);
250             }
251             if (vcodec->extradata)
252                 vcodec->extradata[0] = avio_r8(s->pb);
253             else
254                 avio_skip(s->pb, 1);
255         }
256         return 1;     // 1 byte body size adjustment for flv_read_packet()
257     case FLV_CODECID_H264:
258         vcodec->codec_id = AV_CODEC_ID_H264;
259         vstream->need_parsing = AVSTREAM_PARSE_HEADERS;
260         return 3;     // not 4, reading packet type will consume one byte
261     case FLV_CODECID_MPEG4:
262         vcodec->codec_id = AV_CODEC_ID_MPEG4;
263         return 3;
264     default:
265         avpriv_request_sample(s, "Video codec (%x)", flv_codecid);
266         vcodec->codec_tag = flv_codecid;
267     }
268
269     return 0;
270 }
271
272 static int amf_get_string(AVIOContext *ioc, char *buffer, int buffsize)
273 {
274     int length = avio_rb16(ioc);
275     if (length >= buffsize) {
276         avio_skip(ioc, length);
277         return -1;
278     }
279
280     avio_read(ioc, buffer, length);
281
282     buffer[length] = '\0';
283
284     return length;
285 }
286
287 static int parse_keyframes_index(AVFormatContext *s, AVIOContext *ioc,
288                                  AVStream *vstream, int64_t max_pos)
289 {
290     FLVContext *flv       = s->priv_data;
291     unsigned int timeslen = 0, fileposlen = 0, i;
292     char str_val[256];
293     int64_t *times         = NULL;
294     int64_t *filepositions = NULL;
295     int ret                = AVERROR(ENOSYS);
296     int64_t initial_pos    = avio_tell(ioc);
297
298     if (vstream->nb_index_entries>0) {
299         av_log(s, AV_LOG_WARNING, "Skiping duplicate index\n");
300         return 0;
301     }
302
303     if (s->flags & AVFMT_FLAG_IGNIDX)
304         return 0;
305
306     while (avio_tell(ioc) < max_pos - 2 &&
307            amf_get_string(ioc, str_val, sizeof(str_val)) > 0) {
308         int64_t **current_array;
309         unsigned int arraylen;
310
311         // Expect array object in context
312         if (avio_r8(ioc) != AMF_DATA_TYPE_ARRAY)
313             break;
314
315         arraylen = avio_rb32(ioc);
316         if (arraylen>>28)
317             break;
318
319         if       (!strcmp(KEYFRAMES_TIMESTAMP_TAG , str_val) && !times) {
320             current_array = &times;
321             timeslen      = arraylen;
322         } else if (!strcmp(KEYFRAMES_BYTEOFFSET_TAG, str_val) &&
323                    !filepositions) {
324             current_array = &filepositions;
325             fileposlen    = arraylen;
326         } else
327             // unexpected metatag inside keyframes, will not use such
328             // metadata for indexing
329             break;
330
331         if (!(*current_array = av_mallocz(sizeof(**current_array) * arraylen))) {
332             ret = AVERROR(ENOMEM);
333             goto finish;
334         }
335
336         for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++) {
337             if (avio_r8(ioc) != AMF_DATA_TYPE_NUMBER)
338                 goto invalid;
339             current_array[0][i] = av_int2double(avio_rb64(ioc));
340         }
341         if (times && filepositions) {
342             // All done, exiting at a position allowing amf_parse_object
343             // to finish parsing the object
344             ret = 0;
345             break;
346         }
347     }
348
349     if (timeslen == fileposlen && fileposlen>1 && max_pos <= filepositions[0]) {
350         for (i = 0; i < fileposlen; i++) {
351             av_add_index_entry(vstream, filepositions[i], times[i] * 1000,
352                                0, 0, AVINDEX_KEYFRAME);
353             if (i < 2) {
354                 flv->validate_index[i].pos = filepositions[i];
355                 flv->validate_index[i].dts = times[i] * 1000;
356                 flv->validate_count        = i + 1;
357             }
358         }
359     } else {
360 invalid:
361         av_log(s, AV_LOG_WARNING, "Invalid keyframes object, skipping.\n");
362     }
363
364 finish:
365     av_freep(&times);
366     av_freep(&filepositions);
367     avio_seek(ioc, initial_pos, SEEK_SET);
368     return ret;
369 }
370
371 static int amf_parse_object(AVFormatContext *s, AVStream *astream,
372                             AVStream *vstream, const char *key,
373                             int64_t max_pos, int depth)
374 {
375     AVCodecContext *acodec, *vcodec;
376     FLVContext *flv = s->priv_data;
377     AVIOContext *ioc;
378     AMFDataType amf_type;
379     char str_val[256];
380     double num_val;
381
382     num_val  = 0;
383     ioc      = s->pb;
384     amf_type = avio_r8(ioc);
385
386     switch (amf_type) {
387     case AMF_DATA_TYPE_NUMBER:
388         num_val = av_int2double(avio_rb64(ioc));
389         break;
390     case AMF_DATA_TYPE_BOOL:
391         num_val = avio_r8(ioc);
392         break;
393     case AMF_DATA_TYPE_STRING:
394         if (amf_get_string(ioc, str_val, sizeof(str_val)) < 0)
395             return -1;
396         break;
397     case AMF_DATA_TYPE_OBJECT:
398         if ((vstream || astream) && key &&
399             ioc->seekable &&
400             !strcmp(KEYFRAMES_TAG, key) && depth == 1)
401             if (parse_keyframes_index(s, ioc, vstream ? vstream : astream,
402                                       max_pos) < 0)
403                 av_log(s, AV_LOG_ERROR, "Keyframe index parsing failed\n");
404
405         while (avio_tell(ioc) < max_pos - 2 &&
406                amf_get_string(ioc, str_val, sizeof(str_val)) > 0)
407             if (amf_parse_object(s, astream, vstream, str_val, max_pos,
408                                  depth + 1) < 0)
409                 return -1;     // if we couldn't skip, bomb out.
410         if (avio_r8(ioc) != AMF_END_OF_OBJECT)
411             return -1;
412         break;
413     case AMF_DATA_TYPE_NULL:
414     case AMF_DATA_TYPE_UNDEFINED:
415     case AMF_DATA_TYPE_UNSUPPORTED:
416         break;     // these take up no additional space
417     case AMF_DATA_TYPE_MIXEDARRAY:
418         avio_skip(ioc, 4);     // skip 32-bit max array index
419         while (avio_tell(ioc) < max_pos - 2 &&
420                amf_get_string(ioc, str_val, sizeof(str_val)) > 0)
421             // this is the only case in which we would want a nested
422             // parse to not skip over the object
423             if (amf_parse_object(s, astream, vstream, str_val, max_pos,
424                                  depth + 1) < 0)
425                 return -1;
426         if (avio_r8(ioc) != AMF_END_OF_OBJECT)
427             return -1;
428         break;
429     case AMF_DATA_TYPE_ARRAY:
430     {
431         unsigned int arraylen, i;
432
433         arraylen = avio_rb32(ioc);
434         for (i = 0; i < arraylen && avio_tell(ioc) < max_pos - 1; i++)
435             if (amf_parse_object(s, NULL, NULL, NULL, max_pos,
436                                  depth + 1) < 0)
437                 return -1;      // if we couldn't skip, bomb out.
438     }
439     break;
440     case AMF_DATA_TYPE_DATE:
441         avio_skip(ioc, 8 + 2);  // timestamp (double) and UTC offset (int16)
442         break;
443     default:                    // unsupported type, we couldn't skip
444         return -1;
445     }
446
447     // only look for metadata values when we are not nested and key != NULL
448     if (depth == 1 && key) {
449         acodec = astream ? astream->codec : NULL;
450         vcodec = vstream ? vstream->codec : NULL;
451
452         if (amf_type == AMF_DATA_TYPE_NUMBER ||
453             amf_type == AMF_DATA_TYPE_BOOL) {
454             if (!strcmp(key, "duration"))
455                 s->duration = num_val * AV_TIME_BASE;
456             else if (!strcmp(key, "videodatarate") && vcodec &&
457                      0 <= (int)(num_val * 1024.0))
458                 vcodec->bit_rate = num_val * 1024.0;
459             else if (!strcmp(key, "audiodatarate") && acodec &&
460                      0 <= (int)(num_val * 1024.0))
461                 acodec->bit_rate = num_val * 1024.0;
462             else if (!strcmp(key, "datastream")) {
463                 AVStream *st = create_stream(s, AVMEDIA_TYPE_DATA);
464                 if (!st)
465                     return AVERROR(ENOMEM);
466                 st->codec->codec_id = AV_CODEC_ID_TEXT;
467             } else if (flv->trust_metadata) {
468                 if (!strcmp(key, "videocodecid") && vcodec) {
469                     flv_set_video_codec(s, vstream, num_val, 0);
470                 } else if (!strcmp(key, "audiocodecid") && acodec) {
471                     int id = ((int)num_val) << FLV_AUDIO_CODECID_OFFSET;
472                     flv_set_audio_codec(s, astream, acodec, id);
473                 } else if (!strcmp(key, "audiosamplerate") && acodec) {
474                     acodec->sample_rate = num_val;
475                 } else if (!strcmp(key, "audiosamplesize") && acodec) {
476                     acodec->bits_per_coded_sample = num_val;
477                 } else if (!strcmp(key, "stereo") && acodec) {
478                     acodec->channels       = num_val + 1;
479                     acodec->channel_layout = acodec->channels == 2 ?
480                                              AV_CH_LAYOUT_STEREO :
481                                              AV_CH_LAYOUT_MONO;
482                 } else if (!strcmp(key, "width") && vcodec) {
483                     vcodec->width = num_val;
484                 } else if (!strcmp(key, "height") && vcodec) {
485                     vcodec->height = num_val;
486                 }
487             }
488         }
489
490         if (amf_type == AMF_DATA_TYPE_OBJECT && s->nb_streams == 1 &&
491            ((!acodec && !strcmp(key, "audiocodecid")) ||
492             (!vcodec && !strcmp(key, "videocodecid"))))
493                 s->ctx_flags &= ~AVFMTCTX_NOHEADER; //If there is either audio/video missing, codecid will be an empty object
494
495         if (!strcmp(key, "duration")        ||
496             !strcmp(key, "filesize")        ||
497             !strcmp(key, "width")           ||
498             !strcmp(key, "height")          ||
499             !strcmp(key, "videodatarate")   ||
500             !strcmp(key, "framerate")       ||
501             !strcmp(key, "videocodecid")    ||
502             !strcmp(key, "audiodatarate")   ||
503             !strcmp(key, "audiosamplerate") ||
504             !strcmp(key, "audiosamplesize") ||
505             !strcmp(key, "stereo")          ||
506             !strcmp(key, "audiocodecid")    ||
507             !strcmp(key, "datastream"))
508             return 0;
509
510         if (amf_type == AMF_DATA_TYPE_BOOL) {
511             av_strlcpy(str_val, num_val > 0 ? "true" : "false",
512                        sizeof(str_val));
513             av_dict_set(&s->metadata, key, str_val, 0);
514         } else if (amf_type == AMF_DATA_TYPE_NUMBER) {
515             snprintf(str_val, sizeof(str_val), "%.f", num_val);
516             av_dict_set(&s->metadata, key, str_val, 0);
517         } else if (amf_type == AMF_DATA_TYPE_STRING)
518             av_dict_set(&s->metadata, key, str_val, 0);
519     }
520
521     return 0;
522 }
523
524 static int flv_read_metabody(AVFormatContext *s, int64_t next_pos)
525 {
526     AMFDataType type;
527     AVStream *stream, *astream, *vstream;
528     AVStream av_unused *dstream;
529     AVIOContext *ioc;
530     int i;
531     // only needs to hold the string "onMetaData".
532     // Anything longer is something we don't want.
533     char buffer[11];
534
535     astream = NULL;
536     vstream = NULL;
537     dstream = NULL;
538     ioc     = s->pb;
539
540     // first object needs to be "onMetaData" string
541     type = avio_r8(ioc);
542     if (type != AMF_DATA_TYPE_STRING ||
543         amf_get_string(ioc, buffer, sizeof(buffer)) < 0)
544         return -1;
545
546     if (!strcmp(buffer, "onTextData"))
547         return 1;
548
549     if (strcmp(buffer, "onMetaData"))
550         return -1;
551
552     // find the streams now so that amf_parse_object doesn't need to do
553     // the lookup every time it is called.
554     for (i = 0; i < s->nb_streams; i++) {
555         stream = s->streams[i];
556         if (stream->codec->codec_type == AVMEDIA_TYPE_VIDEO)
557             vstream = stream;
558         else if (stream->codec->codec_type == AVMEDIA_TYPE_AUDIO)
559             astream = stream;
560         else if (stream->codec->codec_type == AVMEDIA_TYPE_DATA)
561             dstream = stream;
562     }
563
564     // parse the second object (we want a mixed array)
565     if (amf_parse_object(s, astream, vstream, buffer, next_pos, 0) < 0)
566         return -1;
567
568     return 0;
569 }
570
571 static int flv_read_header(AVFormatContext *s)
572 {
573     int offset, flags;
574
575     avio_skip(s->pb, 4);
576     flags = avio_r8(s->pb);
577     /* old flvtool cleared this field */
578     /* FIXME: better fix needed */
579     if (!flags) {
580         flags = FLV_HEADER_FLAG_HASVIDEO | FLV_HEADER_FLAG_HASAUDIO;
581         av_log(s, AV_LOG_WARNING,
582                "Broken FLV file, which says no streams present, "
583                "this might fail\n");
584     }
585
586     s->ctx_flags |= AVFMTCTX_NOHEADER;
587
588     if (flags & FLV_HEADER_FLAG_HASVIDEO)
589         if (!create_stream(s, AVMEDIA_TYPE_VIDEO))
590             return AVERROR(ENOMEM);
591     if (flags & FLV_HEADER_FLAG_HASAUDIO)
592         if (!create_stream(s, AVMEDIA_TYPE_AUDIO))
593             return AVERROR(ENOMEM);
594     // Flag doesn't indicate whether or not there is script-data present. Must
595     // create that stream if it's encountered.
596
597     offset = avio_rb32(s->pb);
598     avio_seek(s->pb, offset, SEEK_SET);
599     avio_skip(s->pb, 4);
600
601     s->start_time = 0;
602
603     return 0;
604 }
605
606 static int flv_read_close(AVFormatContext *s)
607 {
608     int i;
609     FLVContext *flv = s->priv_data;
610     for (i=0; i<FLV_STREAM_TYPE_NB; i++)
611         av_freep(&flv->new_extradata[i]);
612     return 0;
613 }
614
615 static int flv_get_extradata(AVFormatContext *s, AVStream *st, int size)
616 {
617     av_free(st->codec->extradata);
618     if (ff_get_extradata(st->codec, s->pb, size) < 0)
619         return AVERROR(ENOMEM);
620     return 0;
621 }
622
623 static int flv_queue_extradata(FLVContext *flv, AVIOContext *pb, int stream,
624                                int size)
625 {
626     av_free(flv->new_extradata[stream]);
627     flv->new_extradata[stream] = av_mallocz(size +
628                                             FF_INPUT_BUFFER_PADDING_SIZE);
629     if (!flv->new_extradata[stream])
630         return AVERROR(ENOMEM);
631     flv->new_extradata_size[stream] = size;
632     avio_read(pb, flv->new_extradata[stream], size);
633     return 0;
634 }
635
636 static void clear_index_entries(AVFormatContext *s, int64_t pos)
637 {
638     int i, j, out;
639     av_log(s, AV_LOG_WARNING,
640            "Found invalid index entries, clearing the index.\n");
641     for (i = 0; i < s->nb_streams; i++) {
642         AVStream *st = s->streams[i];
643         /* Remove all index entries that point to >= pos */
644         out = 0;
645         for (j = 0; j < st->nb_index_entries; j++)
646             if (st->index_entries[j].pos < pos)
647                 st->index_entries[out++] = st->index_entries[j];
648         st->nb_index_entries = out;
649     }
650 }
651
652 static int amf_skip_tag(AVIOContext *pb, AMFDataType type)
653 {
654     int nb = -1, ret, parse_name = 1;
655
656     switch (type) {
657     case AMF_DATA_TYPE_NUMBER:
658         avio_skip(pb, 8);
659         break;
660     case AMF_DATA_TYPE_BOOL:
661         avio_skip(pb, 1);
662         break;
663     case AMF_DATA_TYPE_STRING:
664         avio_skip(pb, avio_rb16(pb));
665         break;
666     case AMF_DATA_TYPE_ARRAY:
667         parse_name = 0;
668     case AMF_DATA_TYPE_MIXEDARRAY:
669         nb = avio_rb32(pb);
670     case AMF_DATA_TYPE_OBJECT:
671         while(!pb->eof_reached && (nb-- > 0 || type != AMF_DATA_TYPE_ARRAY)) {
672             if (parse_name) {
673                 int size = avio_rb16(pb);
674                 if (!size) {
675                     avio_skip(pb, 1);
676                     break;
677                 }
678                 avio_skip(pb, size);
679             }
680             if ((ret = amf_skip_tag(pb, avio_r8(pb))) < 0)
681                 return ret;
682         }
683         break;
684     case AMF_DATA_TYPE_NULL:
685     case AMF_DATA_TYPE_OBJECT_END:
686         break;
687     default:
688         return AVERROR_INVALIDDATA;
689     }
690     return 0;
691 }
692
693 static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,
694                            int64_t dts, int64_t next)
695 {
696     AVIOContext *pb = s->pb;
697     AVStream *st    = NULL;
698     char buf[20];
699     int ret = AVERROR_INVALIDDATA;
700     int i, length = -1;
701
702     switch (avio_r8(pb)) {
703     case AMF_DATA_TYPE_MIXEDARRAY:
704         avio_seek(pb, 4, SEEK_CUR);
705     case AMF_DATA_TYPE_OBJECT:
706         break;
707     default:
708         goto skip;
709     }
710
711     while ((ret = amf_get_string(pb, buf, sizeof(buf))) > 0) {
712         AMFDataType type = avio_r8(pb);
713         if (type == AMF_DATA_TYPE_STRING && !strcmp(buf, "text")) {
714             length = avio_rb16(pb);
715             ret    = av_get_packet(pb, pkt, length);
716             if (ret < 0)
717                 goto skip;
718             else
719                 break;
720         } else {
721             if ((ret = amf_skip_tag(pb, type)) < 0)
722                 goto skip;
723         }
724     }
725
726     if (length < 0) {
727         ret = AVERROR_INVALIDDATA;
728         goto skip;
729     }
730
731     for (i = 0; i < s->nb_streams; i++) {
732         st = s->streams[i];
733         if (st->codec->codec_type == AVMEDIA_TYPE_DATA)
734             break;
735     }
736
737     if (i == s->nb_streams) {
738         st = create_stream(s, AVMEDIA_TYPE_DATA);
739         if (!st)
740             return AVERROR_INVALIDDATA;
741         st->codec->codec_id = AV_CODEC_ID_TEXT;
742     }
743
744     pkt->dts  = dts;
745     pkt->pts  = dts;
746     pkt->size = ret;
747
748     pkt->stream_index = st->index;
749     pkt->flags       |= AV_PKT_FLAG_KEY;
750
751 skip:
752     avio_seek(s->pb, next + 4, SEEK_SET);
753
754     return ret;
755 }
756
757 static int flv_read_packet(AVFormatContext *s, AVPacket *pkt)
758 {
759     FLVContext *flv = s->priv_data;
760     int ret, i, type, size, flags;
761     int stream_type=-1;
762     int64_t next, pos, meta_pos;
763     int64_t dts, pts = AV_NOPTS_VALUE;
764     int av_uninit(channels);
765     int av_uninit(sample_rate);
766     AVStream *st    = NULL;
767
768     /* pkt size is repeated at end. skip it */
769     for (;; avio_skip(s->pb, 4)) {
770         pos  = avio_tell(s->pb);
771         type = avio_r8(s->pb);
772         size = avio_rb24(s->pb);
773         dts  = avio_rb24(s->pb);
774         dts |= avio_r8(s->pb) << 24;
775         av_dlog(s, "type:%d, size:%d, dts:%"PRId64"\n", type, size, dts);
776         if (url_feof(s->pb))
777             return AVERROR_EOF;
778         avio_skip(s->pb, 3); /* stream id, always 0 */
779         flags = 0;
780
781         if (flv->validate_next < flv->validate_count) {
782             int64_t validate_pos = flv->validate_index[flv->validate_next].pos;
783             if (pos == validate_pos) {
784                 if (FFABS(dts - flv->validate_index[flv->validate_next].dts) <=
785                     VALIDATE_INDEX_TS_THRESH) {
786                     flv->validate_next++;
787                 } else {
788                     clear_index_entries(s, validate_pos);
789                     flv->validate_count = 0;
790                 }
791             } else if (pos > validate_pos) {
792                 clear_index_entries(s, validate_pos);
793                 flv->validate_count = 0;
794             }
795         }
796
797         if (size == 0)
798             continue;
799
800         next = size + avio_tell(s->pb);
801
802         if (type == FLV_TAG_TYPE_AUDIO) {
803             stream_type = FLV_STREAM_TYPE_AUDIO;
804             flags    = avio_r8(s->pb);
805             size--;
806         } else if (type == FLV_TAG_TYPE_VIDEO) {
807             stream_type = FLV_STREAM_TYPE_VIDEO;
808             flags    = avio_r8(s->pb);
809             size--;
810             if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_VIDEO_INFO_CMD)
811                 goto skip;
812         } else if (type == FLV_TAG_TYPE_META) {
813             stream_type=FLV_STREAM_TYPE_DATA;
814             if (size > 13 + 1 + 4 && dts == 0) { // Header-type metadata stuff
815                 meta_pos = avio_tell(s->pb);
816                 if (flv_read_metabody(s, next) == 0) {
817                     goto skip;
818                 }
819                 avio_seek(s->pb, meta_pos, SEEK_SET);
820             }
821         } else {
822             av_log(s, AV_LOG_DEBUG,
823                    "skipping flv packet: type %d, size %d, flags %d\n",
824                    type, size, flags);
825 skip:
826             avio_seek(s->pb, next, SEEK_SET);
827             continue;
828         }
829
830         /* skip empty data packets */
831         if (!size)
832             continue;
833
834         /* now find stream */
835         for (i = 0; i < s->nb_streams; i++) {
836             st = s->streams[i];
837             if (stream_type == FLV_STREAM_TYPE_AUDIO) {
838                 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
839                     (s->audio_codec_id || flv_same_audio_codec(st->codec, flags)))
840                     break;
841             } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {
842                 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
843                     (s->video_codec_id || flv_same_video_codec(st->codec, flags)))
844                     break;
845             } else if (stream_type == FLV_STREAM_TYPE_DATA) {
846                 if (st->codec->codec_type == AVMEDIA_TYPE_DATA)
847                     break;
848             }
849         }
850         if (i == s->nb_streams) {
851             static const enum AVMediaType stream_types[] = {AVMEDIA_TYPE_VIDEO, AVMEDIA_TYPE_AUDIO, AVMEDIA_TYPE_DATA};
852             av_log(s, AV_LOG_WARNING, "Stream discovered after head already parsed\n");
853             st = create_stream(s, stream_types[stream_type]);
854             if (!st)
855                 return AVERROR(ENOMEM);
856
857         }
858         av_dlog(s, "%d %X %d \n", stream_type, flags, st->discard);
859         if (  (st->discard >= AVDISCARD_NONKEY && !((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || (stream_type == FLV_STREAM_TYPE_AUDIO)))
860             ||(st->discard >= AVDISCARD_BIDIR  &&  ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_DISP_INTER && (stream_type == FLV_STREAM_TYPE_VIDEO)))
861             || st->discard >= AVDISCARD_ALL
862         ) {
863             avio_seek(s->pb, next, SEEK_SET);
864             continue;
865         }
866         if ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY || stream_type == FLV_STREAM_TYPE_AUDIO)
867             av_add_index_entry(st, pos, dts, size, 0, AVINDEX_KEYFRAME);
868         break;
869     }
870
871     // if not streamed and no duration from metadata then seek to end to find
872     // the duration from the timestamps
873     if (s->pb->seekable && (!s->duration || s->duration == AV_NOPTS_VALUE) && !flv->searched_for_end) {
874         int size;
875         const int64_t pos   = avio_tell(s->pb);
876         int64_t fsize       = avio_size(s->pb);
877 retry_duration:
878         avio_seek(s->pb, fsize - 4, SEEK_SET);
879         size = avio_rb32(s->pb);
880         avio_seek(s->pb, fsize - 3 - size, SEEK_SET);
881         if (size == avio_rb24(s->pb) + 11) {
882             uint32_t ts = avio_rb24(s->pb);
883             ts         |= avio_r8(s->pb) << 24;
884             if (ts)
885                 s->duration = ts * (int64_t)AV_TIME_BASE / 1000;
886             else if (fsize >= 8 && fsize - 8 >= size) {
887                 fsize -= size+4;
888                 goto retry_duration;
889             }
890         }
891
892         avio_seek(s->pb, pos, SEEK_SET);
893         flv->searched_for_end = 1;
894     }
895
896     if (stream_type == FLV_STREAM_TYPE_AUDIO) {
897         int bits_per_coded_sample;
898         channels = (flags & FLV_AUDIO_CHANNEL_MASK) == FLV_STEREO ? 2 : 1;
899         sample_rate = 44100 << ((flags & FLV_AUDIO_SAMPLERATE_MASK) >>
900                                 FLV_AUDIO_SAMPLERATE_OFFSET) >> 3;
901         bits_per_coded_sample = (flags & FLV_AUDIO_SAMPLESIZE_MASK) ? 16 : 8;
902         if (!st->codec->channels || !st->codec->sample_rate ||
903             !st->codec->bits_per_coded_sample) {
904             st->codec->channels              = channels;
905             st->codec->channel_layout        = channels == 1
906                                                ? AV_CH_LAYOUT_MONO
907                                                : AV_CH_LAYOUT_STEREO;
908             st->codec->sample_rate           = sample_rate;
909             st->codec->bits_per_coded_sample = bits_per_coded_sample;
910         }
911         if (!st->codec->codec_id) {
912             flv_set_audio_codec(s, st, st->codec,
913                                 flags & FLV_AUDIO_CODECID_MASK);
914             flv->last_sample_rate =
915             sample_rate           = st->codec->sample_rate;
916             flv->last_channels    =
917             channels              = st->codec->channels;
918         } else {
919             AVCodecContext ctx = {0};
920             ctx.sample_rate = sample_rate;
921             flv_set_audio_codec(s, st, &ctx, flags & FLV_AUDIO_CODECID_MASK);
922             sample_rate = ctx.sample_rate;
923         }
924     } else if (stream_type == FLV_STREAM_TYPE_VIDEO) {
925         size -= flv_set_video_codec(s, st, flags & FLV_VIDEO_CODECID_MASK, 1);
926     }
927
928     if (st->codec->codec_id == AV_CODEC_ID_AAC ||
929         st->codec->codec_id == AV_CODEC_ID_H264 ||
930         st->codec->codec_id == AV_CODEC_ID_MPEG4) {
931         int type = avio_r8(s->pb);
932         size--;
933         if (st->codec->codec_id == AV_CODEC_ID_H264 || st->codec->codec_id == AV_CODEC_ID_MPEG4) {
934             // sign extension
935             int32_t cts = (avio_rb24(s->pb) + 0xff800000) ^ 0xff800000;
936             pts = dts + cts;
937             if (cts < 0) { // dts are wrong
938                 flv->wrong_dts = 1;
939                 av_log(s, AV_LOG_WARNING,
940                        "negative cts, previous timestamps might be wrong\n");
941             }
942             if (flv->wrong_dts)
943                 dts = AV_NOPTS_VALUE;
944         }
945         if (type == 0 && (!st->codec->extradata || st->codec->codec_id == AV_CODEC_ID_AAC)) {
946             AVDictionaryEntry *t;
947
948             if (st->codec->extradata) {
949                 if ((ret = flv_queue_extradata(flv, s->pb, stream_type, size)) < 0)
950                     return ret;
951                 ret = AVERROR(EAGAIN);
952                 goto leave;
953             }
954             if ((ret = flv_get_extradata(s, st, size)) < 0)
955                 return ret;
956
957             /* Workaround for buggy Omnia A/XE encoder */
958             t = av_dict_get(s->metadata, "Encoder", NULL, 0);
959             if (st->codec->codec_id == AV_CODEC_ID_AAC && t && !strcmp(t->value, "Omnia A/XE"))
960                 st->codec->extradata_size = 2;
961
962             if (st->codec->codec_id == AV_CODEC_ID_AAC && 0) {
963                 MPEG4AudioConfig cfg;
964
965                 if (avpriv_mpeg4audio_get_config(&cfg, st->codec->extradata,
966                                              st->codec->extradata_size * 8, 1) >= 0) {
967                 st->codec->channels       = cfg.channels;
968                 st->codec->channel_layout = 0;
969                 if (cfg.ext_sample_rate)
970                     st->codec->sample_rate = cfg.ext_sample_rate;
971                 else
972                     st->codec->sample_rate = cfg.sample_rate;
973                 av_dlog(s, "mp4a config channels %d sample rate %d\n",
974                         st->codec->channels, st->codec->sample_rate);
975                 }
976             }
977
978             ret = AVERROR(EAGAIN);
979             goto leave;
980         }
981     }
982
983     /* skip empty data packets */
984     if (!size) {
985         ret = AVERROR(EAGAIN);
986         goto leave;
987     }
988
989     ret = av_get_packet(s->pb, pkt, size);
990     if (ret < 0)
991         return ret;
992     pkt->dts          = dts;
993     pkt->pts          = pts == AV_NOPTS_VALUE ? dts : pts;
994     pkt->stream_index = st->index;
995     if (flv->new_extradata[stream_type]) {
996         uint8_t *side = av_packet_new_side_data(pkt, AV_PKT_DATA_NEW_EXTRADATA,
997                                                 flv->new_extradata_size[stream_type]);
998         if (side) {
999             memcpy(side, flv->new_extradata[stream_type],
1000                    flv->new_extradata_size[stream_type]);
1001             av_freep(&flv->new_extradata[stream_type]);
1002             flv->new_extradata_size[stream_type] = 0;
1003         }
1004     }
1005     if (stream_type == FLV_STREAM_TYPE_AUDIO &&
1006                     (sample_rate != flv->last_sample_rate ||
1007                      channels    != flv->last_channels)) {
1008         flv->last_sample_rate = sample_rate;
1009         flv->last_channels    = channels;
1010         ff_add_param_change(pkt, channels, 0, sample_rate, 0, 0);
1011     }
1012
1013     if (    stream_type == FLV_STREAM_TYPE_AUDIO ||
1014             ((flags & FLV_VIDEO_FRAMETYPE_MASK) == FLV_FRAME_KEY) ||
1015             stream_type == FLV_STREAM_TYPE_DATA)
1016         pkt->flags |= AV_PKT_FLAG_KEY;
1017
1018 leave:
1019     avio_skip(s->pb, 4);
1020     return ret;
1021 }
1022
1023 static int flv_read_seek(AVFormatContext *s, int stream_index,
1024                          int64_t ts, int flags)
1025 {
1026     FLVContext *flv = s->priv_data;
1027     flv->validate_count = 0;
1028     return avio_seek_time(s->pb, stream_index, ts, flags);
1029 }
1030
1031 #define OFFSET(x) offsetof(FLVContext, x)
1032 #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
1033 static const AVOption options[] = {
1034     { "flv_metadata", "Allocate streams according to the onMetaData array", OFFSET(trust_metadata), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },
1035     { NULL }
1036 };
1037
1038 static const AVClass flv_class = {
1039     .class_name = "flvdec",
1040     .item_name  = av_default_item_name,
1041     .option     = options,
1042     .version    = LIBAVUTIL_VERSION_INT,
1043 };
1044
1045 AVInputFormat ff_flv_demuxer = {
1046     .name           = "flv",
1047     .long_name      = NULL_IF_CONFIG_SMALL("FLV (Flash Video)"),
1048     .priv_data_size = sizeof(FLVContext),
1049     .read_probe     = flv_probe,
1050     .read_header    = flv_read_header,
1051     .read_packet    = flv_read_packet,
1052     .read_seek      = flv_read_seek,
1053     .read_close     = flv_read_close,
1054     .extensions     = "flv",
1055     .priv_class     = &flv_class,
1056 };