Merge commit '10aa44aa675e05067845e3e55fac37642cbbdae4'
authorMichael Niedermayer <michaelni@gmx.at>
Sun, 28 Jul 2013 11:05:35 +0000 (13:05 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Sun, 28 Jul 2013 11:06:38 +0000 (13:06 +0200)
* commit '10aa44aa675e05067845e3e55fac37642cbbdae4':
  avidec: K&R formatting cosmetics

Conflicts:
libavformat/avidec.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavformat/avidec.c

   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
- #include "libavutil/intreadwrite.h"
- #include "libavutil/mathematics.h"
++#include "libavutil/avassert.h"
+ #include "libavutil/avstring.h"
  #include "libavutil/bswap.h"
 +#include "libavutil/opt.h"
  #include "libavutil/dict.h"
- #include "libavutil/avstring.h"
- #include "libavutil/avassert.h"
+ #include "libavutil/intreadwrite.h"
+ #include "libavutil/mathematics.h"
  #include "avformat.h"
- #include "internal.h"
  #include "avi.h"
  #include "dv.h"
+ #include "internal.h"
  #include "riff.h"
  
 -#undef NDEBUG
 -#include <assert.h>
 -
  typedef struct AVIStream {
-     int64_t frame_offset; /* current frame (video) or byte (audio) counter
-                          (used to compute the pts) */
+     int64_t frame_offset;   /* current frame (video) or byte (audio) counter
+                              * (used to compute the pts) */
      int remaining;
      int packet_size;
  
  } AVIStream;
  
  typedef struct {
-     int64_t  riff_end;
-     int64_t  movi_end;
-     int64_t  fsize;
 +    const AVClass *class;
+     int64_t riff_end;
+     int64_t movi_end;
+     int64_t fsize;
 +    int64_t io_fsize;
      int64_t movi_list;
      int64_t last_pkt_pos;
      int index_loaded;
      int is_odml;
      int non_interleaved;
      int stream_index;
-     DVDemuxContextdv_demux;
+     DVDemuxContext *dv_demux;
      int odml_depth;
 +    int use_odml;
  #define MAX_ODML_DEPTH 1000
 +    int64_t dts_max;
  } AVIContext;
  
 +
 +static const AVOption options[] = {
 +    { "use_odml", "use odml index", offsetof(AVIContext, use_odml), AV_OPT_TYPE_INT, {.i64 = 1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM},
 +    { NULL },
 +};
 +
 +static const AVClass demuxer_class = {
 +    .class_name = "avi",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
 +    .category   = AV_CLASS_CATEGORY_DEMUXER,
 +};
 +
 +
  static const char avi_headers[][8] = {
-     { 'R', 'I', 'F', 'F',    'A', 'V', 'I', ' ' },
-     { 'R', 'I', 'F', 'F',    'A', 'V', 'I', 'X' },
-     { 'R', 'I', 'F', 'F',    'A', 'V', 'I', 0x19},
-     { 'O', 'N', '2', ' ',    'O', 'N', '2', 'f' },
-     { 'R', 'I', 'F', 'F',    'A', 'M', 'V', ' ' },
+     { 'R', 'I', 'F', 'F', 'A', 'V', 'I', ' '  },
+     { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 'X'  },
+     { 'R', 'I', 'F', 'F', 'A', 'V', 'I', 0x19 },
+     { 'O', 'N', '2', ' ', 'O', 'N', '2', 'f'  },
+     { 'R', 'I', 'F', 'F', 'A', 'M', 'V', ' '  },
      { 0 }
  };
  
@@@ -162,18 -147,24 +167,24 @@@ static int read_braindead_odml_indx(AVF
      AVStream *st;
      AVIStream *ast;
      int i;
-     int64_t last_pos= -1;
-     int64_t filesize= avi->fsize;
-     av_dlog(s, "longs_pre_entry:%d index_type:%d entries_in_use:%d chunk_id:%X base:%16"PRIX64"\n",
-             longs_pre_entry,index_type, entries_in_use, chunk_id, base);
-     if(stream_id >= s->nb_streams || stream_id < 0)
+     int64_t last_pos = -1;
 -    int64_t filesize = avio_size(s->pb);
++    int64_t filesize = avi->fsize;
+     av_dlog(s,
+             "longs_pre_entry:%d index_type:%d entries_in_use:%d "
+             "chunk_id:%X base:%16"PRIX64"\n",
+             longs_pre_entry,
+             index_type,
+             entries_in_use,
+             chunk_id,
+             base);
+     if (stream_id >= s->nb_streams || stream_id < 0)
          return AVERROR_INVALIDDATA;
-     st= s->streams[stream_id];
+     st  = s->streams[stream_id];
      ast = st->priv_data;
  
-     if(index_sub_type)
+     if (index_sub_type)
          return AVERROR_INVALIDDATA;
  
      avio_rl32(pb);
              return AVERROR_INVALIDDATA;
      }
  
-     for(i=0; i<entries_in_use; i++){
-         if(index_type){
-             int64_t pos= avio_rl32(pb) + base - 8;
-             int len    = avio_rl32(pb);
-             int key= len >= 0;
+     for (i = 0; i < entries_in_use; i++) {
+         if (index_type) {
+             int64_t pos = avio_rl32(pb) + base - 8;
+             int len     = avio_rl32(pb);
+             int key     = len >= 0;
              len &= 0x7FFFFFFF;
  
 -            av_dlog(s, "pos:%"PRId64", len:%X\n", pos, len);
 -
 -            if (pb->eof_reached)
 +#ifdef DEBUG_SEEK
 +            av_log(s, AV_LOG_ERROR, "pos:%"PRId64", len:%X\n", pos, len);
 +#endif
-             if(url_feof(pb))
++            if (url_feof(pb))
                  return AVERROR_INVALIDDATA;
  
-             if(last_pos == pos || pos == base - 8)
-                 avi->non_interleaved= 1;
-             if(last_pos != pos && (len || !ast->sample_size))
-                 av_add_index_entry(st, pos, ast->cum_len, len, 0, key ? AVINDEX_KEYFRAME : 0);
+             if (last_pos == pos || pos == base - 8)
+                 avi->non_interleaved = 1;
+             if (last_pos != pos && (len || !ast->sample_size))
+                 av_add_index_entry(st, pos, ast->cum_len, len, 0,
+                                    key ? AVINDEX_KEYFRAME : 0);
  
              ast->cum_len += get_duration(ast, len);
-             last_pos= pos;
-         }else{
+             last_pos      = pos;
+         } else {
              int64_t offset, pos;
              int duration;
              offset = avio_rl64(pb);
              avio_rl32(pb);       /* size */
              duration = avio_rl32(pb);
  
-             if(url_feof(pb))
 -            if (pb->eof_reached)
++            if (url_feof(pb))
                  return AVERROR_INVALIDDATA;
  
              pos = avio_tell(pb);
                  return AVERROR_INVALIDDATA;
              }
  
-             if(avio_seek(pb, offset+8, SEEK_SET) < 0)
 -            avio_seek(pb, offset + 8, SEEK_SET);
++            if (avio_seek(pb, offset + 8, SEEK_SET) < 0)
 +                return -1;
              avi->odml_depth++;
              read_braindead_odml_indx(s, frame_num);
              avi->odml_depth--;
              frame_num += duration;
  
-             if(avio_seek(pb, pos, SEEK_SET) < 0) {
 -            avio_seek(pb, pos, SEEK_SET);
++            if (avio_seek(pb, pos, SEEK_SET) < 0) {
 +                av_log(s, AV_LOG_ERROR, "Failed to restore position after reading index\n");
 +                return -1;
 +            }
 +
          }
      }
-     avi->index_loaded=2;
 -    avi->index_loaded = 1;
++    avi->index_loaded = 2;
      return 0;
  }
  
@@@ -360,33 -358,30 +384,33 @@@ static int avi_read_header(AVFormatCont
      unsigned int size;
      int i;
      AVStream *st;
-     AVIStream *ast = NULL;
-     int avih_width=0, avih_height=0;
-     int amv_file_format=0;
-     uint64_t list_end = 0;
+     AVIStream *ast      = NULL;
+     int avih_width      = 0, avih_height = 0;
+     int amv_file_format = 0;
+     uint64_t list_end   = 0;
      int ret;
 +    AVDictionaryEntry *dict_entry;
  
-     avi->stream_index= -1;
+     avi->stream_index = -1;
  
      ret = get_riff(s, pb);
      if (ret < 0)
          return ret;
  
 -    avi->fsize = avio_size(pb);
 -    if (avi->fsize <= 0)
 +    av_log(avi, AV_LOG_DEBUG, "use odml:%d\n", avi->use_odml);
 +
 +    avi->io_fsize = avi->fsize = avio_size(pb);
-     if(avi->fsize<=0 || avi->fsize < avi->riff_end)
-         avi->fsize= avi->riff_end == 8 ? INT64_MAX : avi->riff_end;
++    if (avi->fsize <= 0 || avi->fsize < avi->riff_end)
+         avi->fsize = avi->riff_end == 8 ? INT64_MAX : avi->riff_end;
  
      /* first list tag */
      stream_index = -1;
-     codec_type = -1;
+     codec_type   = -1;
      frame_period = 0;
-     for(;;) {
+     for (;;) {
 -        if (pb->eof_reached)
 +        if (url_feof(pb))
              goto fail;
-         tag = avio_rl32(pb);
+         tag  = avio_rl32(pb);
          size = avio_rl32(pb);
  
          print_tag("tag", tag, size);
  
              if (tag1 == MKTAG('m', 'o', 'v', 'i')) {
                  avi->movi_list = avio_tell(pb) - 4;
-                 if(size) avi->movi_end = avi->movi_list + size + (size & 1);
-                 else     avi->movi_end = avi->fsize;
+                 if (size)
+                     avi->movi_end = avi->movi_list + size + (size & 1);
+                 else
 -                    avi->movi_end = avio_size(pb);
++                    avi->movi_end = avi->fsize;
                  av_dlog(NULL, "movi end=%"PRIx64"\n", avi->movi_end);
                  goto end_of_header;
-             }
-             else if (tag1 == MKTAG('I', 'N', 'F', 'O'))
+             } else if (tag1 == MKTAG('I', 'N', 'F', 'O'))
                  ff_read_riff_info(s, size - 4);
              else if (tag1 == MKTAG('n', 'c', 'd', 't'))
                  avi_read_nikon(s, list_end);
                  break;
              }
  
 -            assert(stream_index < s->nb_streams);
 +            av_assert0(stream_index < s->nb_streams);
-             st->codec->stream_codec_tag= handler;
+             st->codec->stream_codec_tag = handler;
  
              avio_rl32(pb); /* flags */
              avio_rl16(pb); /* priority */
              st->start_time = 0;
              avio_rl32(pb); /* buffer size */
              avio_rl32(pb); /* quality */
 +            if (ast->cum_len*ast->scale/ast->rate > 3600) {
 +                av_log(s, AV_LOG_ERROR, "crazy start time, iam scared, giving up\n");
 +                return AVERROR_INVALIDDATA;
 +            }
              ast->sample_size = avio_rl32(pb); /* sample ssize */
-             ast->cum_len *= FFMAX(1, ast->sample_size);
+             ast->cum_len    *= FFMAX(1, ast->sample_size);
              av_dlog(s, "%"PRIu32" %"PRIu32" %d\n",
                      ast->rate, ast->scale, ast->sample_size);
  
                  codec_type = AVMEDIA_TYPE_DATA;
                  break;
              default:
 -                av_log(s, AV_LOG_ERROR, "unknown stream type %X\n", tag1);
 -                goto fail;
 +                av_log(s, AV_LOG_INFO, "unknown stream type %X\n", tag1);
              }
-             if(ast->sample_size == 0) {
 -            if (ast->sample_size == 0)
++            if (ast->sample_size == 0) {
                  st->duration = st->nb_frames;
-             ast->frame_offset= ast->cum_len;
 +                if (st->duration > 0 && avi->io_fsize > 0 && avi->riff_end > avi->io_fsize) {
 +                    av_log(s, AV_LOG_DEBUG, "File is truncated adjusting duration\n");
 +                    st->duration = av_rescale(st->duration, avi->io_fsize, avi->riff_end);
 +                }
 +            }
+             ast->frame_offset = ast->cum_len;
              avio_skip(pb, size - 12 * 4);
              break;
          case MKTAG('s', 't', 'r', 'f'):
                          avio_skip(pb, size);
                          break;
                      }
 -                    tag1 = ff_get_bmp_header(pb, st);
 +                    tag1 = ff_get_bmp_header(pb, st, &esize);
  
-                     if (tag1 == MKTAG('D', 'X', 'S', 'B') || tag1 == MKTAG('D','X','S','A')) {
+                     if (tag1 == MKTAG('D', 'X', 'S', 'B') ||
+                         tag1 == MKTAG('D', 'X', 'S', 'A')) {
                          st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
-                         st->codec->codec_tag = tag1;
-                         st->codec->codec_id = AV_CODEC_ID_XSUB;
+                         st->codec->codec_tag  = tag1;
+                         st->codec->codec_id   = AV_CODEC_ID_XSUB;
                          break;
                      }
  
-                     if(size > 10*4 && size<(1<<30) && size < avi->fsize){
-                         if(esize == size-1 && (esize&1)) st->codec->extradata_size= esize - 10*4;
-                         else                             st->codec->extradata_size=  size - 10*4;
-                         st->codec->extradata= av_malloc(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 -                    if (size > 10 * 4 && size < (1 << 30)) {
 -                        st->codec->extradata_size = size - 10 * 4;
++                    if (size > 10 * 4 && size < (1 << 30) && size < avi->fsize) {
++                        if (esize == size-1 && (esize&1)) {
++                            st->codec->extradata_size = esize - 10 * 4;
++                        } else
++                            st->codec->extradata_size =  size - 10 * 4;
+                         st->codec->extradata      = av_malloc(st->codec->extradata_size +
+                                                               FF_INPUT_BUFFER_PADDING_SIZE);
                          if (!st->codec->extradata) {
-                             st->codec->extradata_size= 0;
+                             st->codec->extradata_size = 0;
                              return AVERROR(ENOMEM);
                          }
-                         avio_read(pb, st->codec->extradata, st->codec->extradata_size);
+                         avio_read(pb,
+                                   st->codec->extradata,
+                                   st->codec->extradata_size);
                      }
  
-                     if(st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly
+                     // FIXME: check if the encoder really did this correctly
+                     if (st->codec->extradata_size & 1)
                          avio_r8(pb);
  
-                     /* Extract palette from extradata if bpp <= 8. */
-                     /* This code assumes that extradata contains only palette. */
-                     /* This is true for all paletted codecs implemented in FFmpeg. */
-                     if (st->codec->extradata_size && (st->codec->bits_per_coded_sample <= 8)) {
+                     /* Extract palette from extradata if bpp <= 8.
+                      * This code assumes that extradata contains only palette.
+                      * This is true for all paletted codecs implemented in
 -                     * Libav. */
++                     * FFmpeg. */
+                     if (st->codec->extradata_size &&
+                         (st->codec->bits_per_coded_sample <= 8)) {
                          int pal_size = (1 << st->codec->bits_per_coded_sample) << 2;
                          const uint8_t *pal_src;
  
                          pal_size = FFMIN(pal_size, st->codec->extradata_size);
-                         pal_src = st->codec->extradata + st->codec->extradata_size - pal_size;
-                         for (i = 0; i < pal_size/4; i++)
+                         pal_src  = st->codec->extradata +
+                                    st->codec->extradata_size - pal_size;
 -#if HAVE_BIGENDIAN
+                         for (i = 0; i < pal_size / 4; i++)
 -                            ast->pal[i] = av_bswap32(((uint32_t *)pal_src)[i]);
 -#else
 -                        memcpy(ast->pal, pal_src, pal_size);
 -#endif
 +                            ast->pal[i] = 0xFFU<<24 | AV_RL32(pal_src+4*i);
                          ast->has_pal = 1;
                      }
  
                      print_tag("video", tag1, 0);
  
                      st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
-                     st->codec->codec_tag = tag1;
-                     st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, tag1);
-                     st->need_parsing = AVSTREAM_PARSE_HEADERS; // This is needed to get the pict type which is necessary for generating correct pts.
-                     if(st->codec->codec_tag==0 && st->codec->height > 0 && st->codec->extradata_size < 1U<<30){
-                         st->codec->extradata_size+= 9;
-                         st->codec->extradata= av_realloc_f(st->codec->extradata, 1, st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
-                         if(st->codec->extradata)
-                             memcpy(st->codec->extradata + st->codec->extradata_size - 9, "BottomUp", 9);
+                     st->codec->codec_tag  = tag1;
+                     st->codec->codec_id   = ff_codec_get_id(ff_codec_bmp_tags,
+                                                             tag1);
+                     /* This is needed to get the pict type which is necessary
+                      * for generating correct pts. */
+                     st->need_parsing = AVSTREAM_PARSE_HEADERS;
 -                    // Support "Resolution 1:1" for Avid AVI Codec
 -                    if (tag1 == MKTAG('A', 'V', 'R', 'n') &&
 -                        st->codec->extradata_size >= 31   &&
 -                        !memcmp(&st->codec->extradata[28], "1:1", 3))
 -                        st->codec->codec_id = AV_CODEC_ID_RAWVIDEO;
+                     if (st->codec->codec_tag == 0 && st->codec->height > 0 &&
+                         st->codec->extradata_size < 1U << 30) {
+                         st->codec->extradata_size += 9;
 -                        st->codec->extradata       = av_realloc(st->codec->extradata,
 -                                                                st->codec->extradata_size +
 -                                                                FF_INPUT_BUFFER_PADDING_SIZE);
++                        st->codec->extradata       = av_realloc_f(st->codec->extradata,
++                                                                  1,
++                                                                  st->codec->extradata_size +
++                                                                  FF_INPUT_BUFFER_PADDING_SIZE);
+                         if (st->codec->extradata)
+                             memcpy(st->codec->extradata + st->codec->extradata_size - 9,
+                                    "BottomUp", 9);
                      }
-                     st->codec->height= FFABS(st->codec->height);
+                     st->codec->height = FFABS(st->codec->height);
  
  //                    avio_skip(pb, size - 5 * 4);
                      break;
                          st->need_parsing = AVSTREAM_PARSE_NONE;
                      /* AVI files with Xan DPCM audio (wrongly) declare PCM
                       * audio in the header but have Axan as stream_code_tag. */
-                     if (st->codec->stream_codec_tag == AV_RL32("Axan")){
+                     if (st->codec->stream_codec_tag == AV_RL32("Axan")) {
                          st->codec->codec_id  = AV_CODEC_ID_XAN_DPCM;
                          st->codec->codec_tag = 0;
 +                        ast->dshow_block_align = 0;
                      }
-                     if (amv_file_format){
-                         st->codec->codec_id  = AV_CODEC_ID_ADPCM_IMA_AMV;
+                     if (amv_file_format) {
+                         st->codec->codec_id    = AV_CODEC_ID_ADPCM_IMA_AMV;
                          ast->dshow_block_align = 0;
                      }
-                     if(st->codec->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align <= 4 && ast->dshow_block_align) {
++                    if (st->codec->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align <= 4 && ast->dshow_block_align) {
 +                        av_log(s, AV_LOG_DEBUG, "overriding invalid dshow_block_align of %d\n", ast->dshow_block_align);
 +                        ast->dshow_block_align = 0;
 +                    }
-                     if(st->codec->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 1024 && ast->sample_size == 1024 ||
++                    if (st->codec->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 1024 && ast->sample_size == 1024 ||
 +                       st->codec->codec_id == AV_CODEC_ID_AAC && ast->dshow_block_align == 4096 && ast->sample_size == 4096 ||
 +                       st->codec->codec_id == AV_CODEC_ID_MP3 && ast->dshow_block_align == 1152 && ast->sample_size == 1152) {
 +                        av_log(s, AV_LOG_DEBUG, "overriding sample_size\n");
 +                        ast->sample_size = 0;
 +                    }
                      break;
                  case AVMEDIA_TYPE_SUBTITLE:
                      st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
                  }
              }
              break;
-                 if(size<(1<<30)){
 +        case MKTAG('s', 't', 'r', 'd'):
 +            if (stream_index >= (unsigned)s->nb_streams
 +                || s->streams[stream_index]->codec->extradata_size
 +                || s->streams[stream_index]->codec->codec_tag == MKTAG('H','2','6','4')) {
 +                avio_skip(pb, size);
 +            } else {
 +                uint64_t cur_pos = avio_tell(pb);
 +                if (cur_pos < list_end)
 +                    size = FFMIN(size, list_end - cur_pos);
 +                st = s->streams[stream_index];
 +
-                 if(st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly
++                if (size<(1<<30)) {
 +                    st->codec->extradata_size= size;
 +                    st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 +                    if (!st->codec->extradata) {
 +                        st->codec->extradata_size= 0;
 +                        return AVERROR(ENOMEM);
 +                    }
 +                    avio_read(pb, st->codec->extradata, st->codec->extradata_size);
 +                }
 +
++                if (st->codec->extradata_size & 1) //FIXME check if the encoder really did this correctly
 +                    avio_r8(pb);
 +            }
 +            break;
          case MKTAG('i', 'n', 'd', 'x'):
-             i= avio_tell(pb);
-             if(pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX) && avi->use_odml &&
-                read_braindead_odml_indx(s, 0) < 0 && (s->error_recognition & AV_EF_EXPLODE))
+             i = avio_tell(pb);
+             if (pb->seekable && !(s->flags & AVFMT_FLAG_IGNIDX) &&
++                avi->use_odml &&
+                 read_braindead_odml_indx(s, 0) < 0 &&
+                 (s->error_recognition & AV_EF_EXPLODE))
                  goto fail;
-             avio_seek(pb, i+size, SEEK_SET);
+             avio_seek(pb, i + size, SEEK_SET);
              break;
          case MKTAG('v', 'p', 'r', 'p'):
-             if(stream_index < (unsigned)s->nb_streams && size > 9*4){
+             if (stream_index < (unsigned)s->nb_streams && size > 9 * 4) {
                  AVRational active, active_aspect;
  
                  st = s->streams[stream_index];
@@@ -801,35 -785,22 +861,36 @@@ fail
          return AVERROR_INVALIDDATA;
      }
  
-     if(!avi->index_loaded && pb->seekable)
+     if (!avi->index_loaded && pb->seekable)
          avi_load_index(s);
-     avi->index_loaded |= 1;
 -    avi->index_loaded     = 1;
 -    avi->non_interleaved |= guess_ni_flag(s);
++    avi->index_loaded    |= 1;
 +    avi->non_interleaved |= guess_ni_flag(s) | (s->flags & AVFMT_FLAG_SORT_DTS);
 +
 +    dict_entry = av_dict_get(s->metadata, "ISFT", NULL, 0);
 +    if (dict_entry && !strcmp(dict_entry->value, "PotEncoder"))
-         for (i=0; i<s->nb_streams; i++) {
++        for (i = 0; i < s->nb_streams; i++) {
 +            AVStream *st = s->streams[i];
 +            if (   st->codec->codec_id == AV_CODEC_ID_MPEG1VIDEO
 +                || st->codec->codec_id == AV_CODEC_ID_MPEG2VIDEO)
 +                st->need_parsing = AVSTREAM_PARSE_FULL;
 +        }
 +
-     for(i=0; i<s->nb_streams; i++){
+     for (i = 0; i < s->nb_streams; i++) {
          AVStream *st = s->streams[i];
-         if(st->nb_index_entries)
+         if (st->nb_index_entries)
              break;
      }
-     if(avi->dv_demux)
-         avi->non_interleaved=0;
-     if(i==s->nb_streams && avi->non_interleaved) {
-         av_log(s, AV_LOG_WARNING, "non-interleaved AVI without index, switching to interleaved\n");
-         avi->non_interleaved=0;
 +    // DV-in-AVI cannot be non-interleaved, if set this must be
 +    // a mis-detection.
++    if (avi->dv_demux)
++        avi->non_interleaved = 0;
+     if (i == s->nb_streams && avi->non_interleaved) {
+         av_log(s, AV_LOG_WARNING,
+                "Non-interleaved AVI without index, switching to interleaved\n");
+         avi->non_interleaved = 0;
      }
  
-     if(avi->non_interleaved) {
+     if (avi->non_interleaved) {
          av_log(s, AV_LOG_INFO, "non-interleaved AVI\n");
          clean_index(s);
      }
      return 0;
  }
  
- static int read_gab2_sub(AVStream *st, AVPacket *pkt) {
    if (pkt->data && !strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data+5) == 2) {
+ static int read_gab2_sub(AVStream *st, AVPacket *pkt)
+ {
 -    if (!strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data + 5) == 2) {
++    if (pkt->data && !strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data + 5) == 2) {
          uint8_t desc[256];
-         int score = AVPROBE_SCORE_EXTENSION, ret;
+         int score      = AVPROBE_SCORE_EXTENSION, ret;
          AVIStream *ast = st->priv_data;
          AVInputFormat *sub_demuxer;
          AVRational time_base;
@@@ -945,26 -917,26 +1011,26 @@@ static int avi_sync(AVFormatContext *s
  
  start_sync:
      memset(d, -1, sizeof(d));
-     for(i=sync=avio_tell(pb); !url_feof(pb); i++) {
 -    for (i = sync = avio_tell(pb); !pb->eof_reached; i++) {
++    for (i = sync = avio_tell(pb); !url_feof(pb); i++) {
          int j;
  
-         for(j=0; j<7; j++)
-             d[j]= d[j+1];
-         d[7]= avio_r8(pb);
+         for (j = 0; j < 7; j++)
+             d[j] = d[j + 1];
+         d[7] = avio_r8(pb);
  
-         size= d[4] + (d[5]<<8) + (d[6]<<16) + (d[7]<<24);
+         size = d[4] + (d[5] << 8) + (d[6] << 16) + (d[7] << 24);
  
-         n= get_stream_idx(d+2);
+         n = get_stream_idx(d + 2);
          av_dlog(s, "%X %X %X %X %X %X %X %X %"PRId64" %u %d\n",
                  d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7], i, size, n);
-         if(i*(avi->io_fsize>0) + (uint64_t)size > avi->fsize || d[0] > 127)
 -        if (i + (uint64_t)size > avi->fsize || d[0] > 127)
++        if (i*(avi->io_fsize>0) + (uint64_t)size > avi->fsize || d[0] > 127)
              continue;
  
-         //parse ix##
-         if(  (d[0] == 'i' && d[1] == 'x' && n < s->nb_streams)
-         //parse JUNK
-            ||(d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K')
-            ||(d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1')){
+         // parse ix##
+         if ((d[0] == 'i' && d[1] == 'x' && n < s->nb_streams) ||
+             // parse JUNK
+             (d[0] == 'J' && d[1] == 'U' && d[2] == 'N' && d[3] == 'K') ||
+             (d[0] == 'i' && d[1] == 'd' && d[2] == 'x' && d[3] == '1')) {
              avio_skip(pb, size);
              goto start_sync;
          }
              goto start_sync;
          }
  
-         //parse ##dc/##wb
-         if(n < s->nb_streams){
+         // parse ##dc/##wb
+         if (n < s->nb_streams) {
              AVStream *st;
              AVIStream *ast;
-             st = s->streams[n];
+             st  = s->streams[n];
              ast = st->priv_data;
  
-             if(s->nb_streams>=2){
-                 AVStream *st1  = s->streams[1];
-                 AVIStream *ast1= st1->priv_data;
-                 //workaround for broken small-file-bug402.avi
-                 if(   d[2] == 'w' && d[3] == 'b'
-                    && n==0
 +            if (!ast) {
 +                av_log(s, AV_LOG_WARNING, "Skiping foreign stream %d packet\n", n);
 +                continue;
 +            }
 +
 -                if (d[2] == 'w' && d[3] == 'b' && n == 0 &&
 -                    st->codec->codec_type  == AVMEDIA_TYPE_VIDEO &&
 -                    st1->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
 -                    ast->prefix == 'd' * 256 + 'c' &&
 -                    (d[2] * 256 + d[3] == ast1->prefix ||
 -                     !ast1->prefix_count)) {
+             if (s->nb_streams >= 2) {
+                 AVStream *st1   = s->streams[1];
+                 AVIStream *ast1 = st1->priv_data;
+                 // workaround for broken small-file-bug402.avi
-                   ){
-                     n=1;
-                     st = st1;
++                if (   d[2] == 'w' && d[3] == 'b'
++                   && n == 0
 +                   && st ->codec->codec_type == AVMEDIA_TYPE_VIDEO
 +                   && st1->codec->codec_type == AVMEDIA_TYPE_AUDIO
 +                   && ast->prefix == 'd'*256+'c'
 +                   && (d[2]*256+d[3] == ast1->prefix || !ast1->prefix_count)
++                  ) {
+                     n   = 1;
+                     st  = st1;
                      ast = ast1;
-                     av_log(s, AV_LOG_WARNING, "Invalid stream + prefix combination, assuming audio.\n");
+                     av_log(s, AV_LOG_WARNING,
+                            "Invalid stream + prefix combination, assuming audio.\n");
                  }
              }
  
-             if(   (st->discard >= AVDISCARD_DEFAULT && size==0)
-                /*|| (st->discard >= AVDISCARD_NONKEY && !(pkt->flags & AV_PKT_FLAG_KEY))*/ //FIXME needs a little reordering
-                || st->discard >= AVDISCARD_ALL){
+             if ((st->discard >= AVDISCARD_DEFAULT && size == 0)
+                 /* || (st->discard >= AVDISCARD_NONKEY && !(pkt->flags & AV_PKT_FLAG_KEY)) */ // FIXME: needs a little reordering
+                 || st->discard >= AVDISCARD_ALL) {
                  if (!exit_early) {
                      ast->frame_offset += get_duration(ast, size);
 +                    avio_skip(pb, size);
 +                    goto start_sync;
                  }
 -                avio_skip(pb, size);
 -                goto start_sync;
              }
  
-             if (d[2] == 'p' && d[3] == 'c' && size<=4*256+4) {
-                 int k = avio_r8(pb);
+             if (d[2] == 'p' && d[3] == 'c' && size <= 4 * 256 + 4) {
+                 int k    = avio_r8(pb);
                  int last = (k + avio_r8(pb) - 1) & 0xFF;
  
-                 avio_rl16(pb); //flags
+                 avio_rl16(pb); // flags
  
+                 // b + (g << 8) + (r << 16);
                  for (; k <= last; k++)
-                     ast->pal[k] = 0xFFU<<24 | avio_rb32(pb)>>8;// b + (g << 8) + (r << 16);
-                 ast->has_pal= 1;
-                 goto start_sync;
-             } else if(   ((ast->prefix_count<5 || sync+9 > i) && d[2]<128 && d[3]<128) ||
-                          d[2]*256+d[3] == ast->prefix /*||
-                          (d[2] == 'd' && d[3] == 'c') ||
-                          (d[2] == 'w' && d[3] == 'b')*/) {
 -                    ast->pal[k] = avio_rb32(pb) >> 8;
++                    ast->pal[k] = 0xFFU<<24 | avio_rb32(pb)>>8;
  
+                 ast->has_pal = 1;
+                 goto start_sync;
+             } else if (((ast->prefix_count < 5 || sync + 9 > i) &&
+                         d[2] < 128 && d[3] < 128) ||
+                        d[2] * 256 + d[3] == ast->prefix /* ||
+                        (d[2] == 'd' && d[3] == 'c') ||
+                        (d[2] == 'w' && d[3] == 'b') */) {
                  if (exit_early)
                      return 0;
-                 if(d[2]*256+d[3] == ast->prefix)
+                 if (d[2] * 256 + d[3] == ast->prefix)
                      ast->prefix_count++;
-                 else{
-                     ast->prefix= d[2]*256+d[3];
-                     ast->prefix_count= 0;
+                 else {
+                     ast->prefix       = d[2] * 256 + d[3];
+                     ast->prefix_count = 0;
                  }
  
-                 avi->stream_index= n;
-                 ast->packet_size= size + 8;
-                 ast->remaining= size;
+                 avi->stream_index = n;
+                 ast->packet_size  = size + 8;
+                 ast->remaining    = size;
  
-                 if(size || !ast->sample_size){
-                     uint64_t pos= avio_tell(pb) - 8;
-                     if(!st->index_entries || !st->nb_index_entries || st->index_entries[st->nb_index_entries - 1].pos < pos){
-                         av_add_index_entry(st, pos, ast->frame_offset, size, 0, AVINDEX_KEYFRAME);
+                 if (size || !ast->sample_size) {
+                     uint64_t pos = avio_tell(pb) - 8;
+                     if (!st->index_entries || !st->nb_index_entries ||
+                         st->index_entries[st->nb_index_entries - 1].pos < pos) {
+                         av_add_index_entry(st, pos, ast->frame_offset, size,
+                                            0, AVINDEX_KEYFRAME);
                      }
                  }
                  return 0;
          }
      }
  
-     if(pb->error)
++    if (pb->error)
 +        return pb->error;
      return AVERROR_EOF;
  }
  
@@@ -1120,63 -1091,69 +1193,70 @@@ static int avi_read_packet(AVFormatCont
              return AVERROR_EOF;
  
          best_ast = best_st->priv_data;
-         best_ts = best_ast->frame_offset;
-         if(best_ast->remaining)
-             i= av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY | AVSEEK_FLAG_BACKWARD);
-         else{
-             i= av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY);
-             if(i>=0)
-                 best_ast->frame_offset= best_st->index_entries[i].timestamp;
 -        best_ts  = av_rescale_q(best_ts,
 -                                (AVRational) { FFMAX(1, best_ast->sample_size),
 -                                               AV_TIME_BASE },
 -                                best_st->time_base);
++        best_ts  = best_ast->frame_offset;
+         if (best_ast->remaining) {
+             i = av_index_search_timestamp(best_st,
+                                           best_ts,
+                                           AVSEEK_FLAG_ANY |
+                                           AVSEEK_FLAG_BACKWARD);
+         } else {
+             i = av_index_search_timestamp(best_st, best_ts, AVSEEK_FLAG_ANY);
+             if (i >= 0)
+                 best_ast->frame_offset = best_st->index_entries[i].timestamp;
          }
  
-         if(i>=0){
-             int64_t pos= best_st->index_entries[i].pos;
+         if (i >= 0) {
+             int64_t pos = best_st->index_entries[i].pos;
              pos += best_ast->packet_size - best_ast->remaining;
-             if(avio_seek(s->pb, pos + 8, SEEK_SET) < 0)
 -            avio_seek(s->pb, pos + 8, SEEK_SET);
++            if (avio_seek(s->pb, pos + 8, SEEK_SET) < 0)
 +              return AVERROR_EOF;
  
 -            assert(best_ast->remaining <= best_ast->packet_size);
 +            av_assert0(best_ast->remaining <= best_ast->packet_size);
  
-             avi->stream_index= best_stream_index;
-             if(!best_ast->remaining)
-                 best_ast->packet_size=
-                 best_ast->remaining= best_st->index_entries[i].size;
+             avi->stream_index = best_stream_index;
+             if (!best_ast->remaining)
+                 best_ast->packet_size =
+                 best_ast->remaining   = best_st->index_entries[i].size;
          }
 +        else
 +          return AVERROR_EOF;
      }
  
  resync:
-     if(avi->stream_index >= 0){
-         AVStream *st= s->streams[ avi->stream_index ];
-         AVIStream *ast= st->priv_data;
+     if (avi->stream_index >= 0) {
+         AVStream *st   = s->streams[avi->stream_index];
+         AVIStream *ast = st->priv_data;
          int size, err;
  
-         if(get_subtitle_pkt(s, st, pkt))
+         if (get_subtitle_pkt(s, st, pkt))
              return 0;
  
-         if(ast->sample_size <= 1) // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM
-             size= INT_MAX;
-         else if(ast->sample_size < 32)
+         // minorityreport.AVI block_align=1024 sample_size=1 IMA-ADPCM
+         if (ast->sample_size <= 1)
+             size = INT_MAX;
+         else if (ast->sample_size < 32)
              // arbitrary multiplier to avoid tiny packets for raw PCM data
-             size= 1024*ast->sample_size;
+             size = 1024 * ast->sample_size;
          else
-             size= ast->sample_size;
+             size = ast->sample_size;
  
-         if(size > ast->remaining)
-             size= ast->remaining;
-         avi->last_pkt_pos= avio_tell(pb);
-         err= av_get_packet(pb, pkt, size);
-         if(err<0)
+         if (size > ast->remaining)
+             size = ast->remaining;
+         avi->last_pkt_pos = avio_tell(pb);
+         err               = av_get_packet(pb, pkt, size);
+         if (err < 0)
              return err;
 +        size = err;
  
-         if(ast->has_pal && pkt->size<(unsigned)INT_MAX/2){
 -        if (ast->has_pal && pkt->data && pkt->size < (unsigned)INT_MAX / 2) {
++        if (ast->has_pal && pkt->size < (unsigned)INT_MAX / 2) {
              uint8_t *pal;
-             pal = av_packet_new_side_data(pkt, AV_PKT_DATA_PALETTE, AVPALETTE_SIZE);
-             if(!pal){
-                 av_log(s, AV_LOG_ERROR, "Failed to allocate data for palette\n");
-             }else{
+             pal = av_packet_new_side_data(pkt,
+                                           AV_PKT_DATA_PALETTE,
+                                           AVPALETTE_SIZE);
+             if (!pal) {
+                 av_log(s, AV_LOG_ERROR,
+                        "Failed to allocate data for palette\n");
+             } else {
                  memcpy(pal, ast->pal, AVPALETTE_SIZE);
                  ast->has_pal = 0;
              }
              dstr = pkt->destruct;
  #endif
              size = avpriv_dv_produce_packet(avi->dv_demux, pkt,
-                                     pkt->data, pkt->size, pkt->pos);
 -                                            pkt->data, pkt->size);
++                                            pkt->data, pkt->size, pkt->pos);
  #if FF_API_DESTRUCT_PACKET
              pkt->destruct = dstr;
  #endif
              if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
                  AVIndexEntry *e;
                  int index;
 -                assert(st->index_entries);
 +                av_assert0(st->index_entries);
  
-                 index= av_index_search_timestamp(st, ast->frame_offset, 0);
-                 e= &st->index_entries[index];
+                 index = av_index_search_timestamp(st, ast->frame_offset, 0);
+                 e     = &st->index_entries[index];
  
-                 if(index >= 0 && e->timestamp == ast->frame_offset){
-                     if (index == st->nb_index_entries-1){
 -                if (index >= 0 && e->timestamp == ast->frame_offset)
++                if (index >= 0 && e->timestamp == ast->frame_offset) {
++                    if (index == st->nb_index_entries-1) {
 +                        int key=1;
 +                        int i;
 +                        uint32_t state=-1;
-                         for(i=0; i<FFMIN(size,256); i++){
-                             if(st->codec->codec_id == AV_CODEC_ID_MPEG4){
-                                 if(state == 0x1B6){
++                        for (i=0; i<FFMIN(size,256); i++) {
++                            if (st->codec->codec_id == AV_CODEC_ID_MPEG4) {
++                                if (state == 0x1B6) {
 +                                    key= !(pkt->data[i]&0xC0);
 +                                    break;
 +                                }
 +                            }else
 +                                break;
 +                            state= (state<<8) + pkt->data[i];
 +                        }
-                         if(!key)
++                        if (!key)
 +                            e->flags &= ~AVINDEX_KEYFRAME;
 +                    }
                      if (e->flags & AVINDEX_KEYFRAME)
                          pkt->flags |= AV_PKT_FLAG_KEY;
 +                }
              } else {
                  pkt->flags |= AV_PKT_FLAG_KEY;
              }
              ast->frame_offset += get_duration(ast, pkt->size);
          }
          ast->remaining -= err;
-         if(!ast->remaining){
-             avi->stream_index= -1;
-             ast->packet_size= 0;
+         if (!ast->remaining) {
+             avi->stream_index = -1;
+             ast->packet_size  = 0;
          }
  
-         if(!avi->non_interleaved && pkt->pos >= 0 && ast->seek_pos > pkt->pos){
++        if (!avi->non_interleaved && pkt->pos >= 0 && ast->seek_pos > pkt->pos) {
 +            av_free_packet(pkt);
 +            goto resync;
 +        }
 +        ast->seek_pos= 0;
 +
-         if(!avi->non_interleaved && st->nb_index_entries>1 && avi->index_loaded>1){
++        if (!avi->non_interleaved && st->nb_index_entries>1 && avi->index_loaded>1) {
 +            int64_t dts= av_rescale_q(pkt->dts, st->time_base, AV_TIME_BASE_Q);
 +
-             if(avi->dts_max - dts > 2*AV_TIME_BASE){
++            if (avi->dts_max - dts > 2*AV_TIME_BASE) {
 +                avi->non_interleaved= 1;
 +                av_log(s, AV_LOG_INFO, "Switching to NI mode, due to poor interleaving\n");
-             }else if(avi->dts_max < dts)
++            }else if (avi->dts_max < dts)
 +                avi->dts_max = dts;
 +        }
 +
          return 0;
      }
  
@@@ -1287,10 -1238,8 +1375,10 @@@ static int avi_read_idx1(AVFormatContex
      AVStream *st;
      AVIStream *ast;
      unsigned int index, tag, flags, pos, len, first_packet = 1;
-     unsigned last_pos= -1;
-     unsigned last_idx= -1;
+     unsigned last_pos = -1;
++    unsigned last_idx = -1;
      int64_t idx1_pos, first_packet_pos = 0, data_offset = 0;
 +    int anykey = 0;
  
      nb_index_entries = size / 16;
      if (nb_index_entries <= 0)
      avi->stream_index = -1;
      avio_seek(pb, idx1_pos, SEEK_SET);
  
-     if (s->nb_streams == 1 && s->streams[0]->codec->codec_tag == AV_RL32("MMES")){
++    if (s->nb_streams == 1 && s->streams[0]->codec->codec_tag == AV_RL32("MMES")) {
 +        first_packet_pos = 0;
 +        data_offset = avi->movi_list;
 +    }
 +
      /* Read the entries and sort them in each stream component. */
-     for(i = 0; i < nb_index_entries; i++) {
-         if(url_feof(pb))
+     for (i = 0; i < nb_index_entries; i++) {
++        if (url_feof(pb))
 +            return -1;
 +
-         tag = avio_rl32(pb);
+         tag   = avio_rl32(pb);
          flags = avio_rl32(pb);
-         pos = avio_rl32(pb);
-         len = avio_rl32(pb);
+         pos   = avio_rl32(pb);
+         len   = avio_rl32(pb);
          av_dlog(s, "%d: tag=0x%x flags=0x%x pos=0x%x len=%d/",
                  i, tag, flags, pos, len);
  
  
          av_dlog(s, "%d cum_len=%"PRId64"\n", len, ast->cum_len);
  
 -        if (pb->eof_reached)
 -            return AVERROR_INVALIDDATA;
 -
 +        // even if we have only a single stream, we should
 +        // switch to non-interleaved to get correct timestamps
-         if(last_pos == pos)
-             avi->non_interleaved= 1;
-         if(last_idx != pos && len) {
-             av_add_index_entry(st, pos, ast->cum_len, len, 0, (flags&AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);
+         if (last_pos == pos)
+             avi->non_interleaved = 1;
 -        else if (len || !ast->sample_size)
++        if (last_idx != pos && len) {
+             av_add_index_entry(st, pos, ast->cum_len, len, 0,
+                                (flags & AVIIF_INDEX) ? AVINDEX_KEYFRAME : 0);
 +            last_idx= pos;
 +        }
          ast->cum_len += get_duration(ast, len);
-         last_pos= pos;
-         anykey |= flags&AVIIF_INDEX;
+         last_pos      = pos;
++        anykey       |= flags&AVIIF_INDEX;
 +    }
 +    if (!anykey) {
 +        for (index = 0; index < s->nb_streams; index++) {
 +            st = s->streams[index];
 +            if (st->nb_index_entries)
 +                st->index_entries[0].flags |= AVINDEX_KEYFRAME;
 +        }
      }
      return 0;
  }
  
- static int guess_ni_flag(AVFormatContext *s){
+ static int guess_ni_flag(AVFormatContext *s)
+ {
      int i;
-     int64_t last_start=0;
-     int64_t first_end= INT64_MAX;
-     int64_t oldpos= avio_tell(s->pb);
+     int64_t last_start = 0;
+     int64_t first_end  = INT64_MAX;
+     int64_t oldpos     = avio_tell(s->pb);
 +    int *idx;
 +    int64_t min_pos, pos;
  
-     for(i=0; i<s->nb_streams; i++){
+     for (i = 0; i < s->nb_streams; i++) {
          AVStream *st = s->streams[i];
-         int n= st->nb_index_entries;
+         int n        = st->nb_index_entries;
          unsigned int size;
  
-         if(n <= 0)
+         if (n <= 0)
              continue;
  
-         if(n >= 2){
-             int64_t pos= st->index_entries[0].pos;
+         if (n >= 2) {
+             int64_t pos = st->index_entries[0].pos;
              avio_seek(s->pb, pos + 4, SEEK_SET);
-             size= avio_rl32(s->pb);
-             if(pos + size > st->index_entries[1].pos)
-                 last_start= INT64_MAX;
+             size = avio_rl32(s->pb);
+             if (pos + size > st->index_entries[1].pos)
+                 last_start = INT64_MAX;
          }
  
-         if(st->index_entries[0].pos > last_start)
-             last_start= st->index_entries[0].pos;
-         if(st->index_entries[n-1].pos < first_end)
-             first_end= st->index_entries[n-1].pos;
+         if (st->index_entries[0].pos > last_start)
+             last_start = st->index_entries[0].pos;
+         if (st->index_entries[n - 1].pos < first_end)
+             first_end = st->index_entries[n - 1].pos;
      }
      avio_seek(s->pb, oldpos, SEEK_SET);
 -    return last_start > first_end;
 +    if (last_start > first_end)
 +        return 1;
 +    idx= av_mallocz(sizeof(*idx) * s->nb_streams);
 +    for (min_pos=pos=0; min_pos!=INT64_MAX; pos= min_pos+1LU) {
 +        int64_t max_dts = INT64_MIN/2, min_dts= INT64_MAX/2;
 +        min_pos = INT64_MAX;
 +
 +        for (i=0; i<s->nb_streams; i++) {
 +            AVStream *st = s->streams[i];
 +            AVIStream *ast = st->priv_data;
 +            int n= st->nb_index_entries;
 +            while (idx[i]<n && st->index_entries[idx[i]].pos < pos)
 +                idx[i]++;
 +            if (idx[i] < n) {
 +                min_dts = FFMIN(min_dts, av_rescale_q(st->index_entries[idx[i]].timestamp/FFMAX(ast->sample_size, 1), st->time_base, AV_TIME_BASE_Q));
 +                min_pos = FFMIN(min_pos, st->index_entries[idx[i]].pos);
 +            }
 +            if (idx[i])
 +                max_dts = FFMAX(max_dts, av_rescale_q(st->index_entries[idx[i]-1].timestamp/FFMAX(ast->sample_size, 1), st->time_base, AV_TIME_BASE_Q));
 +        }
-         if(max_dts - min_dts > 2*AV_TIME_BASE) {
++        if (max_dts - min_dts > 2*AV_TIME_BASE) {
 +            av_free(idx);
 +            return 1;
 +        }
 +    }
 +    av_free(idx);
 +    return 0;
  }
  
  static int avi_load_index(AVFormatContext *s)
      AVIContext *avi = s->priv_data;
      AVIOContext *pb = s->pb;
      uint32_t tag, size;
-     int64_t pos= avio_tell(pb);
+     int64_t pos = avio_tell(pb);
 +    int64_t next;
-     int ret = -1;
+     int ret     = -1;
  
      if (avio_seek(pb, avi->movi_end, SEEK_SET) < 0)
          goto the_end; // maybe truncated file
      av_dlog(s, "movi_end=0x%"PRIx64"\n", avi->movi_end);
-     for(;;) {
-         tag = avio_rl32(pb);
+     for (;;) {
 -        if (pb->eof_reached)
 -            break;
+         tag  = avio_rl32(pb);
          size = avio_rl32(pb);
 +        if (url_feof(pb))
 +            break;
 +        next = avio_tell(pb) + size + (size & 1);
 +
          av_dlog(s, "tag=%c%c%c%c size=0x%x\n",
                   tag        & 0xff,
                  (tag >>  8) & 0xff,
  
          if (tag == MKTAG('i', 'd', 'x', '1') &&
              avi_read_idx1(s, size) >= 0) {
 +            avi->index_loaded=2;
              ret = 0;
-         }else if(tag == MKTAG('L', 'I', 'S', 'T')) {
++        }else if (tag == MKTAG('L', 'I', 'S', 'T')) {
 +            uint32_t tag1 = avio_rl32(pb);
 +
 +            if (tag1 == MKTAG('I', 'N', 'F', 'O'))
 +                ff_read_riff_info(s, size - 4);
-         }else if(!ret)
++        }else if (!ret)
              break;
 -        }
  
 -        size += (size & 1);
 -        if (avio_skip(pb, size) < 0)
 +        if (avio_seek(pb, next, SEEK_SET) < 0)
              break; // something is wrong here
      }
-  the_end:
+ the_end:
      avio_seek(pb, pos, SEEK_SET);
      return ret;
  }
@@@ -1484,24 -1383,20 +1575,26 @@@ static int avi_read_seek(AVFormatContex
      if (!avi->index_loaded) {
          /* we only load the index on demand */
          avi_load_index(s);
 -        avi->index_loaded = 1;
 +        avi->index_loaded |= 1;
      }
-     av_assert0(stream_index>= 0);
-     st = s->streams[stream_index];
-     ast= st->priv_data;
-     index= av_index_search_timestamp(st, timestamp * FFMAX(ast->sample_size, 1), flags);
-     if (index<0) {
 -    assert(stream_index >= 0);
++    av_assert0(stream_index >= 0);
+     st    = s->streams[stream_index];
+     ast   = st->priv_data;
+     index = av_index_search_timestamp(st,
+                                       timestamp * FFMAX(ast->sample_size, 1),
+                                       flags);
 -    if (index < 0)
++    if (index < 0) {
 +        if (st->nb_index_entries > 0)
 +            av_log(s, AV_LOG_DEBUG, "Failed to find timestamp %"PRId64 " in index %"PRId64 " .. %"PRId64 "\n",
 +                   timestamp * FFMAX(ast->sample_size, 1),
 +                   st->index_entries[0].timestamp,
 +                   st->index_entries[st->nb_index_entries - 1].timestamp);
          return AVERROR_INVALIDDATA;
 +    }
  
      /* find the position */
-     pos = st->index_entries[index].pos;
+     pos       = st->index_entries[index].pos;
      timestamp = st->index_entries[index].timestamp / FFMAX(ast->sample_size, 1);
  
      av_dlog(s, "XX %"PRId64" %d %"PRId64"\n",
          /* One and only one real stream for DV in AVI, and it has video  */
          /* offsets. Calling with other stream indexes should have failed */
          /* the av_index_search_timestamp call above.                     */
 -        assert(stream_index == 0);
 +        av_assert0(stream_index == 0);
 +
-         if(avio_seek(s->pb, pos, SEEK_SET) < 0)
++        if (avio_seek(s->pb, pos, SEEK_SET) < 0)
 +            return -1;
  
          /* Feed the DV video stream version of the timestamp to the */
          /* DV demux so it can synthesize correct timestamps.        */
          ff_dv_offset_reset(avi->dv_demux, timestamp);
  
-         avi->stream_index= -1;
 -        avio_seek(s->pb, pos, SEEK_SET);
+         avi->stream_index = -1;
          return 0;
      }
  
-     pos_min= pos;
-     for(i = 0; i < s->nb_streams; i++) {
-         AVStream *st2 = s->streams[i];
++    pos_min = pos;
+     for (i = 0; i < s->nb_streams; i++) {
+         AVStream *st2   = s->streams[i];
          AVIStream *ast2 = st2->priv_data;
  
-         ast2->packet_size=
-         ast2->remaining= 0;
+         ast2->packet_size =
+         ast2->remaining   = 0;
  
          if (ast2->sub_ctx) {
              seek_subtitle(st, st2, timestamp);
          if (st2->nb_index_entries <= 0)
              continue;
  
 -//        assert(st2->codec->block_align);
 -        assert((int64_t)st2->time_base.num * ast2->rate ==
 -               (int64_t)st2->time_base.den * ast2->scale);
 +//        av_assert1(st2->codec->block_align);
-         av_assert0((int64_t)st2->time_base.num*ast2->rate == (int64_t)st2->time_base.den*ast2->scale);
-         index = av_index_search_timestamp(
-                 st2,
-                 av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1),
-                 flags | AVSEEK_FLAG_BACKWARD | (st2->codec->codec_type != AVMEDIA_TYPE_VIDEO ? AVSEEK_FLAG_ANY : 0));
-         if(index<0)
-             index=0;
-         ast2->seek_pos= st2->index_entries[index].pos;
-         pos_min= FFMIN(pos_min,ast2->seek_pos);
++        av_assert0((int64_t)st2->time_base.num * ast2->rate ==
++                   (int64_t)st2->time_base.den * ast2->scale);
+         index = av_index_search_timestamp(st2,
+                                           av_rescale_q(timestamp,
+                                                        st->time_base,
+                                                        st2->time_base) *
+                                           FFMAX(ast2->sample_size, 1),
 -                                          flags | AVSEEK_FLAG_BACKWARD);
++                                          flags |
++                                          AVSEEK_FLAG_BACKWARD |
++                                          (st2->codec->codec_type != AVMEDIA_TYPE_VIDEO ? AVSEEK_FLAG_ANY : 0));
+         if (index < 0)
+             index = 0;
++        ast2->seek_pos = st2->index_entries[index].pos;
++        pos_min = FFMIN(pos_min,ast2->seek_pos);
 +    }
-     for(i = 0; i < s->nb_streams; i++) {
++    for (i = 0; i < s->nb_streams; i++) {
 +        AVStream *st2 = s->streams[i];
 +        AVIStream *ast2 = st2->priv_data;
  
 -        if (!avi->non_interleaved) {
 -            while (index > 0 && st2->index_entries[index].pos > pos)
 -                index--;
 -            while (index + 1 < st2->nb_index_entries &&
 -                   st2->index_entries[index].pos < pos)
 -                index++;
 -        }
 +        if (ast2->sub_ctx || st2->nb_index_entries <= 0)
 +            continue;
  
 -        av_dlog(s, "%"PRId64" %d %"PRId64"\n",
 -                timestamp, index, st2->index_entries[index].timestamp);
 -        /* extract the current frame number */
 +        index = av_index_search_timestamp(
 +                st2,
 +                av_rescale_q(timestamp, st->time_base, st2->time_base) * FFMAX(ast2->sample_size, 1),
 +                flags | AVSEEK_FLAG_BACKWARD | (st2->codec->codec_type != AVMEDIA_TYPE_VIDEO ? AVSEEK_FLAG_ANY : 0));
-         if(index<0)
-             index=0;
-         while(!avi->non_interleaved && index>0 && st2->index_entries[index-1].pos >= pos_min)
++        if (index < 0)
++            index = 0;
++        while (!avi->non_interleaved && index>0 && st2->index_entries[index-1].pos >= pos_min)
 +            index--;
          ast2->frame_offset = st2->index_entries[index].timestamp;
      }
  
      /* do the seek */
 -    avio_seek(s->pb, pos, SEEK_SET);
 +    if (avio_seek(s->pb, pos_min, SEEK_SET) < 0) {
 +        av_log(s, AV_LOG_ERROR, "Seek failed\n");
 +        return -1;
 +    }
-     avi->stream_index= -1;
-     avi->dts_max= INT_MIN;
+     avi->stream_index = -1;
++    avi->dts_max      = INT_MIN;
      return 0;
  }