falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
18207 Commits
32 Branches
301MB
Tree: a90de11dba
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a90de11dba'
${ noResults }
FFmpeg/libavformat/avidec.c

1120 lines
37KB
Raw Blame History 

  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 "libavutil/intreadwrite.h"

  23. #include "libavutil/bswap.h"

  24. #include "avformat.h"

  25. #include "avi.h"

  26. #include "dv.h"

  27. #include "riff.h"

  28. 

  29. #undef NDEBUG

  30. #include <assert.h>

  31. 

  32. //#define DEBUG

  33. //#define DEBUG_SEEK

  34. 

  35. typedef struct AVIStream {

  36.     int64_t frame_offset; /* current frame (video) or byte (audio) counter

  37.                          (used to compute the pts) */

  38.     int remaining;

  39.     int packet_size;

  40. 

  41.     int scale;

  42.     int rate;

  43.     int sample_size; /* size of one sample (or packet) (in the rate/scale sense) in bytes */

  44. 

  45.     int64_t cum_len; /* temporary storage (used during seek) */

  46. 

  47.     int prefix;                       ///< normally 'd'<<8 + 'c' or 'w'<<8 + 'b'

  48.     int prefix_count;

  49.     uint32_t pal[256];

  50.     int has_pal;

  51. } AVIStream;

  52. 

  53. typedef struct {

  54.     int64_t  riff_end;

  55.     int64_t  movi_end;

  56.     int64_t  fsize;

  57.     int64_t movi_list;

  58.     int64_t last_pkt_pos;

  59.     int index_loaded;

  60.     int is_odml;

  61.     int non_interleaved;

  62.     int stream_index;

  63.     DVDemuxContext* dv_demux;

  64. } AVIContext;

  65. 

  66. static const char avi_headers[][8] = {

  67.     { 'R', 'I', 'F', 'F',    'A', 'V', 'I', ' ' },

  68.     { 'R', 'I', 'F', 'F',    'A', 'V', 'I', 'X' },

  69.     { 'R', 'I', 'F', 'F',    'A', 'V', 'I', 0x19},

  70.     { 'O', 'N', '2', ' ',    'O', 'N', '2', 'f' },

  71.     { 'R', 'I', 'F', 'F',    'A', 'M', 'V', ' ' },

  72.     { 0 }

  73. };

  74. 

  75. static int avi_load_index(AVFormatContext *s);

  76. static int guess_ni_flag(AVFormatContext *s);

  77. 

  78. #ifdef DEBUG

  79. static void print_tag(const char *str, unsigned int tag, int size)

  80. {

  81.     printf("%s: tag=%c%c%c%c size=0x%x\n",

  82.            str, tag & 0xff,

  83.            (tag >> 8) & 0xff,

  84.            (tag >> 16) & 0xff,

  85.            (tag >> 24) & 0xff,

  86.            size);

  87. }

  88. #endif

  89. 

  90. static int get_riff(AVFormatContext *s, ByteIOContext *pb)

  91. {

  92.     AVIContext *avi = s->priv_data;

  93.     char header[8];

  94.     int i;

  95. 

  96.     /* check RIFF header */

  97.     get_buffer(pb, header, 4);

  98.     avi->riff_end = get_le32(pb);   /* RIFF chunk size */

  99.     avi->riff_end += url_ftell(pb); /* RIFF chunk end */

  100.     get_buffer(pb, header+4, 4);

  101. 

  102.     for(i=0; avi_headers[i][0]; i++)

  103.         if(!memcmp(header, avi_headers[i], 8))

  104.             break;

  105.     if(!avi_headers[i][0])

  106.         return -1;

  107. 

  108.     if(header[7] == 0x19)

  109.         av_log(s, AV_LOG_INFO, "This file has been generated by a totally broken muxer.\n");

  110. 

  111.     return 0;

  112. }

  113. 

  114. static int read_braindead_odml_indx(AVFormatContext *s, int frame_num){

  115.     AVIContext *avi = s->priv_data;

  116.     ByteIOContext *pb = s->pb;

  117.     int longs_pre_entry= get_le16(pb);

  118.     int index_sub_type = get_byte(pb);

  119.     int index_type     = get_byte(pb);

  120.     int entries_in_use = get_le32(pb);

  121.     int chunk_id       = get_le32(pb);

  122.     int64_t base       = get_le64(pb);

  123.     int stream_id= 10*((chunk_id&0xFF) - '0') + (((chunk_id>>8)&0xFF) - '0');

  124.     AVStream *st;

  125.     AVIStream *ast;

  126.     int i;

  127.     int64_t last_pos= -1;

  128.     int64_t filesize= url_fsize(s->pb);

  129. 

  130. #ifdef DEBUG_SEEK

  131.     av_log(s, AV_LOG_ERROR, "longs_pre_entry:%d index_type:%d entries_in_use:%d chunk_id:%X base:%16"PRIX64"\n",

  132.         longs_pre_entry,index_type, entries_in_use, chunk_id, base);

  133. #endif

  134. 

  135.     if(stream_id > s->nb_streams || stream_id < 0)

  136.         return -1;

  137.     st= s->streams[stream_id];

  138.     ast = st->priv_data;

  139. 

  140.     if(index_sub_type)

  141.         return -1;

  142. 

  143.     get_le32(pb);

  144. 

  145.     if(index_type && longs_pre_entry != 2)

  146.         return -1;

  147.     if(index_type>1)

  148.         return -1;

  149. 

  150.     if(filesize > 0 && base >= filesize){

  151.         av_log(s, AV_LOG_ERROR, "ODML index invalid\n");

  152.         if(base>>32 == (base & 0xFFFFFFFF) && (base & 0xFFFFFFFF) < filesize && filesize <= 0xFFFFFFFF)

  153.             base &= 0xFFFFFFFF;

  154.         else

  155.             return -1;

  156.     }

  157. 

  158.     for(i=0; i<entries_in_use; i++){

  159.         if(index_type){

  160.             int64_t pos= get_le32(pb) + base - 8;

  161.             int len    = get_le32(pb);

  162.             int key= len >= 0;

  163.             len &= 0x7FFFFFFF;

  164. 

  165. #ifdef DEBUG_SEEK

  166.             av_log(s, AV_LOG_ERROR, "pos:%"PRId64", len:%X\n", pos, len);

  167. #endif

  168.             if(last_pos == pos || pos == base - 8)

  169.                 avi->non_interleaved= 1;

  170.             if(last_pos != pos)

  171.                 av_add_index_entry(st, pos, ast->cum_len / FFMAX(1, ast->sample_size), len, 0, key ? AVINDEX_KEYFRAME : 0);

  172. 

  173.             if(ast->sample_size)

  174.                 ast->cum_len += len;

  175.             else

  176.                 ast->cum_len ++;

  177.             last_pos= pos;

  178.         }else{

  179.             int64_t offset, pos;

  180.             int duration;

  181.             offset = get_le64(pb);

  182.             get_le32(pb);       /* size */

  183.             duration = get_le32(pb);

  184.             pos = url_ftell(pb);

  185. 

  186.             url_fseek(pb, offset+8, SEEK_SET);

  187.             read_braindead_odml_indx(s, frame_num);

  188.             frame_num += duration;

  189. 

  190.             url_fseek(pb, pos, SEEK_SET);

  191.         }

  192.     }

  193.     avi->index_loaded=1;

  194.     return 0;

  195. }

  196. 

  197. static void clean_index(AVFormatContext *s){

  198.     int i;

  199.     int64_t j;

  200. 

  201.     for(i=0; i<s->nb_streams; i++){

  202.         AVStream *st = s->streams[i];

  203.         AVIStream *ast = st->priv_data;

  204.         int n= st->nb_index_entries;

  205.         int max= ast->sample_size;

  206.         int64_t pos, size, ts;

  207. 

  208.         if(n != 1 || ast->sample_size==0)

  209.             continue;

  210. 

  211.         while(max < 1024) max+=max;

  212. 

  213.         pos= st->index_entries[0].pos;

  214.         size= st->index_entries[0].size;

  215.         ts= st->index_entries[0].timestamp;

  216. 

  217.         for(j=0; j<size; j+=max){

  218.             av_add_index_entry(st, pos+j, ts + j/ast->sample_size, FFMIN(max, size-j), 0, AVINDEX_KEYFRAME);

  219.         }

  220.     }

  221. }

  222. 

  223. static int avi_read_tag(AVFormatContext *s, const char *key, unsigned int size)

  224. {

  225.     ByteIOContext *pb = s->pb;

  226.     uint8_t value[1024];

  227. 

  228.     int64_t i = url_ftell(pb);

  229.     size += (size & 1);

  230.     get_strz(pb, value, sizeof(value));

  231.     url_fseek(pb, i+size, SEEK_SET);

  232. 

  233.     return av_metadata_set(&s->metadata, key, value);

  234. }

  235. 

  236. static int avi_read_header(AVFormatContext *s, AVFormatParameters *ap)

  237. {

  238.     AVIContext *avi = s->priv_data;

  239.     ByteIOContext *pb = s->pb;

  240.     unsigned int tag, tag1, handler;

  241.     int codec_type, stream_index, frame_period, bit_rate;

  242.     unsigned int size, nb_frames;

  243.     int i;

  244.     AVStream *st;

  245.     AVIStream *ast = NULL;

  246.     int avih_width=0, avih_height=0;

  247.     int amv_file_format=0;

  248. 

  249.     avi->stream_index= -1;

  250. 

  251.     if (get_riff(s, pb) < 0)

  252.         return -1;

  253. 

  254.     avi->fsize = url_fsize(pb);

  255.     if(avi->fsize<=0)

  256.         avi->fsize= avi->riff_end;

  257. 

  258.     /* first list tag */

  259.     stream_index = -1;

  260.     codec_type = -1;

  261.     frame_period = 0;

  262.     for(;;) {

  263.         if (url_feof(pb))

  264.             goto fail;

  265.         tag = get_le32(pb);

  266.         size = get_le32(pb);

  267. #ifdef DEBUG

  268.         print_tag("tag", tag, size);

  269. #endif

  270. 

  271.         switch(tag) {

  272.         case MKTAG('L', 'I', 'S', 'T'):

  273.             /* Ignored, except at start of video packets. */

  274.             tag1 = get_le32(pb);

  275. #ifdef DEBUG

  276.             print_tag("list", tag1, 0);

  277. #endif

  278.             if (tag1 == MKTAG('m', 'o', 'v', 'i')) {

  279.                 avi->movi_list = url_ftell(pb) - 4;

  280.                 if(size) avi->movi_end = avi->movi_list + size + (size & 1);

  281.                 else     avi->movi_end = url_fsize(pb);

  282. #ifdef DEBUG

  283.                 printf("movi end=%"PRIx64"\n", avi->movi_end);

  284. #endif

  285.                 goto end_of_header;

  286.             }

  287.             break;

  288.         case MKTAG('d', 'm', 'l', 'h'):

  289.             avi->is_odml = 1;

  290.             url_fskip(pb, size + (size & 1));

  291.             break;

  292.         case MKTAG('a', 'm', 'v', 'h'):

  293.             amv_file_format=1;

  294.         case MKTAG('a', 'v', 'i', 'h'):

  295.             /* AVI header */

  296.             /* using frame_period is bad idea */

  297.             frame_period = get_le32(pb);

  298.             bit_rate = get_le32(pb) * 8;

  299.             get_le32(pb);

  300.             avi->non_interleaved |= get_le32(pb) & AVIF_MUSTUSEINDEX;

  301. 

  302.             url_fskip(pb, 2 * 4);

  303.             get_le32(pb);

  304.             get_le32(pb);

  305.             avih_width=get_le32(pb);

  306.             avih_height=get_le32(pb);

  307. 

  308.             url_fskip(pb, size - 10 * 4);

  309.             break;

  310.         case MKTAG('s', 't', 'r', 'h'):

  311.             /* stream header */

  312. 

  313.             tag1 = get_le32(pb);

  314.             handler = get_le32(pb); /* codec tag */

  315. 

  316.             if(tag1 == MKTAG('p', 'a', 'd', 's')){

  317.                 url_fskip(pb, size - 8);

  318.                 break;

  319.             }else{

  320.                 stream_index++;

  321.                 st = av_new_stream(s, stream_index);

  322.                 if (!st)

  323.                     goto fail;

  324. 

  325.                 ast = av_mallocz(sizeof(AVIStream));

  326.                 if (!ast)

  327.                     goto fail;

  328.                 st->priv_data = ast;

  329.             }

  330.             if(amv_file_format)

  331.                 tag1 = stream_index ? MKTAG('a','u','d','s') : MKTAG('v','i','d','s');

  332. 

  333. #ifdef DEBUG

  334.             print_tag("strh", tag1, -1);

  335. #endif

  336.             if(tag1 == MKTAG('i', 'a', 'v', 's') || tag1 == MKTAG('i', 'v', 'a', 's')){

  337.                 int64_t dv_dur;

  338. 

  339.                 /*

  340.                  * After some consideration -- I don't think we

  341.                  * have to support anything but DV in type1 AVIs.

  342.                  */

  343.                 if (s->nb_streams != 1)

  344.                     goto fail;

  345. 

  346.                 if (handler != MKTAG('d', 'v', 's', 'd') &&

  347.                     handler != MKTAG('d', 'v', 'h', 'd') &&

  348.                     handler != MKTAG('d', 'v', 's', 'l'))

  349.                    goto fail;

  350. 

  351.                 ast = s->streams[0]->priv_data;

  352.                 av_freep(&s->streams[0]->codec->extradata);

  353.                 av_freep(&s->streams[0]);

  354.                 s->nb_streams = 0;

  355.                 if (CONFIG_DV_DEMUXER) {

  356.                     avi->dv_demux = dv_init_demux(s);

  357.                     if (!avi->dv_demux)

  358.                         goto fail;

  359.                 }

  360.                 s->streams[0]->priv_data = ast;

  361.                 url_fskip(pb, 3 * 4);

  362.                 ast->scale = get_le32(pb);

  363.                 ast->rate = get_le32(pb);

  364.                 url_fskip(pb, 4);  /* start time */

  365. 

  366.                 dv_dur = get_le32(pb);

  367.                 if (ast->scale > 0 && ast->rate > 0 && dv_dur > 0) {

  368.                     dv_dur *= AV_TIME_BASE;

  369.                     s->duration = av_rescale(dv_dur, ast->scale, ast->rate);

  370.                 }

  371.                 /*

  372.                  * else, leave duration alone; timing estimation in utils.c

  373.                  *      will make a guess based on bitrate.

  374.                  */

  375. 

  376.                 stream_index = s->nb_streams - 1;

  377.                 url_fskip(pb, size - 9*4);

  378.                 break;

  379.             }

  380. 

  381.             assert(stream_index < s->nb_streams);

  382.             st->codec->stream_codec_tag= handler;

  383. 

  384.             get_le32(pb); /* flags */

  385.             get_le16(pb); /* priority */

  386.             get_le16(pb); /* language */

  387.             get_le32(pb); /* initial frame */

  388.             ast->scale = get_le32(pb);

  389.             ast->rate = get_le32(pb);

  390.             if(!(ast->scale && ast->rate)){

  391.                 av_log(s, AV_LOG_WARNING, "scale/rate is %u/%u which is invalid. (This file has been generated by broken software.)\n", ast->scale, ast->rate);

  392.                 if(frame_period){

  393.                     ast->rate = 1000000;

  394.                     ast->scale = frame_period;

  395.                 }else{

  396.                     ast->rate = 25;

  397.                     ast->scale = 1;

  398.                 }

  399.             }

  400.             av_set_pts_info(st, 64, ast->scale, ast->rate);

  401. 

  402.             ast->cum_len=get_le32(pb); /* start */

  403.             nb_frames = get_le32(pb);

  404. 

  405.             st->start_time = 0;

  406.             st->duration = nb_frames;

  407.             get_le32(pb); /* buffer size */

  408.             get_le32(pb); /* quality */

  409.             ast->sample_size = get_le32(pb); /* sample ssize */

  410.             ast->cum_len *= FFMAX(1, ast->sample_size);

  411. //            av_log(s, AV_LOG_DEBUG, "%d %d %d %d\n", ast->rate, ast->scale, ast->start, ast->sample_size);

  412. 

  413.             switch(tag1) {

  414.             case MKTAG('v', 'i', 'd', 's'):

  415.                 codec_type = CODEC_TYPE_VIDEO;

  416. 

  417.                 ast->sample_size = 0;

  418.                 break;

  419.             case MKTAG('a', 'u', 'd', 's'):

  420.                 codec_type = CODEC_TYPE_AUDIO;

  421.                 break;

  422.             case MKTAG('t', 'x', 't', 's'):

  423.                 //FIXME

  424.                 codec_type = CODEC_TYPE_DATA; //CODEC_TYPE_SUB ?  FIXME

  425.                 break;

  426.             case MKTAG('d', 'a', 't', 's'):

  427.                 codec_type = CODEC_TYPE_DATA;

  428.                 break;

  429.             default:

  430.                 av_log(s, AV_LOG_ERROR, "unknown stream type %X\n", tag1);

  431.                 goto fail;

  432.             }

  433.             ast->frame_offset= ast->cum_len;

  434.             url_fskip(pb, size - 12 * 4);

  435.             break;

  436.         case MKTAG('s', 't', 'r', 'f'):

  437.             /* stream header */

  438.             if (stream_index >= (unsigned)s->nb_streams || avi->dv_demux) {

  439.                 url_fskip(pb, size);

  440.             } else {

  441.                 st = s->streams[stream_index];

  442.                 switch(codec_type) {

  443.                 case CODEC_TYPE_VIDEO:

  444.                     if(amv_file_format){

  445.                         st->codec->width=avih_width;

  446.                         st->codec->height=avih_height;

  447.                         st->codec->codec_type = CODEC_TYPE_VIDEO;

  448.                         st->codec->codec_id = CODEC_ID_AMV;

  449.                         url_fskip(pb, size);

  450.                         break;

  451.                     }

  452.                     get_le32(pb); /* size */

  453.                     st->codec->width = get_le32(pb);

  454.                     st->codec->height = (int32_t)get_le32(pb);

  455.                     get_le16(pb); /* panes */

  456.                     st->codec->bits_per_coded_sample= get_le16(pb); /* depth */

  457.                     tag1 = get_le32(pb);

  458.                     get_le32(pb); /* ImageSize */

  459.                     get_le32(pb); /* XPelsPerMeter */

  460.                     get_le32(pb); /* YPelsPerMeter */

  461.                     get_le32(pb); /* ClrUsed */

  462.                     get_le32(pb); /* ClrImportant */

  463. 

  464.                     if (tag1 == MKTAG('D', 'X', 'S', 'B')) {

  465.                         st->codec->codec_type = CODEC_TYPE_SUBTITLE;

  466.                         st->codec->codec_tag = tag1;

  467.                         st->codec->codec_id = CODEC_ID_XSUB;

  468.                         break;

  469.                     }

  470. 

  471.                     if(size > 10*4 && size<(1<<30)){

  472.                         st->codec->extradata_size= size - 10*4;

  473.                         st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);

  474.                         get_buffer(pb, st->codec->extradata, st->codec->extradata_size);

  475.                     }

  476. 

  477.                     if(st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly

  478.                         get_byte(pb);

  479. 

  480.                     /* Extract palette from extradata if bpp <= 8. */

  481.                     /* This code assumes that extradata contains only palette. */

  482.                     /* This is true for all paletted codecs implemented in FFmpeg. */

  483.                     if (st->codec->extradata_size && (st->codec->bits_per_coded_sample <= 8)) {

  484.                         st->codec->palctrl = av_mallocz(sizeof(AVPaletteControl));

  485. #ifdef WORDS_BIGENDIAN

  486.                         for (i = 0; i < FFMIN(st->codec->extradata_size, AVPALETTE_SIZE)/4; i++)

  487.                             st->codec->palctrl->palette[i] = bswap_32(((uint32_t*)st->codec->extradata)[i]);

  488. #else

  489.                         memcpy(st->codec->palctrl->palette, st->codec->extradata,

  490.                                FFMIN(st->codec->extradata_size, AVPALETTE_SIZE));

  491. #endif

  492.                         st->codec->palctrl->palette_changed = 1;

  493.                     }

  494. 

  495. #ifdef DEBUG

  496.                     print_tag("video", tag1, 0);

  497. #endif

  498.                     st->codec->codec_type = CODEC_TYPE_VIDEO;

  499.                     st->codec->codec_tag = tag1;

  500.                     st->codec->codec_id = codec_get_id(codec_bmp_tags, tag1);

  501.                     st->need_parsing = AVSTREAM_PARSE_HEADERS; // This is needed to get the pict type which is necessary for generating correct pts.

  502. 

  503.                     if(st->codec->codec_tag==0 && st->codec->height > 0 && st->codec->extradata_size < 1U<<30){

  504.                         st->codec->extradata_size+= 9;

  505.                         st->codec->extradata= av_realloc(st->codec->extradata, st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);

  506.                         if(st->codec->extradata)

  507.                             memcpy(st->codec->extradata + st->codec->extradata_size - 9, "BottomUp", 9);

  508.                     }

  509.                     st->codec->height= FFABS(st->codec->height);

  510. 

  511. //                    url_fskip(pb, size - 5 * 4);

  512.                     break;

  513.                 case CODEC_TYPE_AUDIO:

  514.                     get_wav_header(pb, st->codec, size);

  515.                     if(ast->sample_size && st->codec->block_align && ast->sample_size != st->codec->block_align){

  516.                         av_log(s, AV_LOG_WARNING, "sample size (%d) != block align (%d)\n", ast->sample_size, st->codec->block_align);

  517.                         ast->sample_size= st->codec->block_align;

  518.                     }

  519.                     if (size%2) /* 2-aligned (fix for Stargate SG-1 - 3x18 - Shades of Grey.avi) */

  520.                         url_fskip(pb, 1);

  521.                     /* Force parsing as several audio frames can be in

  522.                      * one packet and timestamps refer to packet start. */

  523.                     st->need_parsing = AVSTREAM_PARSE_TIMESTAMPS;

  524.                     /* ADTS header is in extradata, AAC without header must be

  525.                      * stored as exact frames. Parser not needed and it will

  526.                      * fail. */

  527.                     if (st->codec->codec_id == CODEC_ID_AAC && st->codec->extradata_size)

  528.                         st->need_parsing = AVSTREAM_PARSE_NONE;

  529.                     /* AVI files with Xan DPCM audio (wrongly) declare PCM

  530.                      * audio in the header but have Axan as stream_code_tag. */

  531.                     if (st->codec->stream_codec_tag == AV_RL32("Axan")){

  532.                         st->codec->codec_id  = CODEC_ID_XAN_DPCM;

  533.                         st->codec->codec_tag = 0;

  534.                     }

  535.                     if (amv_file_format)

  536.                         st->codec->codec_id  = CODEC_ID_ADPCM_IMA_AMV;

  537.                     break;

  538.                 default:

  539.                     st->codec->codec_type = CODEC_TYPE_DATA;

  540.                     st->codec->codec_id= CODEC_ID_NONE;

  541.                     st->codec->codec_tag= 0;

  542.                     url_fskip(pb, size);

  543.                     break;

  544.                 }

  545.             }

  546.             break;

  547.         case MKTAG('i', 'n', 'd', 'x'):

  548.             i= url_ftell(pb);

  549.             if(!url_is_streamed(pb) && !(s->flags & AVFMT_FLAG_IGNIDX)){

  550.                 read_braindead_odml_indx(s, 0);

  551.             }

  552.             url_fseek(pb, i+size, SEEK_SET);

  553.             break;

  554.         case MKTAG('v', 'p', 'r', 'p'):

  555.             if(stream_index < (unsigned)s->nb_streams && size > 9*4){

  556.                 AVRational active, active_aspect;

  557. 

  558.                 st = s->streams[stream_index];

  559.                 get_le32(pb);

  560.                 get_le32(pb);

  561.                 get_le32(pb);

  562.                 get_le32(pb);

  563.                 get_le32(pb);

  564. 

  565.                 active_aspect.den= get_le16(pb);

  566.                 active_aspect.num= get_le16(pb);

  567.                 active.num       = get_le32(pb);

  568.                 active.den       = get_le32(pb);

  569.                 get_le32(pb); //nbFieldsPerFrame

  570. 

  571.                 if(active_aspect.num && active_aspect.den && active.num && active.den){

  572.                     st->sample_aspect_ratio= av_div_q(active_aspect, active);

  573. //av_log(s, AV_LOG_ERROR, "vprp %d/%d %d/%d\n", active_aspect.num, active_aspect.den, active.num, active.den);

  574.                 }

  575.                 size -= 9*4;

  576.             }

  577.             url_fseek(pb, size, SEEK_CUR);

  578.             break;

  579.         case MKTAG('I', 'N', 'A', 'M'):

  580.             avi_read_tag(s, "Title", size);

  581.             break;

  582.         case MKTAG('I', 'A', 'R', 'T'):

  583.             avi_read_tag(s, "Artist", size);

  584.             break;

  585.         case MKTAG('I', 'C', 'O', 'P'):

  586.             avi_read_tag(s, "Copyright", size);

  587.             break;

  588.         case MKTAG('I', 'C', 'M', 'T'):

  589.             avi_read_tag(s, "Comment", size);

  590.             break;

  591.         case MKTAG('I', 'G', 'N', 'R'):

  592.             avi_read_tag(s, "Genre", size);

  593.             break;

  594.         case MKTAG('I', 'P', 'R', 'D'):

  595.             avi_read_tag(s, "Album", size);

  596.             break;

  597.         case MKTAG('I', 'P', 'R', 'T'):

  598.             avi_read_tag(s, "Track", size);

  599.             break;

  600.         default:

  601.             if(size > 1000000){

  602.                 av_log(s, AV_LOG_ERROR, "Something went wrong during header parsing, "

  603.                                         "I will ignore it and try to continue anyway.\n");

  604.                 avi->movi_list = url_ftell(pb) - 4;

  605.                 avi->movi_end  = url_fsize(pb);

  606.                 goto end_of_header;

  607.             }

  608.             /* skip tag */

  609.             size += (size & 1);

  610.             url_fskip(pb, size);

  611.             break;

  612.         }

  613.     }

  614.  end_of_header:

  615.     /* check stream number */

  616.     if (stream_index != s->nb_streams - 1) {

  617.     fail:

  618.         return -1;

  619.     }

  620. 

  621.     if(!avi->index_loaded && !url_is_streamed(pb))

  622.         avi_load_index(s);

  623.     avi->index_loaded = 1;

  624.     avi->non_interleaved |= guess_ni_flag(s);

  625.     if(avi->non_interleaved) {

  626.         av_log(s, AV_LOG_INFO, "non-interleaved AVI\n");

  627.         clean_index(s);

  628.     }

  629. 

  630.     return 0;

  631. }

  632. 

  633. static int get_stream_idx(int *d){

  634.     if(    d[0] >= '0' && d[0] <= '9'

  635.         && d[1] >= '0' && d[1] <= '9'){

  636.         return (d[0] - '0') * 10 + (d[1] - '0');

  637.     }else{

  638.         return 100; //invalid stream ID

  639.     }

  640. }

  641. 

  642. static int avi_read_packet(AVFormatContext *s, AVPacket *pkt)

  643. {

  644.     AVIContext *avi = s->priv_data;

  645.     ByteIOContext *pb = s->pb;

  646.     int n, d[8];

  647.     unsigned int size;

  648.     int64_t i, sync;

  649.     void* dstr;

  650. 

  651.     if (CONFIG_DV_DEMUXER && avi->dv_demux) {

  652.         int size = dv_get_packet(avi->dv_demux, pkt);

  653.         if (size >= 0)

  654.             return size;

  655.     }

  656. 

  657.     if(avi->non_interleaved){

  658.         int best_stream_index = 0;

  659.         AVStream *best_st= NULL;

  660.         AVIStream *best_ast;

  661.         int64_t best_ts= INT64_MAX;

  662.         int i;

  663. 

  664.         for(i=0; i<s->nb_streams; i++){

  665.             AVStream *st = s->streams[i];

  666.             AVIStream *ast = st->priv_data;

  667.             int64_t ts= ast->frame_offset;

  668. 

  669.             if(ast->sample_size)

  670.                 ts /= ast->sample_size;

  671.             ts= av_rescale(ts, AV_TIME_BASE * (int64_t)st->time_base.num, st->time_base.den);

  672. 

  673. //            av_log(s, AV_LOG_DEBUG, "%"PRId64" %d/%d %"PRId64"\n", ts, st->time_base.num, st->time_base.den, ast->frame_offset);

  674.             if(ts < best_ts && st->nb_index_entries){

  675.                 best_ts= ts;

  676.                 best_st= st;

  677.                 best_stream_index= i;

  678.             }

  679.         }

  680.         if(!best_st)

  681.             return -1;

  682. 

  683.         best_ast = best_st->priv_data;

  684.         best_ts= av_rescale(best_ts, best_st->time_base.den, AV_TIME_BASE * (int64_t)best_st->time_base.num); //FIXME a little ugly

  685.         if(best_ast->remaining)

  686.             i= av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD);

  687.         else{

  688.             i= av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY);

  689.             if(i>=0)

  690.                 best_ast->frame_offset= best_st->index_entries[i].timestamp

  691.                                       * FFMAX(1, best_ast->sample_size);

  692.         }

  693. 

  694. //        av_log(s, AV_LOG_DEBUG, "%d\n", i);

  695.         if(i>=0){

  696.             int64_t pos= best_st->index_entries[i].pos;

  697.             pos += best_ast->packet_size - best_ast->remaining;

  698.             url_fseek(s->pb, pos + 8, SEEK_SET);

  699. //        av_log(s, AV_LOG_DEBUG, "pos=%"PRId64"\n", pos);

  700. 

  701.             assert(best_ast->remaining <= best_ast->packet_size);

  702. 

  703.             avi->stream_index= best_stream_index;

  704.             if(!best_ast->remaining)

  705.                 best_ast->packet_size=

  706.                 best_ast->remaining= best_st->index_entries[i].size;

  707.         }

  708.     }

  709. 

  710. resync:

  711.     if(avi->stream_index >= 0){

  712.         AVStream *st= s->streams[ avi->stream_index ];

  713.         AVIStream *ast= st->priv_data;

  714.         int size;

  715. 

  716.         if(ast->sample_size <= 1) // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM

  717.             size= INT_MAX;

  718.         else if(ast->sample_size < 32)

  719.             size= 64*ast->sample_size;

  720.         else

  721.             size= ast->sample_size;

  722. 

  723.         if(size > ast->remaining)

  724.             size= ast->remaining;

  725.         avi->last_pkt_pos= url_ftell(pb);

  726.         av_get_packet(pb, pkt, size);

  727. 

  728.         if(ast->has_pal && pkt->data && pkt->size<(unsigned)INT_MAX/2){

  729.             ast->has_pal=0;

  730.             pkt->size += 4*256;

  731.             pkt->data = av_realloc(pkt->data, pkt->size + FF_INPUT_BUFFER_PADDING_SIZE);

  732.             if(pkt->data)

  733.                 memcpy(pkt->data + pkt->size - 4*256, ast->pal, 4*256);

  734.         }

  735. 

  736.         if (CONFIG_DV_DEMUXER && avi->dv_demux) {

  737.             dstr = pkt->destruct;

  738.             size = dv_produce_packet(avi->dv_demux, pkt,

  739.                                     pkt->data, pkt->size);

  740.             pkt->destruct = dstr;

  741.             pkt->flags |= PKT_FLAG_KEY;

  742.         } else {

  743.             /* XXX: How to handle B-frames in AVI? */

  744.             pkt->dts = ast->frame_offset;

  745. //                pkt->dts += ast->start;

  746.             if(ast->sample_size)

  747.                 pkt->dts /= ast->sample_size;

  748. //av_log(s, AV_LOG_DEBUG, "dts:%"PRId64" offset:%"PRId64" %d/%d smpl_siz:%d base:%d st:%d size:%d\n", pkt->dts, ast->frame_offset, ast->scale, ast->rate, ast->sample_size, AV_TIME_BASE, avi->stream_index, size);

  749.             pkt->stream_index = avi->stream_index;

  750. 

  751.             if (st->codec->codec_type == CODEC_TYPE_VIDEO) {

  752.                 AVIndexEntry *e;

  753.                 int index;

  754.                 assert(st->index_entries);

  755. 

  756.                 index= av_index_search_timestamp(st, pkt->dts, 0);

  757.                 e= &st->index_entries[index];

  758. 

  759.                 if(index >= 0 && e->timestamp == ast->frame_offset){

  760.                     if (e->flags & AVINDEX_KEYFRAME)

  761.                         pkt->flags |= PKT_FLAG_KEY;

  762.                 }

  763.             } else {

  764.                 pkt->flags |= PKT_FLAG_KEY;

  765.             }

  766.             if(ast->sample_size)

  767.                 ast->frame_offset += pkt->size;

  768.             else

  769.                 ast->frame_offset++;

  770.         }

  771.         ast->remaining -= size;

  772.         if(!ast->remaining){

  773.             avi->stream_index= -1;

  774.             ast->packet_size= 0;

  775.         }

  776. 

  777.         return size;

  778.     }

  779. 

  780.     memset(d, -1, sizeof(int)*8);

  781.     for(i=sync=url_ftell(pb); !url_feof(pb); i++) {

  782.         int j;

  783. 

  784.         for(j=0; j<7; j++)

  785.             d[j]= d[j+1];

  786.         d[7]= get_byte(pb);

  787. 

  788.         size= d[4] + (d[5]<<8) + (d[6]<<16) + (d[7]<<24);

  789. 

  790.         n= get_stream_idx(d+2);

  791. //av_log(s, AV_LOG_DEBUG, "%X %X %X %X %X %X %X %X %"PRId64" %d %d\n", d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n);

  792.         if(i + (uint64_t)size > avi->fsize || d[0]<0)

  793.             continue;

  794. 

  795.         //parse ix##

  796.         if(  (d[0] == 'i' && d[1] == 'x' && n < s->nb_streams)

  797.         //parse JUNK

  798.            ||(d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K')

  799.            ||(d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1')){

  800.             url_fskip(pb, size);

  801. //av_log(s, AV_LOG_DEBUG, "SKIP\n");

  802.             goto resync;

  803.         }

  804. 

  805.         n= get_stream_idx(d);

  806. 

  807.         if(!((i-avi->last_pkt_pos)&1) && get_stream_idx(d+1) < s->nb_streams)

  808.             continue;

  809. 

  810.         //parse ##dc/##wb

  811.         if(n < s->nb_streams){

  812.             AVStream *st;

  813.             AVIStream *ast;

  814.             st = s->streams[n];

  815.             ast = st->priv_data;

  816. 

  817.             if(s->nb_streams>=2){

  818.                 AVStream *st1  = s->streams[1];

  819.                 AVIStream *ast1= st1->priv_data;

  820.                 //workaround for broken small-file-bug402.avi

  821.                 if(   d[2] == 'w' && d[3] == 'b'

  822.                    && n==0

  823.                    && st ->codec->codec_type == CODEC_TYPE_VIDEO

  824.                    && st1->codec->codec_type == CODEC_TYPE_AUDIO

  825.                    && ast->prefix == 'd'*256+'c'

  826.                    && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count)

  827.                   ){

  828.                     n=1;

  829.                     st = st1;

  830.                     ast = ast1;

  831.                     av_log(s, AV_LOG_WARNING, "Invalid stream + prefix combination, assuming audio.\n");

  832.                 }

  833.             }

  834. 

  835. 

  836.             if(   (st->discard >= AVDISCARD_DEFAULT && size==0)

  837.                /*|| (st->discard >= AVDISCARD_NONKEY && !(pkt->flags & PKT_FLAG_KEY))*/ //FIXME needs a little reordering

  838.                || st->discard >= AVDISCARD_ALL){

  839.                 if(ast->sample_size) ast->frame_offset += pkt->size;

  840.                 else                 ast->frame_offset++;

  841.                 url_fskip(pb, size);

  842.                 goto resync;

  843.             }

  844. 

  845.             if (d[2] == 'p' && d[3] == 'c' && size<=4*256+4) {

  846.                 int k = get_byte(pb);

  847.                 int last = (k + get_byte(pb) - 1) & 0xFF;

  848. 

  849.                 get_le16(pb); //flags

  850. 

  851.                 for (; k <= last; k++)

  852.                     ast->pal[k] = get_be32(pb)>>8;// b + (g << 8) + (r << 16);

  853.                 ast->has_pal= 1;

  854.                 goto resync;

  855.             } else if(   ((ast->prefix_count<5 || sync+9 > i) && d[2]<128 && d[3]<128) ||

  856.                          d[2]*256+d[3] == ast->prefix /*||

  857.                          (d[2] == 'd' && d[3] == 'c') ||

  858.                          (d[2] == 'w' && d[3] == 'b')*/) {

  859. 

  860. //av_log(s, AV_LOG_DEBUG, "OK\n");

  861.                 if(d[2]*256+d[3] == ast->prefix)

  862.                     ast->prefix_count++;

  863.                 else{

  864.                     ast->prefix= d[2]*256+d[3];

  865.                     ast->prefix_count= 0;

  866.                 }

  867. 

  868.                 avi->stream_index= n;

  869.                 ast->packet_size= size + 8;

  870.                 ast->remaining= size;

  871. 

  872.                 {

  873.                     uint64_t pos= url_ftell(pb) - 8;

  874.                     if(!st->index_entries || !st->nb_index_entries || st->index_entries[st->nb_index_entries - 1].pos < pos){

  875.                         av_add_index_entry(st, pos, ast->frame_offset / FFMAX(1, ast->sample_size), size, 0, AVINDEX_KEYFRAME);

  876.                     }

  877.                 }

  878.                 goto resync;

  879.             }

  880.         }

  881.     }

  882. 

  883.     return AVERROR_EOF;

  884. }

  885. 

  886. /* XXX: We make the implicit supposition that the positions are sorted

  887.    for each stream. */

  888. static int avi_read_idx1(AVFormatContext *s, int size)

  889. {

  890.     AVIContext *avi = s->priv_data;

  891.     ByteIOContext *pb = s->pb;

  892.     int nb_index_entries, i;

  893.     AVStream *st;

  894.     AVIStream *ast;

  895.     unsigned int index, tag, flags, pos, len;

  896.     unsigned last_pos= -1;

  897. 

  898.     nb_index_entries = size / 16;

  899.     if (nb_index_entries <= 0)

  900.         return -1;

  901. 

  902.     /* Read the entries and sort them in each stream component. */

  903.     for(i = 0; i < nb_index_entries; i++) {

  904.         tag = get_le32(pb);

  905.         flags = get_le32(pb);

  906.         pos = get_le32(pb);

  907.         len = get_le32(pb);

  908. #if defined(DEBUG_SEEK)

  909.         av_log(s, AV_LOG_DEBUG, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/",

  910.                i, tag, flags, pos, len);

  911. #endif

  912.         if(i==0 && pos > avi->movi_list)

  913.             avi->movi_list= 0; //FIXME better check

  914.         pos += avi->movi_list;

  915. 

  916.         index = ((tag & 0xff) - '0') * 10;

  917.         index += ((tag >> 8) & 0xff) - '0';

  918.         if (index >= s->nb_streams)

  919.             continue;

  920.         st = s->streams[index];

  921.         ast = st->priv_data;

  922. 

  923. #if defined(DEBUG_SEEK)

  924.         av_log(s, AV_LOG_DEBUG, "%d cum_len=%"PRId64"\n", len, ast->cum_len);

  925. #endif

  926.         if(last_pos == pos)

  927.             avi->non_interleaved= 1;

  928.         else

  929.             av_add_index_entry(st, pos, ast->cum_len / FFMAX(1, ast->sample_size), len, 0, (flags&AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);

  930.         if(ast->sample_size)

  931.             ast->cum_len += len;

  932.         else

  933.             ast->cum_len ++;

  934.         last_pos= pos;

  935.     }

  936.     return 0;

  937. }

  938. 

  939. static int guess_ni_flag(AVFormatContext *s){

  940.     int i;

  941.     int64_t last_start=0;

  942.     int64_t first_end= INT64_MAX;

  943. 

  944.     for(i=0; i<s->nb_streams; i++){

  945.         AVStream *st = s->streams[i];

  946.         int n= st->nb_index_entries;

  947. 

  948.         if(n <= 0)

  949.             continue;

  950. 

  951.         if(st->index_entries[0].pos > last_start)

  952.             last_start= st->index_entries[0].pos;

  953.         if(st->index_entries[n-1].pos < first_end)

  954.             first_end= st->index_entries[n-1].pos;

  955.     }

  956.     return last_start > first_end;

  957. }

  958. 

  959. static int avi_load_index(AVFormatContext *s)

  960. {

  961.     AVIContext *avi = s->priv_data;

  962.     ByteIOContext *pb = s->pb;

  963.     uint32_t tag, size;

  964.     int64_t pos= url_ftell(pb);

  965. 

  966.     url_fseek(pb, avi->movi_end, SEEK_SET);

  967. #ifdef DEBUG_SEEK

  968.     printf("movi_end=0x%"PRIx64"\n", avi->movi_end);

  969. #endif

  970.     for(;;) {

  971.         if (url_feof(pb))

  972.             break;

  973.         tag = get_le32(pb);

  974.         size = get_le32(pb);

  975. #ifdef DEBUG_SEEK

  976.         printf("tag=%c%c%c%c size=0x%x\n",

  977.                tag & 0xff,

  978.                (tag >> 8) & 0xff,

  979.                (tag >> 16) & 0xff,

  980.                (tag >> 24) & 0xff,

  981.                size);

  982. #endif

  983.         switch(tag) {

  984.         case MKTAG('i', 'd', 'x', '1'):

  985.             if (avi_read_idx1(s, size) < 0)

  986.                 goto skip;

  987.             else

  988.                 goto the_end;

  989.             break;

  990.         default:

  991.         skip:

  992.             size += (size & 1);

  993.             url_fskip(pb, size);

  994.             break;

  995.         }

  996.     }

  997.  the_end:

  998.     url_fseek(pb, pos, SEEK_SET);

  999.     return 0;

  1000. }

  1001. 

  1002. static int avi_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)

  1003. {

  1004.     AVIContext *avi = s->priv_data;

  1005.     AVStream *st;

  1006.     int i, index;

  1007.     int64_t pos;

  1008. 

  1009.     if (!avi->index_loaded) {

  1010.         /* we only load the index on demand */

  1011.         avi_load_index(s);

  1012.         avi->index_loaded = 1;

  1013.     }

  1014.     assert(stream_index>= 0);

  1015. 

  1016.     st = s->streams[stream_index];

  1017.     index= av_index_search_timestamp(st, timestamp, flags);

  1018.     if(index<0)

  1019.         return -1;

  1020. 

  1021.     /* find the position */

  1022.     pos = st->index_entries[index].pos;

  1023.     timestamp = st->index_entries[index].timestamp;

  1024. 

  1025. //    av_log(s, AV_LOG_DEBUG, "XX %"PRId64" %d %"PRId64"\n", timestamp, index, st->index_entries[index].timestamp);

  1026. 

  1027.     if (CONFIG_DV_DEMUXER && avi->dv_demux) {

  1028.         /* One and only one real stream for DV in AVI, and it has video  */

  1029.         /* offsets. Calling with other stream indexes should have failed */

  1030.         /* the av_index_search_timestamp call above.                     */

  1031.         assert(stream_index == 0);

  1032. 

  1033.         /* Feed the DV video stream version of the timestamp to the */

  1034.         /* DV demux so it can synthesize correct timestamps.        */

  1035.         dv_offset_reset(avi->dv_demux, timestamp);

  1036. 

  1037.         url_fseek(s->pb, pos, SEEK_SET);

  1038.         avi->stream_index= -1;

  1039.         return 0;

  1040.     }

  1041. 

  1042.     for(i = 0; i < s->nb_streams; i++) {

  1043.         AVStream *st2 = s->streams[i];

  1044.         AVIStream *ast2 = st2->priv_data;

  1045. 

  1046.         ast2->packet_size=

  1047.         ast2->remaining= 0;

  1048. 

  1049.         if (st2->nb_index_entries <= 0)

  1050.             continue;

  1051. 

  1052. //        assert(st2->codec->block_align);

  1053.         assert((int64_t)st2->time_base.num*ast2->rate == (int64_t)st2->time_base.den*ast2->scale);

  1054.         index = av_index_search_timestamp(

  1055.                 st2,

  1056.                 av_rescale(timestamp, st2->time_base.den*(int64_t)st->time_base.num, st->time_base.den * (int64_t)st2->time_base.num),

  1057.                 flags | AVSEEK_FLAG_BACKWARD);

  1058.         if(index<0)

  1059.             index=0;

  1060. 

  1061.         if(!avi->non_interleaved){

  1062.             while(index>0 && st2->index_entries[index].pos > pos)

  1063.                 index--;

  1064.             while(index+1 < st2->nb_index_entries && st2->index_entries[index].pos < pos)

  1065.                 index++;

  1066.         }

  1067. 

  1068. //        av_log(s, AV_LOG_DEBUG, "%"PRId64" %d %"PRId64"\n", timestamp, index, st2->index_entries[index].timestamp);

  1069.         /* extract the current frame number */

  1070.         ast2->frame_offset = st2->index_entries[index].timestamp;

  1071.         if(ast2->sample_size)

  1072.             ast2->frame_offset *=ast2->sample_size;

  1073.     }

  1074. 

  1075.     /* do the seek */

  1076.     url_fseek(s->pb, pos, SEEK_SET);

  1077.     avi->stream_index= -1;

  1078.     return 0;

  1079. }

  1080. 

  1081. static int avi_read_close(AVFormatContext *s)

  1082. {

  1083.     int i;

  1084.     AVIContext *avi = s->priv_data;

  1085. 

  1086.     for(i=0;i<s->nb_streams;i++) {

  1087.         AVStream *st = s->streams[i];

  1088.         av_free(st->codec->palctrl);

  1089.     }

  1090. 

  1091.     if (avi->dv_demux)

  1092.         av_free(avi->dv_demux);

  1093. 

  1094.     return 0;

  1095. }

  1096. 

  1097. static int avi_probe(AVProbeData *p)

  1098. {

  1099.     int i;

  1100. 

  1101.     /* check file header */

  1102.     for(i=0; avi_headers[i][0]; i++)

  1103.         if(!memcmp(p->buf  , avi_headers[i]  , 4) &&

  1104.            !memcmp(p->buf+8, avi_headers[i]+4, 4))

  1105.             return AVPROBE_SCORE_MAX;

  1106. 

  1107.     return 0;

  1108. }

  1109. 

  1110. AVInputFormat avi_demuxer = {

  1111.     "avi",

  1112.     NULL_IF_CONFIG_SMALL("AVI format"),

  1113.     sizeof(AVIContext),

  1114.     avi_probe,

  1115.     avi_read_header,

  1116.     avi_read_packet,

  1117.     avi_read_close,

  1118.     avi_read_seek,

  1119. };