Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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