libmpdemux/demux_avi.c

   1 /*
   2  * AVI file parser for DEMUXER v2.9
   3  * Copyright (c) 2001 A'rpi/ESP-team
   4  *
   5  * This file is part of MPlayer.
   6  *
   7  * MPlayer is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * MPlayer 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
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License along
  18  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  19  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  20  */
  21
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <unistd.h>
  25
  26 #include "config.h"
  27 #include "mp_msg.h"
  28 #include "help_mp.h"
  29
  30 #include "stream/stream.h"
  31 #include "demuxer.h"
  32 #include "stheader.h"
  33 #include "demux_ogg.h"
  34 #include "aviheader.h"
  35
  36 extern const demuxer_desc_t demuxer_desc_avi_ni;
  37 extern const demuxer_desc_t demuxer_desc_avi_nini;
  38
  39 // PTS:  0=interleaved  1=BPS-based
  40 int pts_from_bps=1;
  41
  42 // Select ds from ID
  43 static demux_stream_t *demux_avi_select_stream(demuxer_t *demux,
  44                                                unsigned int id)
  45 {
  46   int stream_id=avi_stream_id(id);
  47
  48
  49   if(demux->video->id==-1)
  50     if(demux->v_streams[stream_id])
  51         demux->video->id=stream_id;
  52
  53   if(demux->audio->id==-1)
  54     if(demux->a_streams[stream_id])
  55         demux->audio->id=stream_id;
  56
  57   if(stream_id==demux->audio->id){
  58       if(!demux->audio->sh){
  59         sh_audio_t* sh;
  60         avi_priv_t *priv=demux->priv;
  61         sh=demux->audio->sh=demux->a_streams[stream_id];
  62         mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected AVI audio ID = %d\n",demux->audio->id);
  63         if(sh->wf){
  64           priv->audio_block_size=sh->wf->nBlockAlign;
  65           if(!priv->audio_block_size){
  66             // for PCM audio we can calculate the blocksize:
  67             if(sh->format==1)
  68                 priv->audio_block_size=sh->wf->nChannels*(sh->wf->wBitsPerSample/8);
  69             else
  70                 priv->audio_block_size=1; // hope the best...
  71           } else {
  72             // workaround old mencoder's bug:
  73             if(sh->audio.dwSampleSize==1 && sh->audio.dwScale==1 &&
  74                (sh->wf->nBlockAlign==1152 || sh->wf->nBlockAlign==576)){
  75                 mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_WorkAroundBlockAlignHeaderBug);
  76                 priv->audio_block_size=1;
  77             }
  78           }
  79         } else {
  80           priv->audio_block_size=sh->audio.dwSampleSize;
  81         }
  82       }
  83       return demux->audio;
  84   }
  85   if(stream_id==demux->video->id){
  86       if(!demux->video->sh){
  87         demux->video->sh=demux->v_streams[stream_id];
  88         mp_msg(MSGT_DEMUX,MSGL_V,"Auto-selected AVI video ID = %d\n",demux->video->id);
  89       }
  90       return demux->video;
  91   }
  92   if(id!=mmioFOURCC('J','U','N','K')){
  93      // unknown
  94      mp_msg(MSGT_DEMUX,MSGL_DBG2,"Unknown chunk: %.4s (%X)\n",(char *) &id,id);
  95      //abort();
  96   }
  97   return NULL;
  98 }
  99
 100 static int valid_fourcc(unsigned int id){
 101     static const char valid[] = "0123456789abcdefghijklmnopqrstuvwxyz"
 102                                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ_";
 103     unsigned char* fcc=(unsigned char*)(&id);
 104     return strchr(valid, fcc[0]) && strchr(valid, fcc[1]) &&
 105            strchr(valid, fcc[2]) && strchr(valid, fcc[3]);
 106 }
 107
 108 static int valid_stream_id(unsigned int id) {
 109     unsigned char* fcc=(unsigned char*)(&id);
 110     return fcc[0] >= '0' && fcc[0] <= '9' && fcc[1] >= '0' && fcc[1] <= '9' &&
 111            ((fcc[2] == 'w' && fcc[3] == 'b') || (fcc[2] == 'd' && fcc[3] == 'c'));
 112 }
 113
 114 static int choose_chunk_len(unsigned int len1,unsigned int len2){
 115     // len1 has a bit more priority than len2. len1!=len2
 116     // Note: this is a first-idea-logic, may be wrong. comments welcomed.
 117
 118     // prefer small frames rather than 0
 119     if(!len1) return (len2>0x80000) ? len1 : len2;
 120     if(!len2) return (len1>0x100000) ? len2 : len1;
 121
 122     // choose the smaller value:
 123     return (len1<len2)? len1 : len2;
 124 }
 125
 126 static int demux_avi_read_packet(demuxer_t *demux,demux_stream_t *ds,unsigned int id,unsigned int len,int idxpos,int flags){
 127   avi_priv_t *priv=demux->priv;
 128   int skip;
 129   float pts=0;
 130
 131   mp_dbg(MSGT_DEMUX,MSGL_DBG3,"demux_avi.read_packet: %X\n",id);
 132
 133   if(ds==demux->audio){
 134       if(priv->pts_corrected==0){
 135           if(priv->pts_has_video){
 136               // we have video pts now
 137               float delay=0;
 138               if(((sh_audio_t*)(ds->sh))->wf->nAvgBytesPerSec)
 139                   delay=(float)priv->pts_corr_bytes/((sh_audio_t*)(ds->sh))->wf->nAvgBytesPerSec;
 140               mp_msg(MSGT_DEMUX,MSGL_V,"XXX initial  v_pts=%5.3f  a_pos=%d (%5.3f) \n",priv->avi_audio_pts,priv->pts_corr_bytes,delay);
 141               //priv->pts_correction=-priv->avi_audio_pts+delay;
 142               priv->pts_correction=delay-priv->avi_audio_pts;
 143               priv->avi_audio_pts+=priv->pts_correction;
 144               priv->pts_corrected=1;
 145           } else
 146               priv->pts_corr_bytes+=len;
 147       }
 148       if(pts_from_bps){
 149           pts = priv->audio_block_no *
 150             (float)((sh_audio_t*)demux->audio->sh)->audio.dwScale /
 151             (float)((sh_audio_t*)demux->audio->sh)->audio.dwRate;
 152       } else
 153           pts=priv->avi_audio_pts; //+priv->pts_correction;
 154       priv->avi_audio_pts=0;
 155       // update blockcount:
 156       priv->audio_block_no+=priv->audio_block_size ?
 157         ((len+priv->audio_block_size-1)/priv->audio_block_size) : 1;
 158   } else
 159   if(ds==demux->video){
 160      // video
 161      if(priv->skip_video_frames>0){
 162        // drop frame (seeking)
 163        --priv->skip_video_frames;
 164        ds=NULL;
 165      }
 166
 167      pts = priv->avi_video_pts = priv->video_pack_no *
 168          (float)((sh_video_t*)demux->video->sh)->video.dwScale /
 169          (float)((sh_video_t*)demux->video->sh)->video.dwRate;
 170
 171      priv->avi_audio_pts=priv->avi_video_pts+priv->pts_correction;
 172      priv->pts_has_video=1;
 173
 174      if(ds) ++priv->video_pack_no;
 175
 176   }
 177
 178   skip=(len+1)&(~1); // total bytes in this chunk
 179
 180   if(ds){
 181     mp_dbg(MSGT_DEMUX,MSGL_DBG2,"DEMUX_AVI: Read %d data bytes from packet %04X\n",len,id);
 182     ds_read_packet(ds,demux->stream,len,pts,idxpos,flags);
 183     skip-=len;
 184   }
 185   skip = FFMAX(skip, 0);
 186   if (avi_stream_id(id) > 99 && id != mmioFOURCC('J','U','N','K'))
 187     skip = FFMIN(skip, 65536);
 188   if(skip){
 189     mp_dbg(MSGT_DEMUX,MSGL_DBG2,"DEMUX_AVI: Skipping %d bytes from packet %04X\n",skip,id);
 190     stream_skip(demux->stream,skip);
 191   }
 192   return ds?1:0;
 193 }
 194
 195 static uint32_t avi_find_id(stream_t *stream) {
 196   uint32_t id = stream_read_dword_le(stream);
 197   if (!id) {
 198     mp_msg(MSGT_DEMUX, MSGL_WARN, "Incomplete stream? Trying resync.\n");
 199     do {
 200       id = stream_read_dword_le(stream);
 201       if (stream_eof(stream)) return 0;
 202     } while (avi_stream_id(id) > 99);
 203   }
 204   return id;
 205 }
 206
 207 // return value:
 208 //     0 = EOF or no stream found
 209 //     1 = successfully read a packet
 210 static int demux_avi_fill_buffer(demuxer_t *demux, demux_stream_t *dsds){
 211 avi_priv_t *priv=demux->priv;
 212 unsigned int id=0;
 213 unsigned int len;
 214 int ret=0;
 215 demux_stream_t *ds;
 216
 217 do{
 218   int flags=1;
 219   AVIINDEXENTRY *idx=NULL;
 220   if(priv->idx_size>0 && priv->idx_pos<priv->idx_size){
 221     off_t pos;
 222
 223     idx=&((AVIINDEXENTRY *)priv->idx)[priv->idx_pos++];
 224
 225     if(idx->dwFlags&AVIIF_LIST){
 226       if (!valid_stream_id(idx->ckid))
 227       // LIST
 228       continue;
 229       if (!priv->warned_unaligned)
 230         mp_msg(MSGT_DEMUX, MSGL_WARN, "Looks like unaligned chunk in index, broken AVI file!\n");
 231       priv->warned_unaligned = 1;
 232     }
 233     if(!demux_avi_select_stream(demux,idx->ckid)){
 234       mp_dbg(MSGT_DEMUX,MSGL_DBG3,"Skip chunk %.4s (0x%X)  \n",(char *)&idx->ckid,(unsigned int)idx->ckid);
 235       continue; // skip this chunk
 236     }
 237
 238     pos = (off_t)priv->idx_offset+AVI_IDX_OFFSET(idx);
 239     if((pos<demux->movi_start || pos>=demux->movi_end) && (demux->movi_end>demux->movi_start) && (demux->stream->flags & MP_STREAM_SEEK)){
 240       mp_msg(MSGT_DEMUX,MSGL_V,"ChunkOffset out of range!   idx=0x%"PRIX64"  \n",(int64_t)pos);
 241       continue;
 242     }
 243     stream_seek(demux->stream,pos);
 244     demux->filepos=stream_tell(demux->stream);
 245     id=stream_read_dword_le(demux->stream);
 246     if(stream_eof(demux->stream)) return 0; // EOF!
 247
 248     if(id!=idx->ckid){
 249       mp_msg(MSGT_DEMUX,MSGL_V,"ChunkID mismatch! raw=%.4s idx=%.4s  \n",(char *)&id,(char *)&idx->ckid);
 250       if(valid_fourcc(idx->ckid))
 251           id=idx->ckid; // use index if valid
 252       else
 253           if(!valid_fourcc(id)) continue; // drop chunk if both id and idx bad
 254     }
 255     len=stream_read_dword_le(demux->stream);
 256     if((len!=idx->dwChunkLength)&&((len+1)!=idx->dwChunkLength)){
 257       mp_msg(MSGT_DEMUX,MSGL_V,"ChunkSize mismatch! raw=%d idx=%d  \n",len,idx->dwChunkLength);
 258       if(len>0x200000 && idx->dwChunkLength>0x200000) continue; // both values bad :(
 259       len=choose_chunk_len(idx->dwChunkLength,len);
 260     }
 261     if(!(idx->dwFlags&AVIIF_KEYFRAME)) flags=0;
 262   } else {
 263     demux->filepos=stream_tell(demux->stream);
 264     if(demux->filepos>=demux->movi_end && demux->movi_end>demux->movi_start && (demux->stream->flags & MP_STREAM_SEEK)){
 265           demux->stream->eof=1;
 266           return 0;
 267     }
 268     id=avi_find_id(demux->stream);
 269     len=stream_read_dword_le(demux->stream);
 270     if(stream_eof(demux->stream)) return 0; // EOF!
 271
 272     if(id==mmioFOURCC('L','I','S','T') || id==mmioFOURCC('R', 'I', 'F', 'F')){
 273       id=stream_read_dword_le(demux->stream); // list or RIFF type
 274       continue;
 275     }
 276   }
 277
 278   ds=demux_avi_select_stream(demux,id);
 279   if(ds)
 280     if(ds->packs+1>=MAX_PACKS || ds->bytes+len>=MAX_PACK_BYTES){
 281         // this packet will cause a buffer overflow, switch to -ni mode!!!
 282         mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_SwitchToNi);
 283         if(priv->idx_size>0){
 284             // has index
 285             demux->type=DEMUXER_TYPE_AVI_NI;
 286             demux->desc=&demuxer_desc_avi_ni;
 287             --priv->idx_pos; // hack
 288         } else {
 289             // no index
 290             demux->type=DEMUXER_TYPE_AVI_NINI;
 291             demux->desc=&demuxer_desc_avi_nini;
 292             priv->idx_pos=demux->filepos; // hack
 293         }
 294         priv->idx_pos_v=priv->idx_pos_a=priv->idx_pos;
 295         // quit now, we can't even (no enough buffer memory) read this packet :(
 296         return -1;
 297     }
 298
 299   ret=demux_avi_read_packet(demux,ds,id,len,priv->idx_pos-1,flags);
 300 } while(ret!=1);
 301   return 1;
 302 }
 303
 304
 305 // return value:
 306 //     0 = EOF or no stream found
 307 //     1 = successfully read a packet
 308 static int demux_avi_fill_buffer_ni(demuxer_t *demux, demux_stream_t *ds)
 309 {
 310 avi_priv_t *priv=demux->priv;
 311 unsigned int id=0;
 312 unsigned int len;
 313 int ret=0;
 314
 315 do{
 316   int flags=1;
 317   AVIINDEXENTRY *idx=NULL;
 318   int idx_pos=0;
 319   demux->filepos=stream_tell(demux->stream);
 320
 321   if(ds==demux->video) idx_pos=priv->idx_pos_v++; else
 322   if(ds==demux->audio) idx_pos=priv->idx_pos_a++; else
 323                        idx_pos=priv->idx_pos++;
 324
 325   if(priv->idx_size>0 && idx_pos<priv->idx_size){
 326     off_t pos;
 327     idx=&((AVIINDEXENTRY *)priv->idx)[idx_pos];
 328
 329     if(idx->dwFlags&AVIIF_LIST){
 330       if (!valid_stream_id(idx->ckid))
 331       // LIST
 332       continue;
 333       if (!priv->warned_unaligned)
 334         mp_msg(MSGT_DEMUX, MSGL_WARN, "Looks like unaligned chunk in index, broken AVI file!\n");
 335       priv->warned_unaligned = 1;
 336     }
 337     if(ds && demux_avi_select_stream(demux,idx->ckid)!=ds){
 338       mp_dbg(MSGT_DEMUX,MSGL_DBG3,"Skip chunk %.4s (0x%X)  \n",(char *)&idx->ckid,(unsigned int)idx->ckid);
 339       continue; // skip this chunk
 340     }
 341
 342     pos = priv->idx_offset+AVI_IDX_OFFSET(idx);
 343     if((pos<demux->movi_start || pos>=demux->movi_end) && (demux->movi_end>demux->movi_start)){
 344       mp_msg(MSGT_DEMUX,MSGL_V,"ChunkOffset out of range!  current=0x%"PRIX64"  idx=0x%"PRIX64"  \n",(int64_t)demux->filepos,(int64_t)pos);
 345       continue;
 346     }
 347     stream_seek(demux->stream,pos);
 348
 349     id=stream_read_dword_le(demux->stream);
 350
 351     if(stream_eof(demux->stream)) return 0;
 352
 353     if(id!=idx->ckid){
 354       mp_msg(MSGT_DEMUX,MSGL_V,"ChunkID mismatch! raw=%.4s idx=%.4s  \n",(char *)&id,(char *)&idx->ckid);
 355       if(valid_fourcc(idx->ckid))
 356           id=idx->ckid; // use index if valid
 357       else
 358           if(!valid_fourcc(id)) continue; // drop chunk if both id and idx bad
 359     }
 360     len=stream_read_dword_le(demux->stream);
 361     if((len!=idx->dwChunkLength)&&((len+1)!=idx->dwChunkLength)){
 362       mp_msg(MSGT_DEMUX,MSGL_V,"ChunkSize mismatch! raw=%d idx=%d  \n",len,idx->dwChunkLength);
 363       if(len>0x200000 && idx->dwChunkLength>0x200000) continue; // both values bad :(
 364       len=choose_chunk_len(idx->dwChunkLength,len);
 365     }
 366     if(!(idx->dwFlags&AVIIF_KEYFRAME)) flags=0;
 367   } else return 0;
 368   ret=demux_avi_read_packet(demux,demux_avi_select_stream(demux,id),id,len,idx_pos,flags);
 369 } while(ret!=1);
 370   return 1;
 371 }
 372
 373
 374 // return value:
 375 //     0 = EOF or no stream found
 376 //     1 = successfully read a packet
 377 static int demux_avi_fill_buffer_nini(demuxer_t *demux, demux_stream_t *ds)
 378 {
 379 avi_priv_t *priv=demux->priv;
 380 unsigned int id=0;
 381 unsigned int len;
 382 int ret=0;
 383 off_t *fpos=NULL;
 384
 385   if(ds==demux->video) fpos=&priv->idx_pos_v; else
 386   if(ds==demux->audio) fpos=&priv->idx_pos_a; else
 387   return 0;
 388
 389   stream_seek(demux->stream,fpos[0]);
 390
 391 do{
 392
 393   demux->filepos=stream_tell(demux->stream);
 394   if(demux->filepos>=demux->movi_end && (demux->movi_end>demux->movi_start)){
 395           ds->eof=1;
 396           return 0;
 397   }
 398
 399   id=avi_find_id(demux->stream);
 400   len=stream_read_dword_le(demux->stream);
 401
 402   if(stream_eof(demux->stream)) return 0;
 403
 404   if(id==mmioFOURCC('L','I','S','T')){
 405       id=stream_read_dword_le(demux->stream);      // list type
 406       continue;
 407   }
 408
 409   if(id==mmioFOURCC('R','I','F','F')){
 410       mp_msg(MSGT_DEMUX,MSGL_V,"additional RIFF header...\n");
 411       id=stream_read_dword_le(demux->stream);      // "AVIX"
 412       continue;
 413   }
 414
 415   if(ds==demux_avi_select_stream(demux,id)){
 416     // read it!
 417     ret=demux_avi_read_packet(demux,ds,id,len,priv->idx_pos-1,0);
 418   } else {
 419     // skip it!
 420     int skip=(len+1)&(~1); // total bytes in this chunk
 421     stream_skip(demux->stream,skip);
 422   }
 423
 424 } while(ret!=1);
 425   fpos[0]=stream_tell(demux->stream);
 426   return 1;
 427 }
 428
 429 // AVI demuxer parameters:
 430 int index_mode=-1;  // -1=untouched  0=don't use index  1=use (generate) index
 431 char *index_file_save = NULL, *index_file_load = NULL;
 432 int force_ni=0;     // force non-interleaved AVI parsing
 433
 434 static demuxer_t* demux_open_avi(demuxer_t* demuxer){
 435     demux_stream_t *d_audio=demuxer->audio;
 436     demux_stream_t *d_video=demuxer->video;
 437     sh_audio_t *sh_audio=NULL;
 438     sh_video_t *sh_video=NULL;
 439     avi_priv_t* priv=calloc(1, sizeof(avi_priv_t));
 440
 441   demuxer->priv=(void*)priv;
 442
 443   //---- AVI header:
 444   read_avi_header(demuxer,(demuxer->stream->flags & MP_STREAM_SEEK_BW)?index_mode:-2);
 445
 446   if(demuxer->audio->id>=0 && !demuxer->a_streams[demuxer->audio->id]){
 447       mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_InvalidAudioStreamNosound,demuxer->audio->id);
 448       demuxer->audio->id=-2; // disabled
 449   }
 450   if(demuxer->video->id>=0 && !demuxer->v_streams[demuxer->video->id]){
 451       mp_msg(MSGT_DEMUX,MSGL_WARN,MSGTR_InvalidAudioStreamUsingDefault,demuxer->video->id);
 452       demuxer->video->id=-1; // autodetect
 453   }
 454
 455   stream_reset(demuxer->stream);
 456   stream_seek(demuxer->stream,demuxer->movi_start);
 457   if(priv->idx_size>1){
 458     // decide index format:
 459 #if 1
 460     if((AVI_IDX_OFFSET(&((AVIINDEXENTRY *)priv->idx)[0])<demuxer->movi_start ||
 461         AVI_IDX_OFFSET(&((AVIINDEXENTRY *)priv->idx)[1])<demuxer->movi_start )&& !priv->isodml)
 462       priv->idx_offset=demuxer->movi_start-4;
 463 #else
 464     if(AVI_IDX_OFFSET(&((AVIINDEXENTRY *)priv->idx)[0])<demuxer->movi_start)
 465       priv->idx_offset=demuxer->movi_start-4;
 466 #endif
 467     mp_msg(MSGT_DEMUX,MSGL_V,"AVI index offset: 0x%X (movi=0x%X idx0=0x%X idx1=0x%X)\n",
 468             (int)priv->idx_offset,(int)demuxer->movi_start,
 469             (int)((AVIINDEXENTRY *)priv->idx)[0].dwChunkOffset,
 470             (int)((AVIINDEXENTRY *)priv->idx)[1].dwChunkOffset);
 471   }
 472
 473   if(priv->idx_size>0){
 474       // check that file is non-interleaved:
 475       int i;
 476       off_t a_pos=-1;
 477       off_t v_pos=-1;
 478       for(i=0;i<priv->idx_size;i++){
 479         AVIINDEXENTRY* idx=&((AVIINDEXENTRY *)priv->idx)[i];
 480         demux_stream_t* ds=demux_avi_select_stream(demuxer,idx->ckid);
 481         off_t pos = priv->idx_offset + AVI_IDX_OFFSET(idx);
 482         if(a_pos==-1 && ds==demuxer->audio){
 483           a_pos=pos;
 484           if(v_pos!=-1) break;
 485         }
 486         if(v_pos==-1 && ds==demuxer->video){
 487           v_pos=pos;
 488           if(a_pos!=-1) break;
 489         }
 490       }
 491       if(v_pos==-1){
 492         mp_msg(MSGT_DEMUX,MSGL_ERR,"AVI_NI: " MSGTR_MissingVideoStream);
 493         return NULL;
 494       }
 495       if(a_pos==-1){
 496         d_audio->sh=sh_audio=NULL;
 497       } else {
 498         if(force_ni || abs(a_pos-v_pos)>0x100000){  // distance > 1MB
 499           mp_msg(MSGT_DEMUX,MSGL_INFO,MSGTR_NI_Message,force_ni?MSGTR_NI_Forced:MSGTR_NI_Detected);
 500           demuxer->type=DEMUXER_TYPE_AVI_NI; // HACK!!!!
 501           demuxer->desc=&demuxer_desc_avi_ni; // HACK!!!!
 502           pts_from_bps=1; // force BPS sync!
 503         }
 504       }
 505   } else {
 506       // no index
 507       if(force_ni){
 508           mp_msg(MSGT_DEMUX,MSGL_INFO,MSGTR_UsingNINI);
 509           demuxer->type=DEMUXER_TYPE_AVI_NINI; // HACK!!!!
 510           demuxer->desc=&demuxer_desc_avi_nini; // HACK!!!!
 511           priv->idx_pos_a=
 512           priv->idx_pos_v=demuxer->movi_start;
 513           pts_from_bps=1; // force BPS sync!
 514       }
 515       demuxer->seekable=0;
 516   }
 517   if(!ds_fill_buffer(d_video)){
 518     mp_msg(MSGT_DEMUX,MSGL_ERR,"AVI: " MSGTR_MissingVideoStreamBug);
 519     return NULL;
 520   }
 521   sh_video=d_video->sh;sh_video->ds=d_video;
 522   if(d_audio->id!=-2){
 523     mp_msg(MSGT_DEMUX,MSGL_V,"AVI: Searching for audio stream (id:%d)\n",d_audio->id);
 524     if(!priv->audio_streams || !ds_fill_buffer(d_audio)){
 525       mp_msg(MSGT_DEMUX,MSGL_INFO,"AVI: " MSGTR_MissingAudioStream);
 526       d_audio->sh=sh_audio=NULL;
 527     } else {
 528       sh_audio=d_audio->sh;sh_audio->ds=d_audio;
 529     }
 530   }
 531
 532   // calculating audio/video bitrate:
 533   if(priv->idx_size>0){
 534     // we have index, let's count 'em!
 535     AVIINDEXENTRY *idx = priv->idx;
 536     int64_t vsize=0;
 537     int64_t asize=0;
 538     size_t vsamples=0;
 539     size_t asamples=0;
 540     int i;
 541     for(i=0;i<priv->idx_size;i++){
 542       int id=avi_stream_id(idx[i].ckid);
 543       unsigned len=idx[i].dwChunkLength;
 544       if(sh_video->ds->id == id) {
 545         vsize+=len;
 546         ++vsamples;
 547       }
 548       else if(sh_audio && sh_audio->ds->id == id) {
 549         asize+=len;
 550         asamples+=(len+priv->audio_block_size-1)/priv->audio_block_size;
 551       }
 552     }
 553     mp_msg(MSGT_DEMUX,MSGL_V,"AVI video size=%"PRId64" (%u) audio size=%"PRId64" (%u)\n",vsize,vsamples,asize,asamples);
 554     priv->numberofframes=vsamples;
 555     sh_video->i_bps=((float)vsize/(float)vsamples)*(float)sh_video->video.dwRate/(float)sh_video->video.dwScale;
 556     if(sh_audio) sh_audio->i_bps=((float)asize/(float)asamples)*(float)sh_audio->audio.dwRate/(float)sh_audio->audio.dwScale;
 557   } else {
 558     // guessing, results may be inaccurate:
 559     int64_t vsize;
 560     int64_t asize=0;
 561
 562     if((priv->numberofframes=sh_video->video.dwLength)<=1)
 563       // bad video header, try to get number of frames from audio
 564       if(sh_audio && sh_audio->wf->nAvgBytesPerSec) priv->numberofframes=sh_video->fps*sh_audio->audio.dwLength/sh_audio->audio.dwRate*sh_audio->audio.dwScale;
 565     if(priv->numberofframes<=1){
 566       mp_msg(MSGT_SEEK,MSGL_WARN,MSGTR_CouldntDetFNo);
 567       priv->numberofframes=0;
 568     }
 569
 570     if(sh_audio){
 571       if(sh_audio->wf->nAvgBytesPerSec && sh_audio->audio.dwSampleSize!=1){
 572         asize=(float)sh_audio->wf->nAvgBytesPerSec*sh_audio->audio.dwLength*sh_audio->audio.dwScale/sh_audio->audio.dwRate;
 573       } else {
 574         asize=sh_audio->audio.dwLength;
 575         sh_audio->i_bps=(float)asize/(sh_video->frametime*priv->numberofframes);
 576       }
 577     }
 578     vsize=demuxer->movi_end-demuxer->movi_start-asize-8*priv->numberofframes;
 579     mp_msg(MSGT_DEMUX,MSGL_V,"AVI video size=%"PRId64" (%u)  audio size=%"PRId64"\n",vsize,priv->numberofframes,asize);
 580     sh_video->i_bps=(float)vsize/(sh_video->frametime*priv->numberofframes);
 581   }
 582
 583   return demuxer;
 584
 585 }
 586
 587
 588 static void demux_seek_avi(demuxer_t *demuxer, float rel_seek_secs,
 589                            float audio_delay, int flags)
 590 {
 591     avi_priv_t *priv=demuxer->priv;
 592     demux_stream_t *d_audio=demuxer->audio;
 593     demux_stream_t *d_video=demuxer->video;
 594     sh_audio_t *sh_audio=d_audio->sh;
 595     sh_video_t *sh_video=d_video->sh;
 596     float skip_audio_secs=0;
 597
 598   //FIXME: OFF_T - Didn't check AVI case yet (avi files can't be >2G anyway?)
 599   //================= seek in AVI ==========================
 600     int rel_seek_frames=rel_seek_secs*sh_video->fps;
 601     int video_chunk_pos=d_video->pos;
 602     int i;
 603
 604       if(flags&SEEK_ABSOLUTE){
 605         // seek absolute
 606         video_chunk_pos=0;
 607       }
 608
 609       if(flags&SEEK_FACTOR){
 610         rel_seek_frames=rel_seek_secs*priv->numberofframes;
 611       }
 612
 613       priv->skip_video_frames=0;
 614       priv->avi_audio_pts=0;
 615
 616 // ------------ STEP 1: find nearest video keyframe chunk ------------
 617       // find nearest video keyframe chunk pos:
 618       if(rel_seek_frames>0){
 619         // seek forward
 620         while(video_chunk_pos<priv->idx_size-1){
 621           int id=((AVIINDEXENTRY *)priv->idx)[video_chunk_pos].ckid;
 622           if(avi_stream_id(id)==d_video->id){  // video frame
 623             if((--rel_seek_frames)<0 && ((AVIINDEXENTRY *)priv->idx)[video_chunk_pos].dwFlags&AVIIF_KEYFRAME) break;
 624           }
 625           ++video_chunk_pos;
 626         }
 627       } else {
 628         // seek backward
 629         while(video_chunk_pos>0){
 630           int id=((AVIINDEXENTRY *)priv->idx)[video_chunk_pos].ckid;
 631           if(avi_stream_id(id)==d_video->id){  // video frame
 632             if((++rel_seek_frames)>0 && ((AVIINDEXENTRY *)priv->idx)[video_chunk_pos].dwFlags&AVIIF_KEYFRAME) break;
 633           }
 634           --video_chunk_pos;
 635         }
 636       }
 637       priv->idx_pos_a=priv->idx_pos_v=priv->idx_pos=video_chunk_pos;
 638
 639       // re-calc video pts:
 640       d_video->pack_no=0;
 641       for(i=0;i<video_chunk_pos;i++){
 642           int id=((AVIINDEXENTRY *)priv->idx)[i].ckid;
 643           if(avi_stream_id(id)==d_video->id) ++d_video->pack_no;
 644       }
 645       priv->video_pack_no=
 646       sh_video->num_frames=sh_video->num_frames_decoded=d_video->pack_no;
 647       priv->avi_video_pts=d_video->pack_no*(float)sh_video->video.dwScale/(float)sh_video->video.dwRate;
 648       d_video->pos=video_chunk_pos;
 649
 650       mp_msg(MSGT_SEEK,MSGL_DBG2,"V_SEEK:  pack=%d  pts=%5.3f  chunk=%d  \n",d_video->pack_no,priv->avi_video_pts,video_chunk_pos);
 651
 652 // ------------ STEP 2: seek audio, find the right chunk & pos ------------
 653
 654       d_audio->pack_no=0;
 655       priv->audio_block_no=0;
 656       d_audio->dpos=0;
 657
 658       if(sh_audio){
 659         int i;
 660         int len=0;
 661         int skip_audio_bytes=0;
 662         int curr_audio_pos=-1;
 663         int audio_chunk_pos=-1;
 664         int chunk_max=(demuxer->type==DEMUXER_TYPE_AVI)?video_chunk_pos:priv->idx_size;
 665
 666         if(sh_audio->audio.dwSampleSize){
 667             // constant rate audio stream
 668             /* immediate seeking to audio position, including when streams are delayed */
 669             curr_audio_pos=(priv->avi_video_pts + audio_delay)*(float)sh_audio->audio.dwRate/(float)sh_audio->audio.dwScale;
 670             curr_audio_pos*=sh_audio->audio.dwSampleSize;
 671
 672         // find audio chunk pos:
 673           for(i=0;i<chunk_max;i++){
 674             int id=((AVIINDEXENTRY *)priv->idx)[i].ckid;
 675             if(avi_stream_id(id)==d_audio->id){
 676                 len=((AVIINDEXENTRY *)priv->idx)[i].dwChunkLength;
 677                 if(d_audio->dpos<=curr_audio_pos && curr_audio_pos<(d_audio->dpos+len)){
 678                   break;
 679                 }
 680                 ++d_audio->pack_no;
 681                 priv->audio_block_no+=priv->audio_block_size ?
 682                     ((len+priv->audio_block_size-1)/priv->audio_block_size) : 1;
 683                 d_audio->dpos+=len;
 684             }
 685           }
 686           audio_chunk_pos=i;
 687           skip_audio_bytes=curr_audio_pos-d_audio->dpos;
 688
 689           mp_msg(MSGT_SEEK,MSGL_V,"SEEK: i=%d (max:%d) dpos=%d (wanted:%d)  \n",
 690               i,chunk_max,(int)d_audio->dpos,curr_audio_pos);
 691
 692         } else {
 693             // VBR audio
 694             /* immediate seeking to audio position, including when streams are delayed */
 695             int chunks=(priv->avi_video_pts + audio_delay)*(float)sh_audio->audio.dwRate/(float)sh_audio->audio.dwScale;
 696             audio_chunk_pos=0;
 697
 698         // find audio chunk pos:
 699           for(i=0;i<priv->idx_size && chunks>0;i++){
 700             int id=((AVIINDEXENTRY *)priv->idx)[i].ckid;
 701             if(avi_stream_id(id)==d_audio->id){
 702                 len=((AVIINDEXENTRY *)priv->idx)[i].dwChunkLength;
 703                 if(i>chunk_max){
 704                   skip_audio_bytes+=len;
 705                 } else {
 706                   ++d_audio->pack_no;
 707                   priv->audio_block_no+=priv->audio_block_size ?
 708                     ((len+priv->audio_block_size-1)/priv->audio_block_size) : 1;
 709                   d_audio->dpos+=len;
 710                   audio_chunk_pos=i;
 711                 }
 712                 if(priv->audio_block_size)
 713                     chunks-=(len+priv->audio_block_size-1)/priv->audio_block_size;
 714             }
 715           }
 716         }
 717
 718         // Now we have:
 719         //      audio_chunk_pos = chunk no in index table (it's <=chunk_max)
 720         //      skip_audio_bytes = bytes to be skipped after chunk seek
 721         //      d-audio->pack_no = chunk_no in stream at audio_chunk_pos
 722         //      d_audio->dpos = bytepos in stream at audio_chunk_pos
 723         // let's seek!
 724
 725           // update stream position:
 726           d_audio->pos=audio_chunk_pos;
 727
 728         if(demuxer->type==DEMUXER_TYPE_AVI){
 729           // interleaved stream:
 730           if(audio_chunk_pos<video_chunk_pos){
 731             // calc priv->skip_video_frames & adjust video pts counter:
 732             for(i=audio_chunk_pos;i<video_chunk_pos;i++){
 733               int id=((AVIINDEXENTRY *)priv->idx)[i].ckid;
 734               if(avi_stream_id(id)==d_video->id) ++priv->skip_video_frames;
 735             }
 736             // requires for correct audio pts calculation (demuxer):
 737             priv->avi_video_pts-=priv->skip_video_frames*(float)sh_video->video.dwScale/(float)sh_video->video.dwRate;
 738             priv->avi_audio_pts=priv->avi_video_pts;
 739             // set index position:
 740             priv->idx_pos_a=priv->idx_pos_v=priv->idx_pos=audio_chunk_pos;
 741           }
 742         } else {
 743             // non-interleaved stream:
 744             priv->idx_pos_a=audio_chunk_pos;
 745             priv->idx_pos_v=video_chunk_pos;
 746             priv->idx_pos=(audio_chunk_pos<video_chunk_pos)?audio_chunk_pos:video_chunk_pos;
 747         }
 748
 749           mp_msg(MSGT_SEEK,MSGL_V,"SEEK: idx=%d  (a:%d v:%d)  v.skip=%d  a.skip=%d/%4.3f  \n",
 750             (int)priv->idx_pos,audio_chunk_pos,video_chunk_pos,
 751             (int)priv->skip_video_frames,skip_audio_bytes,skip_audio_secs);
 752
 753           if(skip_audio_bytes){
 754             demux_read_data(d_audio,NULL,skip_audio_bytes);
 755           }
 756
 757       }
 758         d_video->pts=priv->avi_video_pts; // OSD
 759
 760 }
 761
 762
 763 static void demux_close_avi(demuxer_t *demuxer)
 764 {
 765   avi_priv_t* priv=demuxer->priv;
 766
 767   if(!priv)
 768     return;
 769
 770   if(priv->idx_size > 0)
 771     free(priv->idx);
 772   free(priv);
 773 }
 774
 775
 776 static int demux_avi_control(demuxer_t *demuxer,int cmd, void *arg){
 777     avi_priv_t *priv=demuxer->priv;
 778     demux_stream_t *d_video=demuxer->video;
 779     sh_video_t *sh_video=d_video->sh;
 780
 781     switch(cmd) {
 782         case DEMUXER_CTRL_GET_TIME_LENGTH:
 783             if (!priv->numberofframes || !sh_video) return DEMUXER_CTRL_DONTKNOW;
 784             *((double *)arg)=(double)priv->numberofframes/sh_video->fps;
 785             if (sh_video->video.dwLength<=1) return DEMUXER_CTRL_GUESS;
 786             return DEMUXER_CTRL_OK;
 787
 788         case DEMUXER_CTRL_GET_PERCENT_POS:
 789             if (!priv->numberofframes || !sh_video) {
 790               return DEMUXER_CTRL_DONTKNOW;
 791             }
 792             *((int *)arg)=(int)(priv->video_pack_no*100/priv->numberofframes);
 793             if (sh_video->video.dwLength<=1) return DEMUXER_CTRL_GUESS;
 794             return DEMUXER_CTRL_OK;
 795
 796         case DEMUXER_CTRL_SWITCH_AUDIO:
 797         case DEMUXER_CTRL_SWITCH_VIDEO: {
 798             int audio = (cmd == DEMUXER_CTRL_SWITCH_AUDIO);
 799             demux_stream_t *ds = audio ? demuxer->audio : demuxer->video;
 800             void **streams = audio ? demuxer->a_streams : demuxer->v_streams;
 801             int maxid = FFMIN(100, audio ? MAX_A_STREAMS : MAX_V_STREAMS);
 802             int chunkid;
 803             if (ds->id < -1)
 804               ds->id = -1;
 805
 806             if (*(int *)arg >= 0)
 807               ds->id = *(int *)arg;
 808             else {
 809               int i;
 810               for (i = 0; i < maxid; i++) {
 811                 if (++ds->id >= maxid) ds->id = 0;
 812                 if (streams[ds->id]) break;
 813               }
 814             }
 815
 816             chunkid = (ds->id / 10 + '0') | (ds->id % 10 + '0') << 8;
 817             ds->sh = NULL;
 818             if (!streams[ds->id]) // stream not available
 819               ds->id = -1;
 820             else
 821               demux_avi_select_stream(demuxer, chunkid);
 822             *(int *)arg = ds->id;
 823             return DEMUXER_CTRL_OK;
 824         }
 825
 826         default:
 827             return DEMUXER_CTRL_NOTIMPL;
 828     }
 829 }
 830
 831
 832 static int avi_check_file(demuxer_t *demuxer)
 833 {
 834   int id=stream_read_dword_le(demuxer->stream); // "RIFF"
 835
 836   if((id==mmioFOURCC('R','I','F','F')) || (id==mmioFOURCC('O','N','2',' '))) {
 837     stream_read_dword_le(demuxer->stream); //filesize
 838     id=stream_read_dword_le(demuxer->stream); // "AVI "
 839     if(id==formtypeAVI)
 840       return DEMUXER_TYPE_AVI;
 841     // "Samsung Digimax i6 PMP" crap according to bug 742
 842     if(id==mmioFOURCC('A','V','I',0x19))
 843       return DEMUXER_TYPE_AVI;
 844     if(id==mmioFOURCC('O','N','2','f')){
 845       mp_msg(MSGT_DEMUXER,MSGL_INFO,MSGTR_ON2AviFormat);
 846       return DEMUXER_TYPE_AVI;
 847     }
 848   }
 849
 850   return 0;
 851 }
 852
 853
 854 static demuxer_t* demux_open_hack_avi(demuxer_t *demuxer)
 855 {
 856    sh_audio_t* sh_a;
 857
 858    demuxer = demux_open_avi(demuxer);
 859    if(!demuxer) return NULL; // failed to open
 860    sh_a = demuxer->audio->sh;
 861    if(demuxer->audio->id != -2 && sh_a) {
 862 #ifdef CONFIG_OGGVORBIS
 863     // support for Ogg-in-AVI:
 864     if(sh_a->format == 0xFFFE)
 865       demuxer = init_avi_with_ogg(demuxer);
 866     else if(sh_a->format == 0x674F) {
 867       stream_t* s;
 868       demuxer_t  *od;
 869       s = new_ds_stream(demuxer->audio);
 870       od = new_demuxer(s,DEMUXER_TYPE_OGG,-1,-2,-2,NULL);
 871       if(!demux_ogg_open(od)) {
 872         mp_msg( MSGT_DEMUXER,MSGL_ERR,MSGTR_ErrorOpeningOGGDemuxer);
 873         free_stream(s);
 874         demuxer->audio->id = -2;
 875       } else
 876         demuxer = new_demuxers_demuxer(demuxer,od,demuxer);
 877    }
 878 #endif
 879    }
 880
 881    return demuxer;
 882 }
 883
 884
 885 const demuxer_desc_t demuxer_desc_avi = {
 886   "AVI demuxer",
 887   "avi",
 888   "AVI",
 889   "Arpi?",
 890   "AVI files, including non interleaved files",
 891   DEMUXER_TYPE_AVI,
 892   1, // safe autodetect
 893   avi_check_file,
 894   demux_avi_fill_buffer,
 895   demux_open_hack_avi,
 896   demux_close_avi,
 897   demux_seek_avi,
 898   demux_avi_control
 899 };
 900
 901 const demuxer_desc_t demuxer_desc_avi_ni = {
 902   "AVI demuxer, non-interleaved",
 903   "avini",
 904   "AVI",
 905   "Arpi?",
 906   "AVI files, including non interleaved files",
 907   DEMUXER_TYPE_AVI,
 908   1, // safe autodetect
 909   avi_check_file,
 910   demux_avi_fill_buffer_ni,
 911   demux_open_hack_avi,
 912   demux_close_avi,
 913   demux_seek_avi,
 914   demux_avi_control
 915 };
 916
 917 const demuxer_desc_t demuxer_desc_avi_nini = {
 918   "AVI demuxer, non-interleaved and no index",
 919   "avinini",
 920   "AVI",
 921   "Arpi?",
 922   "AVI files, including non interleaved files",
 923   DEMUXER_TYPE_AVI,
 924   1, // safe autodetect
 925   avi_check_file,
 926   demux_avi_fill_buffer_nini,
 927   demux_open_hack_avi,
 928   demux_close_avi,
 929   demux_seek_avi,
 930   demux_avi_control
 931 };