Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * AVI demuxer
  3.  * Copyright (c) 2001 Fabrice Bellard
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. #include <inttypes.h>
  23.  
  24. #include "libavutil/avassert.h"
  25. #include "libavutil/avstring.h"
  26. #include "libavutil/bswap.h"
  27. #include "libavutil/opt.h"
  28. #include "libavutil/dict.h"
  29. #include "libavutil/internal.h"
  30. #include "libavutil/intreadwrite.h"
  31. #include "libavutil/mathematics.h"
  32. #include "avformat.h"
  33. #include "avi.h"
  34. #include "dv.h"
  35. #include "internal.h"
  36. #include "isom.h"
  37. #include "riff.h"
  38. #include "libavcodec/bytestream.h"
  39. #include "libavcodec/exif.h"
  40. #include "libavcodec/internal.h"
  41.  
  42. typedef struct AVIStream {
  43.     int64_t frame_offset;   /* current frame (video) or byte (audio) counter
  44.                              * (used to compute the pts) */
  45.     int remaining;
  46.     int packet_size;
  47.  
  48.     uint32_t handler;
  49.     uint32_t scale;
  50.     uint32_t rate;
  51.     int sample_size;        /* size of one sample (or packet)
  52.                              * (in the rate/scale sense) in bytes */
  53.  
  54.     int64_t cum_len;        /* temporary storage (used during seek) */
  55.     int prefix;             /* normally 'd'<<8 + 'c' or 'w'<<8 + 'b' */
  56.     int prefix_count;
  57.     uint32_t pal[256];
  58.     int has_pal;
  59.     int dshow_block_align;  /* block align variable used to emulate bugs in
  60.                              * the MS dshow demuxer */
  61.  
  62.     AVFormatContext *sub_ctx;
  63.     AVPacket sub_pkt;
  64.     uint8_t *sub_buffer;
  65.  
  66.     int64_t seek_pos;
  67. } AVIStream;
  68.  
  69. typedef struct AVIContext {
  70.     const AVClass *class;
  71.     int64_t riff_end;
  72.     int64_t movi_end;
  73.     int64_t fsize;
  74.     int64_t io_fsize;
  75.     int64_t movi_list;
  76.     int64_t last_pkt_pos;
  77.     int index_loaded;
  78.     int is_odml;
  79.     int non_interleaved;
  80.     int stream_index;
  81.     DVDemuxContext *dv_demux;
  82.     int odml_depth;
  83.     int use_odml;
  84. #define MAX_ODML_DEPTH 1000
  85.     int64_t dts_max;
  86. } AVIContext;
  87.  
  88.  
  89. static const AVOption options[] = {
  90.     { "use_odml", "use odml index", offsetof(AVIContext, use_odml), AV_OPT_TYPE_INT, {.i64 = 1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM},
  91.     { NULL },
  92. };
  93.  
  94. static const AVClass demuxer_class = {
  95.     .class_name = "avi",
  96.     .item_name  = av_default_item_name,
  97.     .option     = options,
  98.     .version    = LIBAVUTIL_VERSION_INT,
  99.     .category   = AV_CLASS_CATEGORY_DEMUXER,
  100. };
  101.  
  102.  
  103. static const char avi_headers[][8] = {
  104.     { 'R', 'I', 'F', 'F', 'A', 'V', 'I', ' '  },
  105.     { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 'X'  },
  106.     { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 0x19 },
  107.     { 'O', 'N', '2', ' ', 'O', 'N', '2', 'f'  },
  108.     { 'R', 'I', 'F', 'F', 'A', 'M', 'V', ' '  },
  109.     { 0 }
  110. };
  111.  
  112. static const AVMetadataConv avi_metadata_conv[] = {
  113.     { "strn", "title" },
  114.     { 0 },
  115. };
  116.  
  117. static int avi_load_index(AVFormatContext *s);
  118. static int guess_ni_flag(AVFormatContext *s);
  119.  
  120. #define print_tag(str, tag, size)                        \
  121.     av_log(NULL, AV_LOG_TRACE, "pos:%"PRIX64" %s: tag=%c%c%c%c size=0x%x\n", \
  122.             avio_tell(pb), str, tag & 0xff,              \
  123.             (tag >> 8) & 0xff,                           \
  124.             (tag >> 16) & 0xff,                          \
  125.             (tag >> 24) & 0xff,                          \
  126.             size)
  127.  
  128. static inline int get_duration(AVIStream *ast, int len)
  129. {
  130.     if (ast->sample_size)
  131.         return len;
  132.     else if (ast->dshow_block_align)
  133.         return (len + ast->dshow_block_align - 1) / ast->dshow_block_align;
  134.     else
  135.         return 1;
  136. }
  137.  
  138. static int get_riff(AVFormatContext *s, AVIOContext *pb)
  139. {
  140.     AVIContext *avi = s->priv_data;
  141.     char header[8] = {0};
  142.     int i;
  143.  
  144.     /* check RIFF header */
  145.     avio_read(pb, header, 4);
  146.     avi->riff_end  = avio_rl32(pb); /* RIFF chunk size */
  147.     avi->riff_end += avio_tell(pb); /* RIFF chunk end */
  148.     avio_read(pb, header + 4, 4);
  149.  
  150.     for (i = 0; avi_headers[i][0]; i++)
  151.         if (!memcmp(header, avi_headers[i], 8))
  152.             break;
  153.     if (!avi_headers[i][0])
  154.         return AVERROR_INVALIDDATA;
  155.  
  156.     if (header[7] == 0x19)
  157.         av_log(s, AV_LOG_INFO,
  158.                "This file has been generated by a totally broken muxer.\n");
  159.  
  160.     return 0;
  161. }
  162.  
  163. static int read_braindead_odml_indx(AVFormatContext *s, int frame_num)
  164. {
  165.     AVIContext *avi     = s->priv_data;
  166.     AVIOContext *pb     = s->pb;
  167.     int longs_pre_entry = avio_rl16(pb);
  168.     int index_sub_type  = avio_r8(pb);
  169.     int index_type      = avio_r8(pb);
  170.     int entries_in_use  = avio_rl32(pb);
  171.     int chunk_id        = avio_rl32(pb);
  172.     int64_t base        = avio_rl64(pb);
  173.     int stream_id       = ((chunk_id      & 0xFF) - '0') * 10 +
  174.                           ((chunk_id >> 8 & 0xFF) - '0');
  175.     AVStream *st;
  176.     AVIStream *ast;
  177.     int i;
  178.     int64_t last_pos = -1;
  179.     int64_t filesize = avi->fsize;
  180.  
  181.     av_log(s, AV_LOG_TRACE,
  182.             "longs_pre_entry:%d index_type:%d entries_in_use:%d "
  183.             "chunk_id:%X base:%16"PRIX64" frame_num:%d\n",
  184.             longs_pre_entry,
  185.             index_type,
  186.             entries_in_use,
  187.             chunk_id,
  188.             base,
  189.             frame_num);
  190.  
  191.     if (stream_id >= s->nb_streams || stream_id < 0)
  192.         return AVERROR_INVALIDDATA;
  193.     st  = s->streams[stream_id];
  194.     ast = st->priv_data;
  195.  
  196.     if (index_sub_type)
  197.         return AVERROR_INVALIDDATA;
  198.  
  199.     avio_rl32(pb);
  200.  
  201.     if (index_type && longs_pre_entry != 2)
  202.         return AVERROR_INVALIDDATA;
  203.     if (index_type > 1)
  204.         return AVERROR_INVALIDDATA;
  205.  
  206.     if (filesize > 0 && base >= filesize) {
  207.         av_log(s, AV_LOG_ERROR, "ODML index invalid\n");
  208.         if (base >> 32 == (base & 0xFFFFFFFF) &&
  209.             (base & 0xFFFFFFFF) < filesize    &&
  210.             filesize <= 0xFFFFFFFF)
  211.             base &= 0xFFFFFFFF;
  212.         else
  213.             return AVERROR_INVALIDDATA;
  214.     }
  215.  
  216.     for (i = 0; i < entries_in_use; i++) {
  217.         if (index_type) {
  218.             int64_t pos = avio_rl32(pb) + base - 8;
  219.             int len     = avio_rl32(pb);
  220.             int key     = len >= 0;
  221.             len &= 0x7FFFFFFF;
  222.  
  223.             av_log(s, AV_LOG_TRACE, "pos:%"PRId64", len:%X\n", pos, len);
  224.  
  225.             if (avio_feof(pb))
  226.                 return AVERROR_INVALIDDATA;
  227.  
  228.             if (last_pos == pos || pos == base - 8)
  229.                 avi->non_interleaved = 1;
  230.             if (last_pos != pos && len)
  231.                 av_add_index_entry(st, pos, ast->cum_len, len, 0,
  232.                                    key ? AVINDEX_KEYFRAME : 0);
  233.  
  234.             ast->cum_len += get_duration(ast, len);
  235.             last_pos      = pos;
  236.         } else {
  237.             int64_t offset, pos;
  238.             int duration;
  239.             offset = avio_rl64(pb);
  240.             avio_rl32(pb);       /* size */
  241.             duration = avio_rl32(pb);
  242.  
  243.             if (avio_feof(pb))
  244.                 return AVERROR_INVALIDDATA;
  245.  
  246.             pos = avio_tell(pb);
  247.  
  248.             if (avi->odml_depth > MAX_ODML_DEPTH) {
  249.                 av_log(s, AV_LOG_ERROR, "Too deeply nested ODML indexes\n");
  250.                 return AVERROR_INVALIDDATA;
  251.             }
  252.  
  253.             if (avio_seek(pb, offset + 8, SEEK_SET) < 0)
  254.                 return -1;
  255.             avi->odml_depth++;
  256.             read_braindead_odml_indx(s, frame_num);
  257.             avi->odml_depth--;
  258.             frame_num += duration;
  259.  
  260.             if (avio_seek(pb, pos, SEEK_SET) < 0) {
  261.                 av_log(s, AV_LOG_ERROR, "Failed to restore position after reading index\n");
  262.                 return -1;
  263.             }
  264.  
  265.         }
  266.     }
  267.     avi->index_loaded = 2;
  268.     return 0;
  269. }
  270.  
  271. static void clean_index(AVFormatContext *s)
  272. {
  273.     int i;
  274.     int64_t j;
  275.  
  276.     for (i = 0; i < s->nb_streams; i++) {
  277.         AVStream *st   = s->streams[i];
  278.         AVIStream *ast = st->priv_data;
  279.         int n          = st->nb_index_entries;
  280.         int max        = ast->sample_size;
  281.         int64_t pos, size, ts;
  282.  
  283.         if (n != 1 || ast->sample_size == 0)
  284.             continue;
  285.  
  286.         while (max < 1024)
  287.             max += max;
  288.  
  289.         pos  = st->index_entries[0].pos;
  290.         size = st->index_entries[0].size;
  291.         ts   = st->index_entries[0].timestamp;
  292.  
  293.         for (j = 0; j < size; j += max)
  294.             av_add_index_entry(st, pos + j, ts + j, FFMIN(max, size - j), 0,
  295.                                AVINDEX_KEYFRAME);
  296.     }
  297. }
  298.  
  299. static int avi_read_tag(AVFormatContext *s, AVStream *st, uint32_t tag,
  300.                         uint32_t size)
  301. {
  302.     AVIOContext *pb = s->pb;
  303.     char key[5]     = { 0 };
  304.     char *value;
  305.  
  306.     size += (size & 1);
  307.  
  308.     if (size == UINT_MAX)
  309.         return AVERROR(EINVAL);
  310.     value = av_malloc(size + 1);
  311.     if (!value)
  312.         return AVERROR(ENOMEM);
  313.     if (avio_read(pb, value, size) != size)
  314.         return AVERROR_INVALIDDATA;
  315.     value[size] = 0;
  316.  
  317.     AV_WL32(key, tag);
  318.  
  319.     return av_dict_set(st ? &st->metadata : &s->metadata, key, value,
  320.                        AV_DICT_DONT_STRDUP_VAL);
  321. }
  322.  
  323. static const char months[12][4] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  324.                                     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
  325.  
  326. static void avi_metadata_creation_time(AVDictionary **metadata, char *date)
  327. {
  328.     char month[4], time[9], buffer[64];
  329.     int i, day, year;
  330.     /* parse standard AVI date format (ie. "Mon Mar 10 15:04:43 2003") */
  331.     if (sscanf(date, "%*3s%*[ ]%3s%*[ ]%2d%*[ ]%8s%*[ ]%4d",
  332.                month, &day, time, &year) == 4) {
  333.         for (i = 0; i < 12; i++)
  334.             if (!av_strcasecmp(month, months[i])) {
  335.                 snprintf(buffer, sizeof(buffer), "%.4d-%.2d-%.2d %s",
  336.                          year, i + 1, day, time);
  337.                 av_dict_set(metadata, "creation_time", buffer, 0);
  338.             }
  339.     } else if (date[4] == '/' && date[7] == '/') {
  340.         date[4] = date[7] = '-';
  341.         av_dict_set(metadata, "creation_time", date, 0);
  342.     }
  343. }
  344.  
  345. static void avi_read_nikon(AVFormatContext *s, uint64_t end)
  346. {
  347.     while (avio_tell(s->pb) < end) {
  348.         uint32_t tag  = avio_rl32(s->pb);
  349.         uint32_t size = avio_rl32(s->pb);
  350.         switch (tag) {
  351.         case MKTAG('n', 'c', 't', 'g'):  /* Nikon Tags */
  352.         {
  353.             uint64_t tag_end = avio_tell(s->pb) + size;
  354.             while (avio_tell(s->pb) < tag_end) {
  355.                 uint16_t tag     = avio_rl16(s->pb);
  356.                 uint16_t size    = avio_rl16(s->pb);
  357.                 const char *name = NULL;
  358.                 char buffer[64]  = { 0 };
  359.                 size = FFMIN(size, tag_end - avio_tell(s->pb));
  360.                 size -= avio_read(s->pb, buffer,
  361.                                   FFMIN(size, sizeof(buffer) - 1));
  362.                 switch (tag) {
  363.                 case 0x03:
  364.                     name = "maker";
  365.                     break;
  366.                 case 0x04:
  367.                     name = "model";
  368.                     break;
  369.                 case 0x13:
  370.                     name = "creation_time";
  371.                     if (buffer[4] == ':' && buffer[7] == ':')
  372.                         buffer[4] = buffer[7] = '-';
  373.                     break;
  374.                 }
  375.                 if (name)
  376.                     av_dict_set(&s->metadata, name, buffer, 0);
  377.                 avio_skip(s->pb, size);
  378.             }
  379.             break;
  380.         }
  381.         default:
  382.             avio_skip(s->pb, size);
  383.             break;
  384.         }
  385.     }
  386. }
  387.  
  388. static int avi_extract_stream_metadata(AVStream *st)
  389. {
  390.     GetByteContext gb;
  391.     uint8_t *data = st->codec->extradata;
  392.     int data_size = st->codec->extradata_size;
  393.     int tag, offset;
  394.  
  395.     if (!data || data_size < 8) {
  396.         return AVERROR_INVALIDDATA;
  397.     }
  398.  
  399.     bytestream2_init(&gb, data, data_size);
  400.  
  401.     tag = bytestream2_get_le32(&gb);
  402.  
  403.     switch (tag) {
  404.     case MKTAG('A', 'V', 'I', 'F'):
  405.         // skip 4 byte padding
  406.         bytestream2_skip(&gb, 4);
  407.         offset = bytestream2_tell(&gb);
  408.         bytestream2_init(&gb, data + offset, data_size - offset);
  409.  
  410.         // decode EXIF tags from IFD, AVI is always little-endian
  411.         return avpriv_exif_decode_ifd(st->codec, &gb, 1, 0, &st->metadata);
  412.         break;
  413.     case MKTAG('C', 'A', 'S', 'I'):
  414.         avpriv_request_sample(st->codec, "RIFF stream data tag type CASI (%u)", tag);
  415.         break;
  416.     case MKTAG('Z', 'o', 'r', 'a'):
  417.         avpriv_request_sample(st->codec, "RIFF stream data tag type Zora (%u)", tag);
  418.         break;
  419.     default:
  420.         break;
  421.     }
  422.  
  423.     return 0;
  424. }
  425.  
  426. static int calculate_bitrate(AVFormatContext *s)
  427. {
  428.     AVIContext *avi = s->priv_data;
  429.     int i, j;
  430.     int64_t lensum = 0;
  431.     int64_t maxpos = 0;
  432.  
  433.     for (i = 0; i<s->nb_streams; i++) {
  434.         int64_t len = 0;
  435.         AVStream *st = s->streams[i];
  436.  
  437.         if (!st->nb_index_entries)
  438.             continue;
  439.  
  440.         for (j = 0; j < st->nb_index_entries; j++)
  441.             len += st->index_entries[j].size;
  442.         maxpos = FFMAX(maxpos, st->index_entries[j-1].pos);
  443.         lensum += len;
  444.     }
  445.     if (maxpos < avi->io_fsize*9/10) // index does not cover the whole file
  446.         return 0;
  447.     if (lensum*9/10 > maxpos || lensum < maxpos*9/10) // frame sum and filesize mismatch
  448.         return 0;
  449.  
  450.     for (i = 0; i<s->nb_streams; i++) {
  451.         int64_t len = 0;
  452.         AVStream *st = s->streams[i];
  453.         int64_t duration;
  454.         int64_t bitrate;
  455.  
  456.         for (j = 0; j < st->nb_index_entries; j++)
  457.             len += st->index_entries[j].size;
  458.  
  459.         if (st->nb_index_entries < 2 || st->codec->bit_rate > 0)
  460.             continue;
  461.         duration = st->index_entries[j-1].timestamp - st->index_entries[0].timestamp;
  462.         bitrate = av_rescale(8*len, st->time_base.den, duration * st->time_base.num);
  463.         if (bitrate <= INT_MAX && bitrate > 0) {
  464.             st->codec->bit_rate = bitrate;
  465.         }
  466.     }
  467.     return 1;
  468. }
  469.  
  470. static int avi_read_header(AVFormatContext *s)
  471. {
  472.     AVIContext *avi = s->priv_data;
  473.     AVIOContext *pb = s->pb;
  474.     unsigned int tag, tag1, handler;
  475.     int codec_type, stream_index, frame_period;
  476.     unsigned int size;
  477.     int i;
  478.     AVStream *st;
  479.     AVIStream *ast      = NULL;
  480.     int avih_width      = 0, avih_height = 0;
  481.     int amv_file_format = 0;
  482.     uint64_t list_end   = 0;
  483.     int ret;
  484.     AVDictionaryEntry *dict_entry;
  485.  
  486.     avi->stream_index = -1;
  487.  
  488.     ret = get_riff(s, pb);
  489.     if (ret < 0)
  490.         return ret;
  491.  
  492.     av_log(avi, AV_LOG_DEBUG, "use odml:%d\n", avi->use_odml);
  493.  
  494.     avi->io_fsize = avi->fsize = avio_size(pb);
  495.     if (avi->fsize <= 0 || avi->fsize < avi->riff_end)
  496.         avi->fsize = avi->riff_end == 8 ? INT64_MAX : avi->riff_end;
  497.  
  498.     /* first list tag */
  499.     stream_index = -1;
  500.     codec_type   = -1;
  501.     frame_period = 0;
  502.     for (;;) {
  503.         if (avio_feof(pb))
  504.             goto fail;
  505.         tag  = avio_rl32(pb);
  506.         size = avio_rl32(pb);
  507.  
  508.         print_tag("tag", tag, size);
  509.  
  510.         switch (tag) {
  511.         case MKTAG('L', 'I', 'S', 'T'):
  512.             list_end = avio_tell(pb) + size;
  513.             /* Ignored, except at start of video packets. */
  514.             tag1 = avio_rl32(pb);
  515.  
  516.             print_tag("list", tag1, 0);
  517.  
  518.             if (tag1 == MKTAG('m', 'o', 'v', 'i')) {
  519.                 avi->movi_list = avio_tell(pb) - 4;
  520.                 if (size)
  521.                     avi->movi_end = avi->movi_list + size + (size & 1);
  522.                 else
  523.                     avi->movi_end = avi->fsize;
  524.                 av_log(NULL, AV_LOG_TRACE, "movi end=%"PRIx64"\n", avi->movi_end);
  525.                 goto end_of_header;
  526.             } else if (tag1 == MKTAG('I', 'N', 'F', 'O'))
  527.                 ff_read_riff_info(s, size - 4);
  528.             else if (tag1 == MKTAG('n', 'c', 'd', 't'))
  529.                 avi_read_nikon(s, list_end);
  530.  
  531.             break;
  532.         case MKTAG('I', 'D', 'I', 'T'):
  533.         {
  534.             unsigned char date[64] = { 0 };
  535.             size += (size & 1);
  536.             size -= avio_read(pb, date, FFMIN(size, sizeof(date) - 1));
  537.             avio_skip(pb, size);
  538.             avi_metadata_creation_time(&s->metadata, date);
  539.             break;
  540.         }
  541.         case MKTAG('d', 'm', 'l', 'h'):
  542.             avi->is_odml = 1;
  543.             avio_skip(pb, size + (size & 1));
  544.             break;
  545.         case MKTAG('a', 'm', 'v', 'h'):
  546.             amv_file_format = 1;
  547.         case MKTAG('a', 'v', 'i', 'h'):
  548.             /* AVI header */
  549.             /* using frame_period is bad idea */
  550.             frame_period = avio_rl32(pb);
  551.             avio_rl32(pb); /* max. bytes per second */
  552.             avio_rl32(pb);
  553.             avi->non_interleaved |= avio_rl32(pb) & AVIF_MUSTUSEINDEX;
  554.  
  555.             avio_skip(pb, 2 * 4);
  556.             avio_rl32(pb);
  557.             avio_rl32(pb);
  558.             avih_width  = avio_rl32(pb);
  559.             avih_height = avio_rl32(pb);
  560.  
  561.             avio_skip(pb, size - 10 * 4);
  562.             break;
  563.         case MKTAG('s', 't', 'r', 'h'):
  564.             /* stream header */
  565.  
  566.             tag1    = avio_rl32(pb);
  567.             handler = avio_rl32(pb); /* codec tag */
  568.  
  569.             if (tag1 == MKTAG('p', 'a', 'd', 's')) {
  570.                 avio_skip(pb, size - 8);
  571.                 break;
  572.             } else {
  573.                 stream_index++;
  574.                 st = avformat_new_stream(s, NULL);
  575.                 if (!st)
  576.                     goto fail;
  577.  
  578.                 st->id = stream_index;
  579.                 ast    = av_mallocz(sizeof(AVIStream));
  580.                 if (!ast)
  581.                     goto fail;
  582.                 st->priv_data = ast;
  583.             }
  584.             if (amv_file_format)
  585.                 tag1 = stream_index ? MKTAG('a', 'u', 'd', 's')
  586.                                     : MKTAG('v', 'i', 'd', 's');
  587.  
  588.             print_tag("strh", tag1, -1);
  589.  
  590.             if (tag1 == MKTAG('i', 'a', 'v', 's') ||
  591.                 tag1 == MKTAG('i', 'v', 'a', 's')) {
  592.                 int64_t dv_dur;
  593.  
  594.                 /* After some consideration -- I don't think we
  595.                  * have to support anything but DV in type1 AVIs. */
  596.                 if (s->nb_streams != 1)
  597.                     goto fail;
  598.  
  599.                 if (handler != MKTAG('d', 'v', 's', 'd') &&
  600.                     handler != MKTAG('d', 'v', 'h', 'd') &&
  601.                     handler != MKTAG('d', 'v', 's', 'l'))
  602.                     goto fail;
  603.  
  604.                 ast = s->streams[0]->priv_data;
  605.                 av_freep(&s->streams[0]->codec->extradata);
  606.                 av_freep(&s->streams[0]->codec);
  607.                 if (s->streams[0]->info)
  608.                     av_freep(&s->streams[0]->info->duration_error);
  609.                 av_freep(&s->streams[0]->info);
  610.                 av_freep(&s->streams[0]);
  611.                 s->nb_streams = 0;
  612.                 if (CONFIG_DV_DEMUXER) {
  613.                     avi->dv_demux = avpriv_dv_init_demux(s);
  614.                     if (!avi->dv_demux)
  615.                         goto fail;
  616.                 } else
  617.                     goto fail;
  618.                 s->streams[0]->priv_data = ast;
  619.                 avio_skip(pb, 3 * 4);
  620.                 ast->scale = avio_rl32(pb);
  621.                 ast->rate  = avio_rl32(pb);
  622.                 avio_skip(pb, 4);  /* start time */
  623.  
  624.                 dv_dur = avio_rl32(pb);
  625.                 if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) {
  626.                     dv_dur     *= AV_TIME_BASE;
  627.                     s->duration = av_rescale(dv_dur, ast->scale, ast->rate);
  628.                 }
  629.                 /* else, leave duration alone; timing estimation in utils.c
  630.                  * will make a guess based on bitrate. */
  631.  
  632.                 stream_index = s->nb_streams - 1;
  633.                 avio_skip(pb, size - 9 * 4);
  634.                 break;
  635.             }
  636.  
  637.             av_assert0(stream_index < s->nb_streams);
  638.             ast->handler = handler;
  639.  
  640.             avio_rl32(pb); /* flags */
  641.             avio_rl16(pb); /* priority */
  642.             avio_rl16(pb); /* language */
  643.             avio_rl32(pb); /* initial frame */
  644.             ast->scale = avio_rl32(pb);
  645.             ast->rate  = avio_rl32(pb);
  646.             if (!(ast->scale && ast->rate)) {
  647.                 av_log(s, AV_LOG_WARNING,
  648.                        "scale/rate is %"PRIu32"/%"PRIu32" which is invalid. "
  649.                        "(This file has been generated by broken software.)\n",
  650.                        ast->scale,
  651.                        ast->rate);
  652.                 if (frame_period) {
  653.                     ast->rate  = 1000000;
  654.                     ast->scale = frame_period;
  655.                 } else {
  656.                     ast->rate  = 25;
  657.                     ast->scale = 1;
  658.                 }
  659.             }
  660.             avpriv_set_pts_info(st, 64, ast->scale, ast->rate);
  661.  
  662.             ast->cum_len  = avio_rl32(pb); /* start */
  663.             st->nb_frames = avio_rl32(pb);
  664.  
  665.             st->start_time = 0;
  666.             avio_rl32(pb); /* buffer size */
  667.             avio_rl32(pb); /* quality */
  668.             if (ast->cum_len*ast->scale/ast->rate > 3600) {
  669.                 av_log(s, AV_LOG_ERROR, "crazy start time, iam scared, giving up\n");
  670.                 ast->cum_len = 0;
  671.             }
  672.             ast->sample_size = avio_rl32(pb); /* sample ssize */
  673.             ast->cum_len    *= FFMAX(1, ast->sample_size);
  674.             av_log(s, AV_LOG_TRACE, "%"PRIu32" %"PRIu32" %d\n",
  675.                     ast->rate, ast->scale, ast->sample_size);
  676.  
  677.             switch (tag1) {
  678.             case MKTAG('v', 'i', 'd', 's'):
  679.                 codec_type = AVMEDIA_TYPE_VIDEO;
  680.  
  681.                 ast->sample_size = 0;
  682.                 st->avg_frame_rate = av_inv_q(st->time_base);
  683.                 break;
  684.             case MKTAG('a', 'u', 'd', 's'):
  685.                 codec_type = AVMEDIA_TYPE_AUDIO;
  686.                 break;
  687.             case MKTAG('t', 'x', 't', 's'):
  688.                 codec_type = AVMEDIA_TYPE_SUBTITLE;
  689.                 break;
  690.             case MKTAG('d', 'a', 't', 's'):
  691.                 codec_type = AVMEDIA_TYPE_DATA;
  692.                 break;
  693.             default:
  694.                 av_log(s, AV_LOG_INFO, "unknown stream type %X\n", tag1);
  695.             }
  696.  
  697.             if (ast->sample_size < 0) {
  698.                 if (s->error_recognition & AV_EF_EXPLODE) {
  699.                     av_log(s, AV_LOG_ERROR,
  700.                            "Invalid sample_size %d at stream %d\n",
  701.                            ast->sample_size,
  702.                            stream_index);
  703.                     goto fail;
  704.                 }
  705.                 av_log(s, AV_LOG_WARNING,
  706.                        "Invalid sample_size %d at stream %d "
  707.                        "setting it to 0\n",
  708.                        ast->sample_size,
  709.                        stream_index);
  710.                 ast->sample_size = 0;
  711.             }
  712.  
  713.             if (ast->sample_size == 0) {
  714.                 st->duration = st->nb_frames;
  715.                 if (st->duration > 0 && avi->io_fsize > 0 && avi->riff_end > avi->io_fsize) {
  716.                     av_log(s, AV_LOG_DEBUG, "File is truncated adjusting duration\n");
  717.                     st->duration = av_rescale(st->duration, avi->io_fsize, avi->riff_end);
  718.                 }
  719.             }
  720.             ast->frame_offset = ast->cum_len;
  721.             avio_skip(pb, size - 12 * 4);
  722.             break;
  723.         case MKTAG('s', 't', 'r', 'f'):
  724.             /* stream header */
  725.             if (!size)
  726.                 break;
  727.             if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) {
  728.                 avio_skip(pb, size);
  729.             } else {
  730.                 uint64_t cur_pos = avio_tell(pb);
  731.                 unsigned esize;
  732.                 if (cur_pos < list_end)
  733.                     size = FFMIN(size, list_end - cur_pos);
  734.                 st = s->streams[stream_index];
  735.                 if (st->codec->codec_type != AVMEDIA_TYPE_UNKNOWN) {
  736.                     avio_skip(pb, size);
  737.                     break;
  738.                 }
  739.                 switch (codec_type) {
  740.                 case AVMEDIA_TYPE_VIDEO:
  741.                     if (amv_file_format) {
  742.                         st->codec->width      = avih_width;
  743.                         st->codec->height     = avih_height;
  744.                         st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  745.                         st->codec->codec_id   = AV_CODEC_ID_AMV;
  746.                         avio_skip(pb, size);
  747.                         break;
  748.                     }
  749.                     tag1 = ff_get_bmp_header(pb, st, &esize);
  750.  
  751.                     if (tag1 == MKTAG('D', 'X', 'S', 'B') ||
  752.                         tag1 == MKTAG('D', 'X', 'S', 'A')) {
  753.                         st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
  754.                         st->codec->codec_tag  = tag1;
  755.                         st->codec->codec_id   = AV_CODEC_ID_XSUB;
  756.                         break;
  757.                     }
  758.  
  759.                     if (size > 10 * 4 && size < (1 << 30) && size < avi->fsize) {
  760.                         if (esize == size-1 && (esize&1)) {
  761.                             st->codec->extradata_size = esize - 10 * 4;
  762.                         } else
  763.                             st->codec->extradata_size =  size - 10 * 4;
  764.                         if (ff_get_extradata(st->codec, pb, st->codec->extradata_size) < 0)
  765.                             return AVERROR(ENOMEM);
  766.                     }
  767.  
  768.                     // FIXME: check if the encoder really did this correctly
  769.                     if (st->codec->extradata_size & 1)
  770.                         avio_r8(pb);
  771.  
  772.                     /* Extract palette from extradata if bpp <= 8.
  773.                      * This code assumes that extradata contains only palette.
  774.                      * This is true for all paletted codecs implemented in
  775.                      * FFmpeg. */
  776.                     if (st->codec->extradata_size &&
  777.                         (st->codec->bits_per_coded_sample <= 8)) {
  778.                         int pal_size = (1 << st->codec->bits_per_coded_sample) << 2;
  779.                         const uint8_t *pal_src;
  780.  
  781.                         pal_size = FFMIN(pal_size, st->codec->extradata_size);
  782.                         pal_src  = st->codec->extradata +
  783.                                    st->codec->extradata_size - pal_size;
  784.                         /* Exclude the "BottomUp" field from the palette */
  785.                         if (pal_src - st->codec->extradata >= 9 &&
  786.                             !memcmp(st->codec->extradata + st->codec->extradata_size - 9, "BottomUp", 9))
  787.                             pal_src -= 9;
  788.                         for (i = 0; i < pal_size / 4; i++)
  789.                             ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src+4*i);
  790.                         ast->has_pal = 1;
  791.                     }
  792.  
  793.                     print_tag("video", tag1, 0);
  794.  
  795.                     st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
  796.                     st->codec->codec_tag  = tag1;
  797.                     st->codec->codec_id   = ff_codec_get_id(ff_codec_bmp_tags,
  798.                                                             tag1);
  799.                     /* If codec is not found yet, try with the mov tags. */
  800.                     if (!st->codec->codec_id) {
  801.                         char tag_buf[32];
  802.                         av_get_codec_tag_string(tag_buf, sizeof(tag_buf), tag1);
  803.                         st->codec->codec_id =
  804.                             ff_codec_get_id(ff_codec_movvideo_tags, tag1);
  805.                         if (st->codec->codec_id)
  806.                            av_log(s, AV_LOG_WARNING,
  807.                                   "mov tag found in avi (fourcc %s)\n",
  808.                                   tag_buf);
  809.                     }
  810.                     /* This is needed to get the pict type which is necessary
  811.                      * for generating correct pts. */
  812.                     st->need_parsing = AVSTREAM_PARSE_HEADERS;
  813.  
  814.                     if (st->codec->codec_id == AV_CODEC_ID_MPEG4 &&
  815.                         ast->handler == MKTAG('X', 'V', 'I', 'D'))
  816.                         st->codec->codec_tag = MKTAG('X', 'V', 'I', 'D');
  817.  
  818.                     if (st->codec->codec_tag == MKTAG('V', 'S', 'S', 'H'))
  819.                         st->need_parsing = AVSTREAM_PARSE_FULL;
  820.  
  821.                     if (st->codec->codec_tag == 0 && st->codec->height > 0 &&
  822.                         st->codec->extradata_size < 1U << 30) {
  823.                         st->codec->extradata_size += 9;
  824.                         if ((ret = av_reallocp(&st->codec->extradata,
  825.                                                st->codec->extradata_size +
  826.                                                AV_INPUT_BUFFER_PADDING_SIZE)) < 0) {
  827.                             st->codec->extradata_size = 0;
  828.                             return ret;
  829.                         } else
  830.                             memcpy(st->codec->extradata + st->codec->extradata_size - 9,
  831.                                    "BottomUp", 9);
  832.                     }
  833.                     st->codec->height = FFABS(st->codec->height);
  834.  
  835. //                    avio_skip(pb, size - 5 * 4);
  836.                     break;
  837.                 case AVMEDIA_TYPE_AUDIO:
  838.                     ret = ff_get_wav_header(s, pb, st->codec, size, 0);
  839.                     if (ret < 0)
  840.                         return ret;
  841.                     ast->dshow_block_align = st->codec->block_align;
  842.                     if (ast->sample_size && st->codec->block_align &&
  843.                         ast->sample_size != st->codec->block_align) {
  844.                         av_log(s,
  845.                                AV_LOG_WARNING,
  846.                                "sample size (%d) != block align (%d)\n",
  847.                                ast->sample_size,
  848.                                st->codec->block_align);
  849.                         ast->sample_size = st->codec->block_align;
  850.                     }
  851.                     /* 2-aligned
  852.                      * (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */
  853.                     if (size & 1)
  854.                         avio_skip(pb, 1);
  855.                     /* Force parsing as several audio frames can be in
  856.                      * one packet and timestamps refer to packet start. */
  857.                     st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;
  858.                     /* ADTS header is in extradata, AAC without header must be
  859.                      * stored as exact frames. Parser not needed and it will
  860.                      * fail. */
  861.                     if (st->codec->codec_id == AV_CODEC_ID_AAC &&
  862.                         st->codec->extradata_size)
  863.                         st->need_parsing = AVSTREAM_PARSE_NONE;
  864.                     // The flac parser does not work with AVSTREAM_PARSE_TIMESTAMPS
  865.                     if (st->codec->codec_id == AV_CODEC_ID_FLAC)
  866.                         st->need_parsing = AVSTREAM_PARSE_NONE;
  867.                     /* AVI files with Xan DPCM audio (wrongly) declare PCM
  868.                      * audio in the header but have Axan as stream_code_tag. */
  869.                     if (ast->handler == AV_RL32("Axan")) {
  870.                         st->codec->codec_id  = AV_CODEC_ID_XAN_DPCM;
  871.                         st->codec->codec_tag = 0;
  872.                         ast->dshow_block_align = 0;
  873.                     }
  874.                     if (amv_file_format) {
  875.                         st->codec->codec_id    = AV_CODEC_ID_ADPCM_IMA_AMV;
  876.                         ast->dshow_block_align = 0;
  877.                     }
  878.                     if ((st->codec->codec_id == AV_CODEC_ID_AAC  ||
  879.                          st->codec->codec_id == AV_CODEC_ID_FLAC ||
  880.                          st->codec->codec_id == AV_CODEC_ID_MP2 ) && ast->dshow_block_align <= 4 && ast->dshow_block_align) {
  881.                         av_log(s, AV_LOG_DEBUG, "overriding invalid dshow_block_align of %d\n", ast->dshow_block_align);
  882.                         ast->dshow_block_align = 0;
  883.                     }
  884.                     if (st->codec->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 1024 && ast->sample_size == 1024 ||
  885.                        st->codec->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 4096 && ast->sample_size == 4096 ||
  886.                        st->codec->codec_id == AV_CODEC_ID_MP3 && ast->dshow_block_align == 1152 && ast->sample_size == 1152) {
  887.                         av_log(s, AV_LOG_DEBUG, "overriding sample_size\n");
  888.                         ast->sample_size = 0;
  889.                     }
  890.                     break;
  891.                 case AVMEDIA_TYPE_SUBTITLE:
  892.                     st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
  893.                     st->request_probe= 1;
  894.                     avio_skip(pb, size);
  895.                     break;
  896.                 default:
  897.                     st->codec->codec_type = AVMEDIA_TYPE_DATA;
  898.                     st->codec->codec_id   = AV_CODEC_ID_NONE;
  899.                     st->codec->codec_tag  = 0;
  900.                     avio_skip(pb, size);
  901.                     break;
  902.                 }
  903.             }
  904.             break;
  905.         case MKTAG('s', 't', 'r', 'd'):
  906.             if (stream_index >= (unsigned)s->nb_streams
  907.                 || s->streams[stream_index]->codec->extradata_size
  908.                 || s->streams[stream_index]->codec->codec_tag == MKTAG('H','2','6','4')) {
  909.                 avio_skip(pb, size);
  910.             } else {
  911.                 uint64_t cur_pos = avio_tell(pb);
  912.                 if (cur_pos < list_end)
  913.                     size = FFMIN(size, list_end - cur_pos);
  914.                 st = s->streams[stream_index];
  915.  
  916.                 if (size<(1<<30)) {
  917.                     if (ff_get_extradata(st->codec, pb, size) < 0)
  918.                         return AVERROR(ENOMEM);
  919.                 }
  920.  
  921.                 if (st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly
  922.                     avio_r8(pb);
  923.  
  924.                 ret = avi_extract_stream_metadata(st);
  925.                 if (ret < 0) {
  926.                     av_log(s, AV_LOG_WARNING, "could not decoding EXIF data in stream header.\n");
  927.                 }
  928.             }
  929.             break;
  930.         case MKTAG('i', 'n', 'd', 'x'):
  931.             i = avio_tell(pb);
  932.             if (pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX) &&
  933.                 avi->use_odml &&
  934.                 read_braindead_odml_indx(s, 0) < 0 &&
  935.                 (s->error_recognition & AV_EF_EXPLODE))
  936.                 goto fail;
  937.             avio_seek(pb, i + size, SEEK_SET);
  938.             break;
  939.         case MKTAG('v', 'p', 'r', 'p'):
  940.             if (stream_index < (unsigned)s->nb_streams && size > 9 * 4) {
  941.                 AVRational active, active_aspect;
  942.  
  943.                 st = s->streams[stream_index];
  944.                 avio_rl32(pb);
  945.                 avio_rl32(pb);
  946.                 avio_rl32(pb);
  947.                 avio_rl32(pb);
  948.                 avio_rl32(pb);
  949.  
  950.                 active_aspect.den = avio_rl16(pb);
  951.                 active_aspect.num = avio_rl16(pb);
  952.                 active.num        = avio_rl32(pb);
  953.                 active.den        = avio_rl32(pb);
  954.                 avio_rl32(pb); // nbFieldsPerFrame
  955.  
  956.                 if (active_aspect.num && active_aspect.den &&
  957.                     active.num && active.den) {
  958.                     st->sample_aspect_ratio = av_div_q(active_aspect, active);
  959.                     av_log(s, AV_LOG_TRACE, "vprp %d/%d %d/%d\n",
  960.                             active_aspect.num, active_aspect.den,
  961.                             active.num, active.den);
  962.                 }
  963.                 size -= 9 * 4;
  964.             }
  965.             avio_skip(pb, size);
  966.             break;
  967.         case MKTAG('s', 't', 'r', 'n'):
  968.             if (s->nb_streams) {
  969.                 ret = avi_read_tag(s, s->streams[s->nb_streams - 1], tag, size);
  970.                 if (ret < 0)
  971.                     return ret;
  972.                 break;
  973.             }
  974.         default:
  975.             if (size > 1000000) {
  976.                 av_log(s, AV_LOG_ERROR,
  977.                        "Something went wrong during header parsing, "
  978.                        "I will ignore it and try to continue anyway.\n");
  979.                 if (s->error_recognition & AV_EF_EXPLODE)
  980.                     goto fail;
  981.                 avi->movi_list = avio_tell(pb) - 4;
  982.                 avi->movi_end  = avi->fsize;
  983.                 goto end_of_header;
  984.             }
  985.             /* skip tag */
  986.             size += (size & 1);
  987.             avio_skip(pb, size);
  988.             break;
  989.         }
  990.     }
  991.  
  992. end_of_header:
  993.     /* check stream number */
  994.     if (stream_index != s->nb_streams - 1) {
  995.  
  996. fail:
  997.         return AVERROR_INVALIDDATA;
  998.     }
  999.  
  1000.     if (!avi->index_loaded && pb->seekable)
  1001.         avi_load_index(s);
  1002.     calculate_bitrate(s);
  1003.     avi->index_loaded    |= 1;
  1004.  
  1005.     if ((ret = guess_ni_flag(s)) < 0)
  1006.         return ret;
  1007.  
  1008.     avi->non_interleaved |= ret | (s->flags & AVFMT_FLAG_SORT_DTS);
  1009.  
  1010.     dict_entry = av_dict_get(s->metadata, "ISFT", NULL, 0);
  1011.     if (dict_entry && !strcmp(dict_entry->value, "PotEncoder"))
  1012.         for (i = 0; i < s->nb_streams; i++) {
  1013.             AVStream *st = s->streams[i];
  1014.             if (   st->codec->codec_id == AV_CODEC_ID_MPEG1VIDEO
  1015.                 || st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO)
  1016.                 st->need_parsing = AVSTREAM_PARSE_FULL;
  1017.         }
  1018.  
  1019.     for (i = 0; i < s->nb_streams; i++) {
  1020.         AVStream *st = s->streams[i];
  1021.         if (st->nb_index_entries)
  1022.             break;
  1023.     }
  1024.     // DV-in-AVI cannot be non-interleaved, if set this must be
  1025.     // a mis-detection.
  1026.     if (avi->dv_demux)
  1027.         avi->non_interleaved = 0;
  1028.     if (i == s->nb_streams && avi->non_interleaved) {
  1029.         av_log(s, AV_LOG_WARNING,
  1030.                "Non-interleaved AVI without index, switching to interleaved\n");
  1031.         avi->non_interleaved = 0;
  1032.     }
  1033.  
  1034.     if (avi->non_interleaved) {
  1035.         av_log(s, AV_LOG_INFO, "non-interleaved AVI\n");
  1036.         clean_index(s);
  1037.     }
  1038.  
  1039.     ff_metadata_conv_ctx(s, NULL, avi_metadata_conv);
  1040.     ff_metadata_conv_ctx(s, NULL, ff_riff_info_conv);
  1041.  
  1042.     return 0;
  1043. }
  1044.  
  1045. static int read_gab2_sub(AVFormatContext *s, AVStream *st, AVPacket *pkt)
  1046. {
  1047.     if (pkt->size >= 7 &&
  1048.         pkt->size < INT_MAX - AVPROBE_PADDING_SIZE &&
  1049.         !strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data + 5) == 2) {
  1050.         uint8_t desc[256];
  1051.         int score      = AVPROBE_SCORE_EXTENSION, ret;
  1052.         AVIStream *ast = st->priv_data;
  1053.         AVInputFormat *sub_demuxer;
  1054.         AVRational time_base;
  1055.         int size;
  1056.         AVIOContext *pb = avio_alloc_context(pkt->data + 7,
  1057.                                              pkt->size - 7,
  1058.                                              0, NULL, NULL, NULL, NULL);
  1059.         AVProbeData pd;
  1060.         unsigned int desc_len = avio_rl32(pb);
  1061.  
  1062.         if (desc_len > pb->buf_end - pb->buf_ptr)
  1063.             goto error;
  1064.  
  1065.         ret = avio_get_str16le(pb, desc_len, desc, sizeof(desc));
  1066.         avio_skip(pb, desc_len - ret);
  1067.         if (*desc)
  1068.             av_dict_set(&st->metadata, "title", desc, 0);
  1069.  
  1070.         avio_rl16(pb);   /* flags? */
  1071.         avio_rl32(pb);   /* data size */
  1072.  
  1073.         size = pb->buf_end - pb->buf_ptr;
  1074.         pd = (AVProbeData) { .buf      = av_mallocz(size + AVPROBE_PADDING_SIZE),
  1075.                              .buf_size = size };
  1076.         if (!pd.buf)
  1077.             goto error;
  1078.         memcpy(pd.buf, pb->buf_ptr, size);
  1079.         sub_demuxer = av_probe_input_format2(&pd, 1, &score);
  1080.         av_freep(&pd.buf);
  1081.         if (!sub_demuxer)
  1082.             goto error;
  1083.  
  1084.         if (!(ast->sub_ctx = avformat_alloc_context()))
  1085.             goto error;
  1086.  
  1087.         ast->sub_ctx->pb = pb;
  1088.  
  1089.         if (ff_copy_whitelists(ast->sub_ctx, s) < 0)
  1090.             goto error;
  1091.  
  1092.         if (!avformat_open_input(&ast->sub_ctx, "", sub_demuxer, NULL)) {
  1093.             ff_read_packet(ast->sub_ctx, &ast->sub_pkt);
  1094.             *st->codec = *ast->sub_ctx->streams[0]->codec;
  1095.             ast->sub_ctx->streams[0]->codec->extradata = NULL;
  1096.             time_base = ast->sub_ctx->streams[0]->time_base;
  1097.             avpriv_set_pts_info(st, 64, time_base.num, time_base.den);
  1098.         }
  1099.         ast->sub_buffer = pkt->data;
  1100.         memset(pkt, 0, sizeof(*pkt));
  1101.         return 1;
  1102.  
  1103. error:
  1104.         av_freep(&ast->sub_ctx);
  1105.         av_freep(&pb);
  1106.     }
  1107.     return 0;
  1108. }
  1109.  
  1110. static AVStream *get_subtitle_pkt(AVFormatContext *s, AVStream *next_st,
  1111.                                   AVPacket *pkt)
  1112. {
  1113.     AVIStream *ast, *next_ast = next_st->priv_data;
  1114.     int64_t ts, next_ts, ts_min = INT64_MAX;
  1115.     AVStream *st, *sub_st = NULL;
  1116.     int i;
  1117.  
  1118.     next_ts = av_rescale_q(next_ast->frame_offset, next_st->time_base,
  1119.                            AV_TIME_BASE_Q);
  1120.  
  1121.     for (i = 0; i < s->nb_streams; i++) {
  1122.         st  = s->streams[i];
  1123.         ast = st->priv_data;
  1124.         if (st->discard < AVDISCARD_ALL && ast && ast->sub_pkt.data) {
  1125.             ts = av_rescale_q(ast->sub_pkt.dts, st->time_base, AV_TIME_BASE_Q);
  1126.             if (ts <= next_ts && ts < ts_min) {
  1127.                 ts_min = ts;
  1128.                 sub_st = st;
  1129.             }
  1130.         }
  1131.     }
  1132.  
  1133.     if (sub_st) {
  1134.         ast               = sub_st->priv_data;
  1135.         *pkt              = ast->sub_pkt;
  1136.         pkt->stream_index = sub_st->index;
  1137.  
  1138.         if (ff_read_packet(ast->sub_ctx, &ast->sub_pkt) < 0)
  1139.             ast->sub_pkt.data = NULL;
  1140.     }
  1141.     return sub_st;
  1142. }
  1143.  
  1144. static int get_stream_idx(const unsigned *d)
  1145. {
  1146.     if (d[0] >= '0' && d[0] <= '9' &&
  1147.         d[1] >= '0' && d[1] <= '9') {
  1148.         return (d[0] - '0') * 10 + (d[1] - '0');
  1149.     } else {
  1150.         return 100; // invalid stream ID
  1151.     }
  1152. }
  1153.  
  1154. /**
  1155.  *
  1156.  * @param exit_early set to 1 to just gather packet position without making the changes needed to actually read & return the packet
  1157.  */
  1158. static int avi_sync(AVFormatContext *s, int exit_early)
  1159. {
  1160.     AVIContext *avi = s->priv_data;
  1161.     AVIOContext *pb = s->pb;
  1162.     int n;
  1163.     unsigned int d[8];
  1164.     unsigned int size;
  1165.     int64_t i, sync;
  1166.  
  1167. start_sync:
  1168.     memset(d, -1, sizeof(d));
  1169.     for (i = sync = avio_tell(pb); !avio_feof(pb); i++) {
  1170.         int j;
  1171.  
  1172.         for (j = 0; j < 7; j++)
  1173.             d[j] = d[j + 1];
  1174.         d[7] = avio_r8(pb);
  1175.  
  1176.         size = d[4] + (d[5] << 8) + (d[6] << 16) + (d[7] << 24);
  1177.  
  1178.         n = get_stream_idx(d + 2);
  1179.         ff_tlog(s, "%X %X %X %X %X %X %X %X %"PRId64" %u %d\n",
  1180.                 d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n);
  1181.         if (i*(avi->io_fsize>0) + (uint64_t)size > avi->fsize || d[0] > 127)
  1182.             continue;
  1183.  
  1184.         // parse ix##
  1185.         if ((d[0] == 'i' && d[1] == 'x' && n < s->nb_streams) ||
  1186.             // parse JUNK
  1187.             (d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K') ||
  1188.             (d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1')) {
  1189.             avio_skip(pb, size);
  1190.             goto start_sync;
  1191.         }
  1192.  
  1193.         // parse stray LIST
  1194.         if (d[0] == 'L' && d[1] == 'I' && d[2] == 'S' && d[3] == 'T') {
  1195.             avio_skip(pb, 4);
  1196.             goto start_sync;
  1197.         }
  1198.  
  1199.         n = get_stream_idx(d);
  1200.  
  1201.         if (!((i - avi->last_pkt_pos) & 1) &&
  1202.             get_stream_idx(d + 1) < s->nb_streams)
  1203.             continue;
  1204.  
  1205.         // detect ##ix chunk and skip
  1206.         if (d[2] == 'i' && d[3] == 'x' && n < s->nb_streams) {
  1207.             avio_skip(pb, size);
  1208.             goto start_sync;
  1209.         }
  1210.  
  1211.         if (avi->dv_demux && n != 0)
  1212.             continue;
  1213.  
  1214.         // parse ##dc/##wb
  1215.         if (n < s->nb_streams) {
  1216.             AVStream *st;
  1217.             AVIStream *ast;
  1218.             st  = s->streams[n];
  1219.             ast = st->priv_data;
  1220.  
  1221.             if (!ast) {
  1222.                 av_log(s, AV_LOG_WARNING, "Skipping foreign stream %d packet\n", n);
  1223.                 continue;
  1224.             }
  1225.  
  1226.             if (s->nb_streams >= 2) {
  1227.                 AVStream *st1   = s->streams[1];
  1228.                 AVIStream *ast1 = st1->priv_data;
  1229.                 // workaround for broken small-file-bug402.avi
  1230.                 if (   d[2] == 'w' && d[3] == 'b'
  1231.                    && n == 0
  1232.                    && st ->codec->codec_type == AVMEDIA_TYPE_VIDEO
  1233.                    && st1->codec->codec_type == AVMEDIA_TYPE_AUDIO
  1234.                    && ast->prefix == 'd'*256+'c'
  1235.                    && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count)
  1236.                   ) {
  1237.                     n   = 1;
  1238.                     st  = st1;
  1239.                     ast = ast1;
  1240.                     av_log(s, AV_LOG_WARNING,
  1241.                            "Invalid stream + prefix combination, assuming audio.\n");
  1242.                 }
  1243.             }
  1244.  
  1245.             if (!avi->dv_demux &&
  1246.                 ((st->discard >= AVDISCARD_DEFAULT && size == 0) /* ||
  1247.                  // FIXME: needs a little reordering
  1248.                  (st->discard >= AVDISCARD_NONKEY &&
  1249.                  !(pkt->flags & AV_PKT_FLAG_KEY)) */
  1250.                 || st->discard >= AVDISCARD_ALL)) {
  1251.                 if (!exit_early) {
  1252.                     ast->frame_offset += get_duration(ast, size);
  1253.                     avio_skip(pb, size);
  1254.                     goto start_sync;
  1255.                 }
  1256.             }
  1257.  
  1258.             if (d[2] == 'p' && d[3] == 'c' && size <= 4 * 256 + 4) {
  1259.                 int k    = avio_r8(pb);
  1260.                 int last = (k + avio_r8(pb) - 1) & 0xFF;
  1261.  
  1262.                 avio_rl16(pb); // flags
  1263.  
  1264.                 // b + (g << 8) + (r << 16);
  1265.                 for (; k <= last; k++)
  1266.                     ast->pal[k] = 0xFFU<<24 | avio_rb32(pb)>>8;
  1267.  
  1268.                 ast->has_pal = 1;
  1269.                 goto start_sync;
  1270.             } else if (((ast->prefix_count < 5 || sync + 9 > i) &&
  1271.                         d[2] < 128 && d[3] < 128) ||
  1272.                        d[2] * 256 + d[3] == ast->prefix /* ||
  1273.                        (d[2] == 'd' && d[3] == 'c') ||
  1274.                        (d[2] == 'w' && d[3] == 'b') */) {
  1275.                 if (exit_early)
  1276.                     return 0;
  1277.                 if (d[2] * 256 + d[3] == ast->prefix)
  1278.                     ast->prefix_count++;
  1279.                 else {
  1280.                     ast->prefix       = d[2] * 256 + d[3];
  1281.                     ast->prefix_count = 0;
  1282.                 }
  1283.  
  1284.                 avi->stream_index = n;
  1285.                 ast->packet_size  = size + 8;
  1286.                 ast->remaining    = size;
  1287.  
  1288.                 if (size) {
  1289.                     uint64_t pos = avio_tell(pb) - 8;
  1290.                     if (!st->index_entries || !st->nb_index_entries ||
  1291.                         st->index_entries[st->nb_index_entries - 1].pos < pos) {
  1292.                         av_add_index_entry(st, pos, ast->frame_offset, size,
  1293.                                            0, AVINDEX_KEYFRAME);
  1294.                     }
  1295.                 }
  1296.                 return 0;
  1297.             }
  1298.         }
  1299.     }
  1300.  
  1301.     if (pb->error)
  1302.         return pb->error;
  1303.     return AVERROR_EOF;
  1304. }
  1305.  
  1306. static int avi_read_packet(AVFormatContext *s, AVPacket *pkt)
  1307. {
  1308.     AVIContext *avi = s->priv_data;
  1309.     AVIOContext *pb = s->pb;
  1310.     int err;
  1311. #if FF_API_DESTRUCT_PACKET
  1312.     void *dstr;
  1313. #endif
  1314.  
  1315.     if (CONFIG_DV_DEMUXER && avi->dv_demux) {
  1316.         int size = avpriv_dv_get_packet(avi->dv_demux, pkt);
  1317.         if (size >= 0)
  1318.             return size;
  1319.         else
  1320.             goto resync;
  1321.     }
  1322.  
  1323.     if (avi->non_interleaved) {
  1324.         int best_stream_index = 0;
  1325.         AVStream *best_st     = NULL;
  1326.         AVIStream *best_ast;
  1327.         int64_t best_ts = INT64_MAX;
  1328.         int i;
  1329.  
  1330.         for (i = 0; i < s->nb_streams; i++) {
  1331.             AVStream *st   = s->streams[i];
  1332.             AVIStream *ast = st->priv_data;
  1333.             int64_t ts     = ast->frame_offset;
  1334.             int64_t last_ts;
  1335.  
  1336.             if (!st->nb_index_entries)
  1337.                 continue;
  1338.  
  1339.             last_ts = st->index_entries[st->nb_index_entries - 1].timestamp;
  1340.             if (!ast->remaining && ts > last_ts)
  1341.                 continue;
  1342.  
  1343.             ts = av_rescale_q(ts, st->time_base,
  1344.                               (AVRational) { FFMAX(1, ast->sample_size),
  1345.                                              AV_TIME_BASE });
  1346.  
  1347.             av_log(s, AV_LOG_TRACE, "%"PRId64" %d/%d %"PRId64"\n", ts,
  1348.                     st->time_base.num, st->time_base.den, ast->frame_offset);
  1349.             if (ts < best_ts) {
  1350.                 best_ts           = ts;
  1351.                 best_st           = st;
  1352.                 best_stream_index = i;
  1353.             }
  1354.         }
  1355.         if (!best_st)
  1356.             return AVERROR_EOF;
  1357.  
  1358.         best_ast = best_st->priv_data;
  1359.         best_ts  = best_ast->frame_offset;
  1360.         if (best_ast->remaining) {
  1361.             i = av_index_search_timestamp(best_st,
  1362.                                           best_ts,
  1363.                                           AVSEEK_FLAG_ANY |
  1364.                                           AVSEEK_FLAG_BACKWARD);
  1365.         } else {
  1366.             i = av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY);
  1367.             if (i >= 0)
  1368.                 best_ast->frame_offset = best_st->index_entries[i].timestamp;
  1369.         }
  1370.  
  1371.         if (i >= 0) {
  1372.             int64_t pos = best_st->index_entries[i].pos;
  1373.             pos += best_ast->packet_size - best_ast->remaining;
  1374.             if (avio_seek(s->pb, pos + 8, SEEK_SET) < 0)
  1375.               return AVERROR_EOF;
  1376.  
  1377.             av_assert0(best_ast->remaining <= best_ast->packet_size);
  1378.  
  1379.             avi->stream_index = best_stream_index;
  1380.             if (!best_ast->remaining)
  1381.                 best_ast->packet_size =
  1382.                 best_ast->remaining   = best_st->index_entries[i].size;
  1383.         }
  1384.         else
  1385.           return AVERROR_EOF;
  1386.     }
  1387.  
  1388. resync:
  1389.     if (avi->stream_index >= 0) {
  1390.         AVStream *st   = s->streams[avi->stream_index];
  1391.         AVIStream *ast = st->priv_data;
  1392.         int size, err;
  1393.  
  1394.         if (get_subtitle_pkt(s, st, pkt))
  1395.             return 0;
  1396.  
  1397.         // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM
  1398.         if (ast->sample_size <= 1)
  1399.             size = INT_MAX;
  1400.         else if (ast->sample_size < 32)
  1401.             // arbitrary multiplier to avoid tiny packets for raw PCM data
  1402.             size = 1024 * ast->sample_size;
  1403.         else
  1404.             size = ast->sample_size;
  1405.  
  1406.         if (size > ast->remaining)
  1407.             size = ast->remaining;
  1408.         avi->last_pkt_pos = avio_tell(pb);
  1409.         err               = av_get_packet(pb, pkt, size);
  1410.         if (err < 0)
  1411.             return err;
  1412.         size = err;
  1413.  
  1414.         if (ast->has_pal && pkt->size < (unsigned)INT_MAX / 2) {
  1415.             uint8_t *pal;
  1416.             pal = av_packet_new_side_data(pkt,
  1417.                                           AV_PKT_DATA_PALETTE,
  1418.                                           AVPALETTE_SIZE);
  1419.             if (!pal) {
  1420.                 av_log(s, AV_LOG_ERROR,
  1421.                        "Failed to allocate data for palette\n");
  1422.             } else {
  1423.                 memcpy(pal, ast->pal, AVPALETTE_SIZE);
  1424.                 ast->has_pal = 0;
  1425.             }
  1426.         }
  1427.  
  1428.         if (CONFIG_DV_DEMUXER && avi->dv_demux) {
  1429.             AVBufferRef *avbuf = pkt->buf;
  1430. #if FF_API_DESTRUCT_PACKET
  1431. FF_DISABLE_DEPRECATION_WARNINGS
  1432.             dstr = pkt->destruct;
  1433. FF_ENABLE_DEPRECATION_WARNINGS
  1434. #endif
  1435.             size = avpriv_dv_produce_packet(avi->dv_demux, pkt,
  1436.                                             pkt->data, pkt->size, pkt->pos);
  1437. #if FF_API_DESTRUCT_PACKET
  1438. FF_DISABLE_DEPRECATION_WARNINGS
  1439.             pkt->destruct = dstr;
  1440. FF_ENABLE_DEPRECATION_WARNINGS
  1441. #endif
  1442.             pkt->buf    = avbuf;
  1443.             pkt->flags |= AV_PKT_FLAG_KEY;
  1444.             if (size < 0)
  1445.                 av_free_packet(pkt);
  1446.         } else if (st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE &&
  1447.                    !st->codec->codec_tag && read_gab2_sub(s, st, pkt)) {
  1448.             ast->frame_offset++;
  1449.             avi->stream_index = -1;
  1450.             ast->remaining    = 0;
  1451.             goto resync;
  1452.         } else {
  1453.             /* XXX: How to handle B-frames in AVI? */
  1454.             pkt->dts = ast->frame_offset;
  1455. //                pkt->dts += ast->start;
  1456.             if (ast->sample_size)
  1457.                 pkt->dts /= ast->sample_size;
  1458.             av_log(s, AV_LOG_TRACE,
  1459.                     "dts:%"PRId64" offset:%"PRId64" %d/%d smpl_siz:%d "
  1460.                     "base:%d st:%d size:%d\n",
  1461.                     pkt->dts,
  1462.                     ast->frame_offset,
  1463.                     ast->scale,
  1464.                     ast->rate,
  1465.                     ast->sample_size,
  1466.                     AV_TIME_BASE,
  1467.                     avi->stream_index,
  1468.                     size);
  1469.             pkt->stream_index = avi->stream_index;
  1470.  
  1471.             if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && st->index_entries) {
  1472.                 AVIndexEntry *e;
  1473.                 int index;
  1474.  
  1475.                 index = av_index_search_timestamp(st, ast->frame_offset, AVSEEK_FLAG_ANY);
  1476.                 e     = &st->index_entries[index];
  1477.  
  1478.                 if (index >= 0 && e->timestamp == ast->frame_offset) {
  1479.                     if (index == st->nb_index_entries-1) {
  1480.                         int key=1;
  1481.                         uint32_t state=-1;
  1482.                         if (st->codec->codec_id == AV_CODEC_ID_MPEG4) {
  1483.                             const uint8_t *ptr = pkt->data, *end = ptr + FFMIN(size, 256);
  1484.                             while (ptr < end) {
  1485.                                 ptr = avpriv_find_start_code(ptr, end, &state);
  1486.                                 if (state == 0x1B6 && ptr < end) {
  1487.                                     key = !(*ptr & 0xC0);
  1488.                                     break;
  1489.                                 }
  1490.                             }
  1491.                         }
  1492.                         if (!key)
  1493.                             e->flags &= ~AVINDEX_KEYFRAME;
  1494.                     }
  1495.                     if (e->flags & AVINDEX_KEYFRAME)
  1496.                         pkt->flags |= AV_PKT_FLAG_KEY;
  1497.                 }
  1498.             } else {
  1499.                 pkt->flags |= AV_PKT_FLAG_KEY;
  1500.             }
  1501.             ast->frame_offset += get_duration(ast, pkt->size);
  1502.         }
  1503.         ast->remaining -= err;
  1504.         if (!ast->remaining) {
  1505.             avi->stream_index = -1;
  1506.             ast->packet_size  = 0;
  1507.         }
  1508.  
  1509.         if (!avi->non_interleaved && pkt->pos >= 0 && ast->seek_pos > pkt->pos) {
  1510.             av_free_packet(pkt);
  1511.             goto resync;
  1512.         }
  1513.         ast->seek_pos= 0;
  1514.  
  1515.         if (!avi->non_interleaved && st->nb_index_entries>1 && avi->index_loaded>1) {
  1516.             int64_t dts= av_rescale_q(pkt->dts, st->time_base, AV_TIME_BASE_Q);
  1517.  
  1518.             if (avi->dts_max - dts > 2*AV_TIME_BASE) {
  1519.                 avi->non_interleaved= 1;
  1520.                 av_log(s, AV_LOG_INFO, "Switching to NI mode, due to poor interleaving\n");
  1521.             }else if (avi->dts_max < dts)
  1522.                 avi->dts_max = dts;
  1523.         }
  1524.  
  1525.         return 0;
  1526.     }
  1527.  
  1528.     if ((err = avi_sync(s, 0)) < 0)
  1529.         return err;
  1530.     goto resync;
  1531. }
  1532.  
  1533. /* XXX: We make the implicit supposition that the positions are sorted
  1534.  * for each stream. */
  1535. static int avi_read_idx1(AVFormatContext *s, int size)
  1536. {
  1537.     AVIContext *avi = s->priv_data;
  1538.     AVIOContext *pb = s->pb;
  1539.     int nb_index_entries, i;
  1540.     AVStream *st;
  1541.     AVIStream *ast;
  1542.     unsigned int index, tag, flags, pos, len, first_packet = 1;
  1543.     unsigned last_pos = -1;
  1544.     unsigned last_idx = -1;
  1545.     int64_t idx1_pos, first_packet_pos = 0, data_offset = 0;
  1546.     int anykey = 0;
  1547.  
  1548.     nb_index_entries = size / 16;
  1549.     if (nb_index_entries <= 0)
  1550.         return AVERROR_INVALIDDATA;
  1551.  
  1552.     idx1_pos = avio_tell(pb);
  1553.     avio_seek(pb, avi->movi_list + 4, SEEK_SET);
  1554.     if (avi_sync(s, 1) == 0)
  1555.         first_packet_pos = avio_tell(pb) - 8;
  1556.     avi->stream_index = -1;
  1557.     avio_seek(pb, idx1_pos, SEEK_SET);
  1558.  
  1559.     if (s->nb_streams == 1 && s->streams[0]->codec->codec_tag == AV_RL32("MMES")) {
  1560.         first_packet_pos = 0;
  1561.         data_offset = avi->movi_list;
  1562.     }
  1563.  
  1564.     /* Read the entries and sort them in each stream component. */
  1565.     for (i = 0; i < nb_index_entries; i++) {
  1566.         if (avio_feof(pb))
  1567.             return -1;
  1568.  
  1569.         tag   = avio_rl32(pb);
  1570.         flags = avio_rl32(pb);
  1571.         pos   = avio_rl32(pb);
  1572.         len   = avio_rl32(pb);
  1573.         av_log(s, AV_LOG_TRACE, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/",
  1574.                 i, tag, flags, pos, len);
  1575.  
  1576.         index  = ((tag      & 0xff) - '0') * 10;
  1577.         index +=  (tag >> 8 & 0xff) - '0';
  1578.         if (index >= s->nb_streams)
  1579.             continue;
  1580.         st  = s->streams[index];
  1581.         ast = st->priv_data;
  1582.  
  1583.         if (first_packet && first_packet_pos) {
  1584.             if (avi->movi_list + 4 != pos || pos + 500 > first_packet_pos)
  1585.                 data_offset  = first_packet_pos - pos;
  1586.             first_packet = 0;
  1587.         }
  1588.         pos += data_offset;
  1589.  
  1590.         av_log(s, AV_LOG_TRACE, "%d cum_len=%"PRId64"\n", len, ast->cum_len);
  1591.  
  1592.         // even if we have only a single stream, we should
  1593.         // switch to non-interleaved to get correct timestamps
  1594.         if (last_pos == pos)
  1595.             avi->non_interleaved = 1;
  1596.         if (last_idx != pos && len) {
  1597.             av_add_index_entry(st, pos, ast->cum_len, len, 0,
  1598.                                (flags & AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);
  1599.             last_idx= pos;
  1600.         }
  1601.         ast->cum_len += get_duration(ast, len);
  1602.         last_pos      = pos;
  1603.         anykey       |= flags&AVIIF_INDEX;
  1604.     }
  1605.     if (!anykey) {
  1606.         for (index = 0; index < s->nb_streams; index++) {
  1607.             st = s->streams[index];
  1608.             if (st->nb_index_entries)
  1609.                 st->index_entries[0].flags |= AVINDEX_KEYFRAME;
  1610.         }
  1611.     }
  1612.     return 0;
  1613. }
  1614.  
  1615. /* Scan the index and consider any file with streams more than
  1616.  * 2 seconds or 64MB apart non-interleaved. */
  1617. static int check_stream_max_drift(AVFormatContext *s)
  1618. {
  1619.     int64_t min_pos, pos;
  1620.     int i;
  1621.     int *idx = av_mallocz_array(s->nb_streams, sizeof(*idx));
  1622.     if (!idx)
  1623.         return AVERROR(ENOMEM);
  1624.     for (min_pos = pos = 0; min_pos != INT64_MAX; pos = min_pos + 1LU) {
  1625.         int64_t max_dts = INT64_MIN / 2;
  1626.         int64_t min_dts = INT64_MAX / 2;
  1627.         int64_t max_buffer = 0;
  1628.  
  1629.         min_pos = INT64_MAX;
  1630.  
  1631.         for (i = 0; i < s->nb_streams; i++) {
  1632.             AVStream *st = s->streams[i];
  1633.             AVIStream *ast = st->priv_data;
  1634.             int n = st->nb_index_entries;
  1635.             while (idx[i] < n && st->index_entries[idx[i]].pos < pos)
  1636.                 idx[i]++;
  1637.             if (idx[i] < n) {
  1638.                 int64_t dts;
  1639.                 dts = av_rescale_q(st->index_entries[idx[i]].timestamp /
  1640.                                    FFMAX(ast->sample_size, 1),
  1641.                                    st->time_base, AV_TIME_BASE_Q);
  1642.                 min_dts = FFMIN(min_dts, dts);
  1643.                 min_pos = FFMIN(min_pos, st->index_entries[idx[i]].pos);
  1644.             }
  1645.         }
  1646.         for (i = 0; i < s->nb_streams; i++) {
  1647.             AVStream *st = s->streams[i];
  1648.             AVIStream *ast = st->priv_data;
  1649.  
  1650.             if (idx[i] && min_dts != INT64_MAX / 2) {
  1651.                 int64_t dts;
  1652.                 dts = av_rescale_q(st->index_entries[idx[i] - 1].timestamp /
  1653.                                    FFMAX(ast->sample_size, 1),
  1654.                                    st->time_base, AV_TIME_BASE_Q);
  1655.                 max_dts = FFMAX(max_dts, dts);
  1656.                 max_buffer = FFMAX(max_buffer,
  1657.                                    av_rescale(dts - min_dts,
  1658.                                               st->codec->bit_rate,
  1659.                                               AV_TIME_BASE));
  1660.             }
  1661.         }
  1662.         if (max_dts - min_dts > 2 * AV_TIME_BASE ||
  1663.             max_buffer > 1024 * 1024 * 8 * 8) {
  1664.             av_free(idx);
  1665.             return 1;
  1666.         }
  1667.     }
  1668.     av_free(idx);
  1669.     return 0;
  1670. }
  1671.  
  1672. static int guess_ni_flag(AVFormatContext *s)
  1673. {
  1674.     int i;
  1675.     int64_t last_start = 0;
  1676.     int64_t first_end  = INT64_MAX;
  1677.     int64_t oldpos     = avio_tell(s->pb);
  1678.  
  1679.     for (i = 0; i < s->nb_streams; i++) {
  1680.         AVStream *st = s->streams[i];
  1681.         int n        = st->nb_index_entries;
  1682.         unsigned int size;
  1683.  
  1684.         if (n <= 0)
  1685.             continue;
  1686.  
  1687.         if (n >= 2) {
  1688.             int64_t pos = st->index_entries[0].pos;
  1689.             unsigned tag[2];
  1690.             avio_seek(s->pb, pos, SEEK_SET);
  1691.             tag[0] = avio_r8(s->pb);
  1692.             tag[1] = avio_r8(s->pb);
  1693.             avio_rl16(s->pb);
  1694.             size = avio_rl32(s->pb);
  1695.             if (get_stream_idx(tag) == i && pos + size > st->index_entries[1].pos)
  1696.                 last_start = INT64_MAX;
  1697.         }
  1698.  
  1699.         if (st->index_entries[0].pos > last_start)
  1700.             last_start = st->index_entries[0].pos;
  1701.         if (st->index_entries[n - 1].pos < first_end)
  1702.             first_end = st->index_entries[n - 1].pos;
  1703.     }
  1704.     avio_seek(s->pb, oldpos, SEEK_SET);
  1705.  
  1706.     if (last_start > first_end)
  1707.         return 1;
  1708.  
  1709.     return check_stream_max_drift(s);
  1710. }
  1711.  
  1712. static int avi_load_index(AVFormatContext *s)
  1713. {
  1714.     AVIContext *avi = s->priv_data;
  1715.     AVIOContext *pb = s->pb;
  1716.     uint32_t tag, size;
  1717.     int64_t pos = avio_tell(pb);
  1718.     int64_t next;
  1719.     int ret     = -1;
  1720.  
  1721.     if (avio_seek(pb, avi->movi_end, SEEK_SET) < 0)
  1722.         goto the_end; // maybe truncated file
  1723.     av_log(s, AV_LOG_TRACE, "movi_end=0x%"PRIx64"\n", avi->movi_end);
  1724.     for (;;) {
  1725.         tag  = avio_rl32(pb);
  1726.         size = avio_rl32(pb);
  1727.         if (avio_feof(pb))
  1728.             break;
  1729.         next = avio_tell(pb) + size + (size & 1);
  1730.  
  1731.         av_log(s, AV_LOG_TRACE, "tag=%c%c%c%c size=0x%x\n",
  1732.                  tag        & 0xff,
  1733.                 (tag >>  8) & 0xff,
  1734.                 (tag >> 16) & 0xff,
  1735.                 (tag >> 24) & 0xff,
  1736.                 size);
  1737.  
  1738.         if (tag == MKTAG('i', 'd', 'x', '1') &&
  1739.             avi_read_idx1(s, size) >= 0) {
  1740.             avi->index_loaded=2;
  1741.             ret = 0;
  1742.         }else if (tag == MKTAG('L', 'I', 'S', 'T')) {
  1743.             uint32_t tag1 = avio_rl32(pb);
  1744.  
  1745.             if (tag1 == MKTAG('I', 'N', 'F', 'O'))
  1746.                 ff_read_riff_info(s, size - 4);
  1747.         }else if (!ret)
  1748.             break;
  1749.  
  1750.         if (avio_seek(pb, next, SEEK_SET) < 0)
  1751.             break; // something is wrong here
  1752.     }
  1753.  
  1754. the_end:
  1755.     avio_seek(pb, pos, SEEK_SET);
  1756.     return ret;
  1757. }
  1758.  
  1759. static void seek_subtitle(AVStream *st, AVStream *st2, int64_t timestamp)
  1760. {
  1761.     AVIStream *ast2 = st2->priv_data;
  1762.     int64_t ts2     = av_rescale_q(timestamp, st->time_base, st2->time_base);
  1763.     av_free_packet(&ast2->sub_pkt);
  1764.     if (avformat_seek_file(ast2->sub_ctx, 0, INT64_MIN, ts2, ts2, 0) >= 0 ||
  1765.         avformat_seek_file(ast2->sub_ctx, 0, ts2, ts2, INT64_MAX, 0) >= 0)
  1766.         ff_read_packet(ast2->sub_ctx, &ast2->sub_pkt);
  1767. }
  1768.  
  1769. static int avi_read_seek(AVFormatContext *s, int stream_index,
  1770.                          int64_t timestamp, int flags)
  1771. {
  1772.     AVIContext *avi = s->priv_data;
  1773.     AVStream *st;
  1774.     int i, index;
  1775.     int64_t pos, pos_min;
  1776.     AVIStream *ast;
  1777.  
  1778.     /* Does not matter which stream is requested dv in avi has the
  1779.      * stream information in the first video stream.
  1780.      */
  1781.     if (avi->dv_demux)
  1782.         stream_index = 0;
  1783.  
  1784.     if (!avi->index_loaded) {
  1785.         /* we only load the index on demand */
  1786.         avi_load_index(s);
  1787.         avi->index_loaded |= 1;
  1788.     }
  1789.     av_assert0(stream_index >= 0);
  1790.  
  1791.     st    = s->streams[stream_index];
  1792.     ast   = st->priv_data;
  1793.     index = av_index_search_timestamp(st,
  1794.                                       timestamp * FFMAX(ast->sample_size, 1),
  1795.                                       flags);
  1796.     if (index < 0) {
  1797.         if (st->nb_index_entries > 0)
  1798.             av_log(s, AV_LOG_DEBUG, "Failed to find timestamp %"PRId64 " in index %"PRId64 " .. %"PRId64 "\n",
  1799.                    timestamp * FFMAX(ast->sample_size, 1),
  1800.                    st->index_entries[0].timestamp,
  1801.                    st->index_entries[st->nb_index_entries - 1].timestamp);
  1802.         return AVERROR_INVALIDDATA;
  1803.     }
  1804.  
  1805.     /* find the position */
  1806.     pos       = st->index_entries[index].pos;
  1807.     timestamp = st->index_entries[index].timestamp / FFMAX(ast->sample_size, 1);
  1808.  
  1809.     av_log(s, AV_LOG_TRACE, "XX %"PRId64" %d %"PRId64"\n",
  1810.             timestamp, index, st->index_entries[index].timestamp);
  1811.  
  1812.     if (CONFIG_DV_DEMUXER && avi->dv_demux) {
  1813.         /* One and only one real stream for DV in AVI, and it has video  */
  1814.         /* offsets. Calling with other stream indexes should have failed */
  1815.         /* the av_index_search_timestamp call above.                     */
  1816.  
  1817.         if (avio_seek(s->pb, pos, SEEK_SET) < 0)
  1818.             return -1;
  1819.  
  1820.         /* Feed the DV video stream version of the timestamp to the */
  1821.         /* DV demux so it can synthesize correct timestamps.        */
  1822.         ff_dv_offset_reset(avi->dv_demux, timestamp);
  1823.  
  1824.         avi->stream_index = -1;
  1825.         return 0;
  1826.     }
  1827.  
  1828.     pos_min = pos;
  1829.     for (i = 0; i < s->nb_streams; i++) {
  1830.         AVStream *st2   = s->streams[i];
  1831.         AVIStream *ast2 = st2->priv_data;
  1832.  
  1833.         ast2->packet_size =
  1834.         ast2->remaining   = 0;
  1835.  
  1836.         if (ast2->sub_ctx) {
  1837.             seek_subtitle(st, st2, timestamp);
  1838.             continue;
  1839.         }
  1840.  
  1841.         if (st2->nb_index_entries <= 0)
  1842.             continue;
  1843.  
  1844. //        av_assert1(st2->codec->block_align);
  1845.         av_assert0(fabs(av_q2d(st2->time_base) - ast2->scale / (double)ast2->rate) < av_q2d(st2->time_base) * 0.00000001);
  1846.         index = av_index_search_timestamp(st2,
  1847.                                           av_rescale_q(timestamp,
  1848.                                                        st->time_base,
  1849.                                                        st2->time_base) *
  1850.                                           FFMAX(ast2->sample_size, 1),
  1851.                                           flags |
  1852.                                           AVSEEK_FLAG_BACKWARD |
  1853.                                           (st2->codec->codec_type != AVMEDIA_TYPE_VIDEO ? AVSEEK_FLAG_ANY : 0));
  1854.         if (index < 0)
  1855.             index = 0;
  1856.         ast2->seek_pos = st2->index_entries[index].pos;
  1857.         pos_min = FFMIN(pos_min,ast2->seek_pos);
  1858.     }
  1859.     for (i = 0; i < s->nb_streams; i++) {
  1860.         AVStream *st2 = s->streams[i];
  1861.         AVIStream *ast2 = st2->priv_data;
  1862.  
  1863.         if (ast2->sub_ctx || st2->nb_index_entries <= 0)
  1864.             continue;
  1865.  
  1866.         index = av_index_search_timestamp(
  1867.                 st2,
  1868.                 av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1),
  1869.                 flags | AVSEEK_FLAG_BACKWARD | (st2->codec->codec_type != AVMEDIA_TYPE_VIDEO ? AVSEEK_FLAG_ANY : 0));
  1870.         if (index < 0)
  1871.             index = 0;
  1872.         while (!avi->non_interleaved && index>0 && st2->index_entries[index-1].pos >= pos_min)
  1873.             index--;
  1874.         ast2->frame_offset = st2->index_entries[index].timestamp;
  1875.     }
  1876.  
  1877.     /* do the seek */
  1878.     if (avio_seek(s->pb, pos_min, SEEK_SET) < 0) {
  1879.         av_log(s, AV_LOG_ERROR, "Seek failed\n");
  1880.         return -1;
  1881.     }
  1882.     avi->stream_index = -1;
  1883.     avi->dts_max      = INT_MIN;
  1884.     return 0;
  1885. }
  1886.  
  1887. static int avi_read_close(AVFormatContext *s)
  1888. {
  1889.     int i;
  1890.     AVIContext *avi = s->priv_data;
  1891.  
  1892.     for (i = 0; i < s->nb_streams; i++) {
  1893.         AVStream *st   = s->streams[i];
  1894.         AVIStream *ast = st->priv_data;
  1895.         if (ast) {
  1896.             if (ast->sub_ctx) {
  1897.                 av_freep(&ast->sub_ctx->pb);
  1898.                 avformat_close_input(&ast->sub_ctx);
  1899.             }
  1900.             av_freep(&ast->sub_buffer);
  1901.             av_free_packet(&ast->sub_pkt);
  1902.         }
  1903.     }
  1904.  
  1905.     av_freep(&avi->dv_demux);
  1906.  
  1907.     return 0;
  1908. }
  1909.  
  1910. static int avi_probe(AVProbeData *p)
  1911. {
  1912.     int i;
  1913.  
  1914.     /* check file header */
  1915.     for (i = 0; avi_headers[i][0]; i++)
  1916.         if (AV_RL32(p->buf    ) == AV_RL32(avi_headers[i]    ) &&
  1917.             AV_RL32(p->buf + 8) == AV_RL32(avi_headers[i] + 4))
  1918.             return AVPROBE_SCORE_MAX;
  1919.  
  1920.     return 0;
  1921. }
  1922.  
  1923. AVInputFormat ff_avi_demuxer = {
  1924.     .name           = "avi",
  1925.     .long_name      = NULL_IF_CONFIG_SMALL("AVI (Audio Video Interleaved)"),
  1926.     .priv_data_size = sizeof(AVIContext),
  1927.     .extensions     = "avi",
  1928.     .read_probe     = avi_probe,
  1929.     .read_header    = avi_read_header,
  1930.     .read_packet    = avi_read_packet,
  1931.     .read_close     = avi_read_close,
  1932.     .read_seek      = avi_read_seek,
  1933.     .priv_class = &demuxer_class,
  1934. };
  1935.