git.sesse.net Git - vlc/blob - modules/demux/avi/avi.c

   1 /*****************************************************************************
   2  * avi.c : AVI file Stream input module for vlc
   3  *****************************************************************************
   4  * Copyright (C) 2001-2004 VideoLAN
   5  * $Id$
   6  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  21  *****************************************************************************/
  22
  23 /*****************************************************************************
  24  * Preamble
  25  *****************************************************************************/
  26 #include <stdlib.h>                                      /* malloc(), free() */
  27
  28 #include <vlc/vlc.h>
  29 #include <vlc/input.h>
  30
  31 #include "vlc_meta.h"
  32 #include "codecs.h"
  33
  34 #include "libavi.h"
  35
  36 /*****************************************************************************
  37  * Module descriptor
  38  *****************************************************************************/
  39
  40 #define INTERLEAVE_TEXT N_("Force interleaved method" )
  41 #define INTERLEAVE_LONGTEXT N_( "Force interleaved method" )
  42
  43 #define INDEX_TEXT N_("Force index creation")
  44 #define INDEX_LONGTEXT N_( \
  45     "Recreate a index for the AVI file so we can seek trough it more reliably." )
  46
  47 static int  Open ( vlc_object_t * );
  48 static void Close( vlc_object_t * );
  49
  50 vlc_module_begin();
  51     set_description( _("AVI demuxer") );
  52     set_capability( "demux2", 212 );
  53
  54     add_bool( "avi-interleaved", 0, NULL,
  55               INTERLEAVE_TEXT, INTERLEAVE_LONGTEXT, VLC_TRUE );
  56     add_bool( "avi-index", 0, NULL,
  57               INDEX_TEXT, INDEX_LONGTEXT, VLC_TRUE );
  58
  59     set_callbacks( Open, Close );
  60 vlc_module_end();
  61
  62 /*****************************************************************************
  63  * Local prototypes
  64  *****************************************************************************/
  65 static int Control         ( demux_t *, int, va_list );
  66 static int Seek            ( demux_t *, mtime_t, int );
  67 static int Demux_Seekable  ( demux_t * );
  68 static int Demux_UnSeekable( demux_t * );
  69
  70 #define FREE( p ) if( p ) { free( p ); (p) = NULL; }
  71 #define __ABS( x ) ( (x) < 0 ? (-(x)) : (x) )
  72
  73 typedef struct
  74 {
  75     vlc_fourcc_t i_fourcc;
  76     off_t        i_pos;
  77     uint32_t     i_size;
  78     vlc_fourcc_t i_type;     /* only for AVIFOURCC_LIST */
  79
  80     uint8_t      i_peek[8];  /* first 8 bytes */
  81
  82     unsigned int i_stream;
  83     unsigned int i_cat;
  84 } avi_packet_t;
  85
  86
  87 typedef struct
  88 {
  89     vlc_fourcc_t i_id;
  90     uint32_t     i_flags;
  91     off_t        i_pos;
  92     uint32_t     i_length;
  93     uint32_t     i_lengthtotal;
  94
  95 } avi_entry_t;
  96
  97 typedef struct
  98 {
  99     vlc_bool_t      b_activated;
 100
 101     unsigned int    i_cat; /* AUDIO_ES, VIDEO_ES */
 102     vlc_fourcc_t    i_codec;
 103
 104     int             i_rate;
 105     int             i_scale;
 106     int             i_samplesize;
 107
 108     es_out_id_t     *p_es;
 109
 110     avi_entry_t     *p_index;
 111     unsigned int        i_idxnb;
 112     unsigned int        i_idxmax;
 113
 114     unsigned int        i_idxposc;  /* numero of chunk */
 115     unsigned int        i_idxposb;  /* byte in the current chunk */
 116
 117     /* For VBR audio only */
 118     unsigned int        i_blockno;
 119     unsigned int        i_blocksize;
 120 } avi_track_t;
 121
 122 struct demux_sys_t
 123 {
 124     mtime_t i_time;
 125     mtime_t i_length;
 126
 127     vlc_bool_t  b_seekable;
 128     avi_chunk_t ck_root;
 129
 130     vlc_bool_t  b_odml;
 131
 132     off_t   i_movi_begin;
 133     off_t   i_movi_lastchunk_pos;   /* XXX position of last valid chunk */
 134
 135     /* number of streams and information */
 136     unsigned int i_track;
 137     avi_track_t  **track;
 138
 139     /* meta */
 140     vlc_meta_t  *meta;
 141 };
 142
 143 static inline off_t __EVEN( off_t i )
 144 {
 145     return (i & 1) ? i + 1 : i;
 146 }
 147
 148 static mtime_t AVI_PTSToChunk( avi_track_t *, mtime_t i_pts );
 149 static mtime_t AVI_PTSToByte ( avi_track_t *, mtime_t i_pts );
 150 static mtime_t AVI_GetDPTS   ( avi_track_t *, int64_t i_count );
 151 static mtime_t AVI_GetPTS    ( avi_track_t * );
 152
 153
 154 static int AVI_StreamChunkFind( demux_t *, unsigned int i_stream );
 155 static int AVI_StreamChunkSet ( demux_t *,
 156                                 unsigned int i_stream, unsigned int i_ck );
 157 static int AVI_StreamBytesSet ( demux_t *,
 158                                 unsigned int i_stream, off_t   i_byte );
 159
 160 vlc_fourcc_t AVI_FourccGetCodec( unsigned int i_cat, vlc_fourcc_t );
 161 static int   AVI_GetKeyFlag    ( vlc_fourcc_t , uint8_t * );
 162
 163 static int AVI_PacketGetHeader( demux_t *, avi_packet_t *p_pk );
 164 static int AVI_PacketNext     ( demux_t * );
 165 static int AVI_PacketRead     ( demux_t *, avi_packet_t *, block_t **);
 166 static int AVI_PacketSearch   ( demux_t * );
 167
 168 static void AVI_IndexLoad    ( demux_t * );
 169 static void AVI_IndexCreate  ( demux_t * );
 170 static void AVI_IndexAddEntry( demux_sys_t *, int, avi_entry_t * );
 171
 172 static mtime_t  AVI_MovieGetLength( demux_t * );
 173
 174 /*****************************************************************************
 175  * Stream management
 176  *****************************************************************************/
 177 static int        AVI_TrackSeek  ( demux_t *, int, mtime_t );
 178 static int        AVI_TrackStopFinishedStreams( demux_t *);
 179
 180 /* Remarks:
 181  - For VBR mp3 stream:
 182     count blocks by rounded-up chunksizes instead of chunks
 183     we need full emulation of dshow avi demuxer bugs :(
 184     fixes silly nandub-style a-v delaying in avi with vbr mp3...
 185     (from mplayer 2002/08/02)
 186  - to complete....
 187  */
 188
 189 /*****************************************************************************
 190  * Open: check file and initializes AVI structures
 191  *****************************************************************************/
 192 static int Open( vlc_object_t * p_this )
 193 {
 194     demux_t  *p_demux = (demux_t *)p_this;
 195     demux_sys_t     *p_sys;
 196
 197     avi_chunk_t         ck_riff;
 198     avi_chunk_list_t    *p_riff = (avi_chunk_list_t*)&ck_riff;
 199     avi_chunk_list_t    *p_hdrl, *p_movi;
 200     avi_chunk_avih_t    *p_avih;
 201
 202     unsigned int i_track;
 203     unsigned int i, i_peeker;
 204
 205     uint8_t  *p_peek;
 206
 207
 208     /* Is it an avi file ? */
 209     if( stream_Peek( p_demux->s, &p_peek, 200 ) < 200 )
 210     {
 211         msg_Err( p_demux, "cannot peek()" );
 212         return VLC_EGENERIC;
 213     }
 214     for( i_peeker = 0; i_peeker < 188; i_peeker++ )
 215     {
 216         if( !strncmp( &p_peek[0], "RIFF", 4 ) && !strncmp( &p_peek[8], "AVI ", 4 ) )
 217         {
 218             break;
 219         }
 220         p_peek++;
 221     }
 222     if( i_peeker == 188 )
 223     {
 224         msg_Warn( p_demux, "avi module discarded (invalid header)" );
 225         return VLC_EGENERIC;
 226     }
 227
 228     /* Initialize input  structures. */
 229     p_sys = p_demux->p_sys = malloc( sizeof(demux_sys_t) );
 230     memset( p_sys, 0, sizeof( demux_sys_t ) );
 231     p_sys->i_time   = 0;
 232     p_sys->i_length = 0;
 233     p_sys->i_movi_lastchunk_pos = 0;
 234     p_sys->b_odml   = VLC_FALSE;
 235     p_sys->i_track  = 0;
 236     p_sys->track    = NULL;
 237     p_sys->meta     = NULL;
 238
 239     stream_Control( p_demux->s, STREAM_CAN_FASTSEEK, &p_sys->b_seekable );
 240
 241     p_demux->pf_control = Control;
 242     p_demux->pf_demux = Demux_Seekable;
 243     /* For unseekable stream, automaticaly use Demux_UnSeekable */
 244     if( !p_sys->b_seekable || config_GetInt( p_demux, "avi-interleaved" ) )
 245     {
 246         p_demux->pf_demux = Demux_UnSeekable;
 247     }
 248
 249     if( i_peeker > 0 )
 250     {
 251         stream_Read( p_demux->s, NULL, i_peeker );
 252     }
 253
 254     if( AVI_ChunkReadRoot( p_demux->s, &p_sys->ck_root ) )
 255     {
 256         msg_Err( p_demux, "avi module discarded (invalid file)" );
 257         return VLC_EGENERIC;
 258     }
 259
 260     if( AVI_ChunkCount( &p_sys->ck_root, AVIFOURCC_RIFF ) > 1 )
 261     {
 262         unsigned int i_count =
 263             AVI_ChunkCount( &p_sys->ck_root, AVIFOURCC_RIFF );
 264
 265         msg_Warn( p_demux, "multiple riff -> OpenDML ?" );
 266         for( i = 1; i < i_count; i++ )
 267         {
 268             avi_chunk_list_t *p_sysx;
 269
 270             p_sysx = AVI_ChunkFind( &p_sys->ck_root, AVIFOURCC_RIFF, i );
 271             if( p_sysx->i_type == AVIFOURCC_AVIX )
 272             {
 273                 msg_Warn( p_demux, "detected OpenDML file" );
 274                 p_sys->b_odml = VLC_TRUE;
 275                 break;
 276             }
 277         }
 278     }
 279
 280     p_riff  = AVI_ChunkFind( &p_sys->ck_root, AVIFOURCC_RIFF, 0 );
 281     p_hdrl  = AVI_ChunkFind( p_riff, AVIFOURCC_hdrl, 0 );
 282     p_movi  = AVI_ChunkFind( p_riff, AVIFOURCC_movi, 0 );
 283
 284     if( !p_hdrl || !p_movi )
 285     {
 286         msg_Err( p_demux, "avi module discarded (invalid file)" );
 287         goto error;
 288     }
 289
 290     if( !( p_avih = AVI_ChunkFind( p_hdrl, AVIFOURCC_avih, 0 ) ) )
 291     {
 292         msg_Err( p_demux, "cannot find avih chunk" );
 293         goto error;
 294     }
 295     i_track = AVI_ChunkCount( p_hdrl, AVIFOURCC_strl );
 296     if( p_avih->i_streams != i_track )
 297     {
 298         msg_Warn( p_demux,
 299                   "found %d stream but %d are declared",
 300                   i_track, p_avih->i_streams );
 301     }
 302     if( i_track == 0 )
 303     {
 304         msg_Err( p_demux, "no stream defined!" );
 305         goto error;
 306     }
 307
 308     /* print information on streams */
 309     msg_Dbg( p_demux, "AVIH: %d stream, flags %s%s%s%s ",
 310              i_track,
 311              p_avih->i_flags&AVIF_HASINDEX?" HAS_INDEX":"",
 312              p_avih->i_flags&AVIF_MUSTUSEINDEX?" MUST_USE_INDEX":"",
 313              p_avih->i_flags&AVIF_ISINTERLEAVED?" IS_INTERLEAVED":"",
 314              p_avih->i_flags&AVIF_TRUSTCKTYPE?" TRUST_CKTYPE":"" );
 315     if( ( p_sys->meta = vlc_meta_New() ) )
 316     {
 317         char buffer[200];
 318         sprintf( buffer, "%s%s%s%s",
 319                  p_avih->i_flags&AVIF_HASINDEX?" HAS_INDEX":"",
 320                  p_avih->i_flags&AVIF_MUSTUSEINDEX?" MUST_USE_INDEX":"",
 321                  p_avih->i_flags&AVIF_ISINTERLEAVED?" IS_INTERLEAVED":"",
 322                  p_avih->i_flags&AVIF_TRUSTCKTYPE?" TRUST_CKTYPE":"" );
 323         vlc_meta_Add( p_sys->meta, VLC_META_SETTING, buffer );
 324     }
 325
 326     /* now read info on each stream and create ES */
 327     for( i = 0 ; i < i_track; i++ )
 328     {
 329         avi_track_t      *tk = malloc( sizeof( avi_track_t ) );
 330         avi_chunk_list_t *p_strl = AVI_ChunkFind( p_hdrl, AVIFOURCC_strl, i );
 331         avi_chunk_strh_t *p_strh = AVI_ChunkFind( p_strl, AVIFOURCC_strh, 0 );
 332         avi_chunk_strf_auds_t *p_auds;
 333         avi_chunk_strf_vids_t *p_vids;
 334         es_format_t fmt;
 335
 336         tk->b_activated = VLC_FALSE;
 337         tk->p_index     = 0;
 338         tk->i_idxnb     = 0;
 339         tk->i_idxmax    = 0;
 340         tk->i_idxposc   = 0;
 341         tk->i_idxposb   = 0;
 342
 343         tk->i_blockno   = 0;
 344         tk->i_blocksize = 0;
 345
 346         p_vids = (avi_chunk_strf_vids_t*)AVI_ChunkFind( p_strl, AVIFOURCC_strf, 0 );
 347         p_auds = (avi_chunk_strf_auds_t*)AVI_ChunkFind( p_strl, AVIFOURCC_strf, 0 );
 348
 349         if( p_strl == NULL || p_strh == NULL || p_auds == NULL || p_vids == NULL )
 350         {
 351             msg_Warn( p_demux, "stream[%d] incomplete", i );
 352             continue;
 353         }
 354
 355         tk->i_rate  = p_strh->i_rate;
 356         tk->i_scale = p_strh->i_scale;
 357         tk->i_samplesize = p_strh->i_samplesize;
 358         msg_Dbg( p_demux, "stream[%d] rate:%d scale:%d samplesize:%d",
 359                  i, tk->i_rate, tk->i_scale, tk->i_samplesize );
 360
 361         switch( p_strh->i_type )
 362         {
 363             case( AVIFOURCC_auds ):
 364                 tk->i_cat   = AUDIO_ES;
 365                 tk->i_codec = AVI_FourccGetCodec( AUDIO_ES,
 366                                                   p_auds->p_wf->wFormatTag );
 367                 if( ( tk->i_blocksize = p_auds->p_wf->nBlockAlign ) == 0 )
 368                 {
 369                     if( p_auds->p_wf->wFormatTag == 1 )
 370                     {
 371                         tk->i_blocksize = p_auds->p_wf->nChannels * (p_auds->p_wf->wBitsPerSample/8);
 372                     }
 373                     else
 374                     {
 375                         tk->i_blocksize = 1;
 376                     }
 377                 }
 378                 es_format_Init( &fmt, AUDIO_ES, tk->i_codec );
 379
 380                 fmt.audio.i_channels        = p_auds->p_wf->nChannels;
 381                 fmt.audio.i_rate            = p_auds->p_wf->nSamplesPerSec;
 382                 fmt.i_bitrate               = p_auds->p_wf->nAvgBytesPerSec*8;
 383                 fmt.audio.i_blockalign      = p_auds->p_wf->nBlockAlign;
 384                 fmt.audio.i_bitspersample   = p_auds->p_wf->wBitsPerSample;
 385                 fmt.i_extra = __MIN( p_auds->p_wf->cbSize,
 386                     p_auds->i_chunk_size - sizeof(WAVEFORMATEX) );
 387                 fmt.p_extra = &p_auds->p_wf[1];
 388                 msg_Dbg( p_demux, "stream[%d] audio(0x%x) %d channels %dHz %dbits",
 389                          i, p_auds->p_wf->wFormatTag, p_auds->p_wf->nChannels,
 390                          p_auds->p_wf->nSamplesPerSec, p_auds->p_wf->wBitsPerSample);
 391                 break;
 392
 393             case( AVIFOURCC_vids ):
 394                 tk->i_cat   = VIDEO_ES;
 395                 tk->i_codec = AVI_FourccGetCodec( VIDEO_ES,
 396                                                   p_vids->p_bih->biCompression );
 397                 if( p_vids->p_bih->biCompression == 0x00 )
 398                 {
 399                     switch( p_vids->p_bih->biBitCount )
 400                     {
 401                         case 32:
 402                             tk->i_codec = VLC_FOURCC('R','V','3','2');
 403                             break;
 404                         case 24:
 405                             tk->i_codec = VLC_FOURCC('R','V','2','4');
 406                             break;
 407                         case 16:
 408                             /* tk->i_codec = VLC_FOURCC('R','V','1','6');*/
 409                             /* break;*/
 410                         case 15:
 411                             tk->i_codec = VLC_FOURCC('R','V','1','5');
 412                             break;
 413                         case 9:
 414                             tk->i_codec = VLC_FOURCC( 'Y', 'V', 'U', '9' ); /* <- TODO check that */
 415                             break;
 416                     }
 417                     es_format_Init( &fmt, VIDEO_ES, tk->i_codec );
 418                 }
 419                 else
 420                 {
 421                     es_format_Init( &fmt, VIDEO_ES, p_vids->p_bih->biCompression );
 422                     if( tk->i_codec == FOURCC_mp4v && !strncasecmp( (char*)&p_strh->i_handler, "XVID", 4 ) )
 423                     {
 424                         fmt.i_codec = VLC_FOURCC( 'X', 'V', 'I', 'D' );
 425                     }
 426                 }
 427                 tk->i_samplesize = 0;
 428                 fmt.video.i_width  = p_vids->p_bih->biWidth;
 429                 fmt.video.i_height = p_vids->p_bih->biHeight;
 430                 fmt.video.i_bits_per_pixel = p_vids->p_bih->biBitCount;
 431                 fmt.i_extra =
 432                     __MIN( p_vids->p_bih->biSize - sizeof( BITMAPINFOHEADER ),
 433                            p_vids->i_chunk_size - sizeof(BITMAPINFOHEADER) );
 434                 fmt.p_extra = &p_vids->p_bih[1];
 435                 msg_Dbg( p_demux, "stream[%d] video(%4.4s) %dx%d %dbpp %ffps",
 436                         i,
 437                          (char*)&p_vids->p_bih->biCompression,
 438                          p_vids->p_bih->biWidth,
 439                          p_vids->p_bih->biHeight,
 440                          p_vids->p_bih->biBitCount,
 441                          (float)tk->i_rate/(float)tk->i_scale );
 442                 break;
 443             default:
 444                 msg_Warn( p_demux, "stream[%d] unknown type", i );
 445                 free( tk );
 446                 continue;
 447         }
 448         tk->p_es = es_out_Add( p_demux->out, &fmt );
 449         TAB_APPEND( p_sys->i_track, p_sys->track, tk );
 450     }
 451
 452     if( p_sys->i_track <= 0 )
 453     {
 454         msg_Err( p_demux, "no valid track" );
 455         goto error;
 456     }
 457
 458     if( config_GetInt( p_demux, "avi-index" ) )
 459     {
 460         if( p_sys->b_seekable )
 461         {
 462             AVI_IndexCreate( p_demux );
 463         }
 464         else
 465         {
 466             msg_Warn( p_demux, "cannot create index (unseekable stream)" );
 467             AVI_IndexLoad( p_demux );
 468         }
 469     }
 470     else
 471     {
 472         AVI_IndexLoad( p_demux );
 473     }
 474
 475     /* *** movie length in sec *** */
 476     p_sys->i_length = AVI_MovieGetLength( p_demux );
 477     if( p_sys->i_length < (mtime_t)p_avih->i_totalframes *
 478                           (mtime_t)p_avih->i_microsecperframe /
 479                           (mtime_t)1000000 )
 480     {
 481         msg_Warn( p_demux, "broken or missing index, 'seek' will be axproximative or will have strange behavour" );
 482     }
 483     /* fix some BeOS MediaKit generated file */
 484     for( i = 0 ; i < p_sys->i_track; i++ )
 485     {
 486         avi_track_t         *tk = p_sys->track[i];
 487         avi_chunk_list_t    *p_strl;
 488         avi_chunk_strh_t    *p_strh;
 489         avi_chunk_strf_auds_t    *p_auds;
 490
 491         if( tk->i_cat != AUDIO_ES )
 492         {
 493             continue;
 494         }
 495         if( tk->i_idxnb < 1 ||
 496             tk->i_scale != 1 ||
 497             tk->i_samplesize != 0 )
 498         {
 499             continue;
 500         }
 501         p_strl = AVI_ChunkFind( p_hdrl, AVIFOURCC_strl, i );
 502         p_strh = AVI_ChunkFind( p_strl, AVIFOURCC_strh, 0 );
 503         p_auds = AVI_ChunkFind( p_strl, AVIFOURCC_strf, 0 );
 504
 505         if( p_auds->p_wf->wFormatTag != WAVE_FORMAT_PCM &&
 506             (unsigned int)tk->i_rate == p_auds->p_wf->nSamplesPerSec )
 507         {
 508             int64_t i_track_length =
 509                 tk->p_index[tk->i_idxnb-1].i_length +
 510                 tk->p_index[tk->i_idxnb-1].i_lengthtotal;
 511             mtime_t i_length = (mtime_t)p_avih->i_totalframes *
 512                                (mtime_t)p_avih->i_microsecperframe;
 513
 514             if( i_length == 0 )
 515             {
 516                 msg_Warn( p_demux, "track[%d] cannot be fixed (BeOS MediaKit generated)", i );
 517                 continue;
 518             }
 519             tk->i_samplesize = 1;
 520             tk->i_rate       = i_track_length  * (int64_t)1000000/ i_length;
 521             msg_Warn( p_demux, "track[%d] fixed with rate=%d scale=%d (BeOS MediaKit generated)", i, tk->i_rate, tk->i_scale );
 522         }
 523     }
 524
 525     if( p_sys->b_seekable )
 526     {
 527         /* we have read all chunk so go back to movi */
 528         stream_Seek( p_demux->s, p_movi->i_chunk_pos );
 529     }
 530     /* Skip movi header */
 531     stream_Read( p_demux->s, NULL, 12 );
 532
 533     p_sys->i_movi_begin = p_movi->i_chunk_pos;
 534     return VLC_SUCCESS;
 535
 536 error:
 537     if( p_sys->meta )
 538     {
 539         vlc_meta_Delete( p_sys->meta );
 540     }
 541     AVI_ChunkFreeRoot( p_demux->s, &p_sys->ck_root );
 542     free( p_sys );
 543     return VLC_EGENERIC;
 544 }
 545
 546 /*****************************************************************************
 547  * Close: frees unused data
 548  *****************************************************************************/
 549 static void Close ( vlc_object_t * p_this )
 550 {
 551     demux_t *    p_demux = (demux_t *)p_this;
 552     unsigned int i;
 553     demux_sys_t *p_sys = p_demux->p_sys  ;
 554
 555     for( i = 0; i < p_sys->i_track; i++ )
 556     {
 557         if( p_sys->track[i] )
 558         {
 559             FREE( p_sys->track[i]->p_index );
 560             free( p_sys->track[i] );
 561         }
 562     }
 563     FREE( p_sys->track );
 564     AVI_ChunkFreeRoot( p_demux->s, &p_sys->ck_root );
 565     vlc_meta_Delete( p_sys->meta );
 566
 567     free( p_sys );
 568 }
 569
 570 /*****************************************************************************
 571  * Demux_Seekable: reads and demuxes data packets for stream seekable
 572  *****************************************************************************
 573  * AVIDemux: reads and demuxes data packets
 574  *****************************************************************************
 575  * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
 576  *****************************************************************************/
 577 typedef struct
 578 {
 579     vlc_bool_t b_ok;
 580
 581     int i_toread;
 582
 583     off_t i_posf; /* where we will read :
 584                    if i_idxposb == 0 : begining of chunk (+8 to acces data)
 585                    else : point on data directly */
 586 } avi_track_toread_t;
 587
 588 static int Demux_Seekable( demux_t *p_demux )
 589 {
 590     demux_sys_t *p_sys = p_demux->p_sys;
 591
 592     unsigned int i_track_count = 0;
 593     unsigned int i_track;
 594     vlc_bool_t b_stream;
 595     /* cannot be more than 100 stream (dcXX or wbXX) */
 596     avi_track_toread_t toread[100];
 597
 598
 599     /* detect new selected/unselected streams */
 600     for( i_track = 0; i_track < p_sys->i_track; i_track++ )
 601     {
 602         avi_track_t *tk = p_sys->track[i_track];
 603         vlc_bool_t  b;
 604
 605         es_out_Control( p_demux->out, ES_OUT_GET_ES_STATE, tk->p_es, &b );
 606         if( b && !tk->b_activated )
 607         {
 608             if( p_sys->b_seekable)
 609             {
 610                 AVI_TrackSeek( p_demux, i_track, p_sys->i_time );
 611             }
 612             tk->b_activated = VLC_TRUE;
 613         }
 614         else if( !b && tk->b_activated )
 615         {
 616             tk->b_activated = VLC_FALSE;
 617         }
 618         if( b )
 619         {
 620             i_track_count++;
 621         }
 622     }
 623
 624     if( i_track_count <= 0 )
 625     {
 626         int64_t i_length = p_sys->i_length * (mtime_t)1000000;
 627
 628         p_sys->i_time += 25*1000;  /* read 25ms */
 629         if( i_length > 0 )
 630         {
 631             if( p_sys->i_time >= i_length )
 632                 return 0;
 633             return 1;
 634         }
 635         msg_Warn( p_demux, "no track selected, exiting..." );
 636         return 0;
 637     }
 638
 639     /* wait for the good time */
 640     es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_time + 1 );
 641     p_sys->i_time += 25*1000;  /* read 25ms */
 642
 643     /* init toread */
 644     for( i_track = 0; i_track < p_sys->i_track; i_track++ )
 645     {
 646         avi_track_t *tk = p_sys->track[i_track];
 647         mtime_t i_dpts;
 648
 649         toread[i_track].b_ok = tk->b_activated;
 650         if( tk->i_idxposc < tk->i_idxnb )
 651         {
 652             toread[i_track].i_posf = tk->p_index[tk->i_idxposc].i_pos;
 653            if( tk->i_idxposb > 0 )
 654            {
 655                 toread[i_track].i_posf += 8 + tk->i_idxposb;
 656            }
 657         }
 658         else
 659         {
 660             toread[i_track].i_posf = -1;
 661         }
 662
 663         i_dpts = p_sys->i_time - AVI_GetPTS( tk  );
 664
 665         if( tk->i_samplesize )
 666         {
 667             toread[i_track].i_toread = AVI_PTSToByte( tk, __ABS( i_dpts ) );
 668         }
 669         else
 670         {
 671             toread[i_track].i_toread = AVI_PTSToChunk( tk, __ABS( i_dpts ) );
 672         }
 673
 674         if( i_dpts < 0 )
 675         {
 676             toread[i_track].i_toread *= -1;
 677         }
 678     }
 679
 680     b_stream = VLC_FALSE;
 681
 682     for( ;; )
 683     {
 684         avi_track_t     *tk;
 685         vlc_bool_t       b_done;
 686         block_t         *p_frame;
 687         off_t i_pos;
 688         unsigned int i;
 689         size_t i_size;
 690
 691         /* search for first chunk to be read */
 692         for( i = 0, b_done = VLC_TRUE, i_pos = -1; i < p_sys->i_track; i++ )
 693         {
 694             if( !toread[i].b_ok ||
 695                 AVI_GetDPTS( p_sys->track[i],
 696                              toread[i].i_toread ) <= -25 * 1000 )
 697             {
 698                 continue;
 699             }
 700
 701             if( toread[i].i_toread > 0 )
 702             {
 703                 b_done = VLC_FALSE; /* not yet finished */
 704             }
 705             if( toread[i].i_posf > 0 )
 706             {
 707                 if( i_pos == -1 || i_pos > toread[i_track].i_posf )
 708                 {
 709                     i_track = i;
 710                     i_pos = toread[i].i_posf;
 711                 }
 712             }
 713         }
 714
 715         if( b_done )
 716         {
 717             return( 1 );
 718         }
 719
 720         if( i_pos == -1 )
 721         {
 722             int i_loop_count = 0;
 723
 724             /* no valid index, we will parse directly the stream
 725              * in case we fail we will disable all finished stream */
 726             if( p_sys->i_movi_lastchunk_pos >= p_sys->i_movi_begin + 12 )
 727             {
 728                 stream_Seek( p_demux->s, p_sys->i_movi_lastchunk_pos );
 729                 if( AVI_PacketNext( p_demux ) )
 730                 {
 731                     return( AVI_TrackStopFinishedStreams( p_demux ) ? 0 : 1 );
 732                 }
 733             }
 734             else
 735             {
 736                 stream_Seek( p_demux->s, p_sys->i_movi_begin + 12 );
 737             }
 738
 739             for( ;; )
 740             {
 741                 avi_packet_t avi_pk;
 742
 743                 if( AVI_PacketGetHeader( p_demux, &avi_pk ) )
 744                 {
 745                     msg_Warn( p_demux,
 746                              "cannot get packet header, track disabled" );
 747                     return( AVI_TrackStopFinishedStreams( p_demux ) ? 0 : 1 );
 748                 }
 749                 if( avi_pk.i_stream >= p_sys->i_track ||
 750                     ( avi_pk.i_cat != AUDIO_ES && avi_pk.i_cat != VIDEO_ES ) )
 751                 {
 752                     if( AVI_PacketNext( p_demux ) )
 753                     {
 754                         msg_Warn( p_demux,
 755                                   "cannot skip packet, track disabled" );
 756                         return( AVI_TrackStopFinishedStreams( p_demux ) ? 0 : 1 );
 757                     }
 758
 759                     /* Prevents from eating all the CPU with broken files.
 760                      * This value should be low enough so that it doesn't
 761                      * affect the reading speed too much. */
 762                     if( !(++i_loop_count % 1024) )
 763                     {
 764                         if( p_demux->b_die ) return -1;
 765                         msleep( 10000 );
 766
 767                         if( !(i_loop_count % (1024 * 10)) )
 768                             msg_Warn( p_demux,
 769                                       "don't seem to find any data..." );
 770                     }
 771                     continue;
 772                 }
 773                 else
 774                 {
 775                     /* add this chunk to the index */
 776                     avi_entry_t index;
 777
 778                     index.i_id = avi_pk.i_fourcc;
 779                     index.i_flags =
 780                        AVI_GetKeyFlag(p_sys->track[avi_pk.i_stream]->i_codec,
 781                                       avi_pk.i_peek);
 782                     index.i_pos = avi_pk.i_pos;
 783                     index.i_length = avi_pk.i_size;
 784                     AVI_IndexAddEntry( p_sys, avi_pk.i_stream, &index );
 785
 786                     i_track = avi_pk.i_stream;
 787                     tk = p_sys->track[i_track];
 788                     /* do we will read this data ? */
 789                     if( AVI_GetDPTS( tk, toread[i_track].i_toread ) > -25*1000 )
 790                     {
 791                         break;
 792                     }
 793                     else
 794                     {
 795                         if( AVI_PacketNext( p_demux ) )
 796                         {
 797                             msg_Warn( p_demux,
 798                                       "cannot skip packet, track disabled" );
 799                             return( AVI_TrackStopFinishedStreams( p_demux ) ? 0 : 1 );
 800                         }
 801                     }
 802                 }
 803             }
 804
 805         }
 806         else
 807         {
 808             stream_Seek( p_demux->s, i_pos );
 809         }
 810
 811         /* Set the track to use */
 812         tk = p_sys->track[i_track];
 813
 814         /* read thoses data */
 815         if( tk->i_samplesize )
 816         {
 817             unsigned int i_toread;
 818
 819             if( ( i_toread = toread[i_track].i_toread ) <= 0 )
 820             {
 821                 if( tk->i_samplesize > 1 )
 822                 {
 823                     i_toread = tk->i_samplesize;
 824                 }
 825                 else
 826                 {
 827                     i_toread = __MAX( AVI_PTSToByte( tk, 20 * 1000 ), 100 );
 828                 }
 829             }
 830             i_size = __MIN( tk->p_index[tk->i_idxposc].i_length -
 831                                 tk->i_idxposb,
 832                             i_toread );
 833         }
 834         else
 835         {
 836             i_size = tk->p_index[tk->i_idxposc].i_length;
 837         }
 838
 839         if( tk->i_idxposb == 0 )
 840         {
 841             i_size += 8; /* need to read and skip header */
 842         }
 843
 844         if( ( p_frame = stream_Block( p_demux->s, __EVEN( i_size ) ) )==NULL )
 845         {
 846             msg_Warn( p_demux, "failled reading data" );
 847             tk->b_activated = VLC_FALSE;
 848             toread[i_track].b_ok = VLC_FALSE;
 849             continue;
 850         }
 851         if( i_size % 2 )    /* read was padded on word boundary */
 852         {
 853             p_frame->i_buffer--;
 854         }
 855         /* skip header */
 856         if( tk->i_idxposb == 0 )
 857         {
 858             p_frame->p_buffer += 8;
 859             p_frame->i_buffer -= 8;
 860         }
 861         p_frame->i_pts = AVI_GetPTS( tk ) + 1;
 862         if( tk->p_index[tk->i_idxposc].i_flags&AVIIF_KEYFRAME )
 863         {
 864             p_frame->i_flags = BLOCK_FLAG_TYPE_I;
 865         }
 866         else
 867         {
 868             p_frame->i_flags = BLOCK_FLAG_TYPE_PB;
 869         }
 870
 871         /* read data */
 872         if( tk->i_samplesize )
 873         {
 874             if( tk->i_idxposb == 0 )
 875             {
 876                 i_size -= 8;
 877             }
 878             toread[i_track].i_toread -= i_size;
 879             tk->i_idxposb += i_size;
 880             if( tk->i_idxposb >=
 881                     tk->p_index[tk->i_idxposc].i_length )
 882             {
 883                 tk->i_idxposb = 0;
 884                 tk->i_idxposc++;
 885             }
 886         }
 887         else
 888         {
 889             int i_length = tk->p_index[tk->i_idxposc].i_length;
 890
 891             tk->i_idxposc++;
 892             if( tk->i_cat == AUDIO_ES )
 893             {
 894                 tk->i_blockno += tk->i_blocksize > 0 ? ( i_length + tk->i_blocksize - 1 ) / tk->i_blocksize : 1;
 895             }
 896             toread[i_track].i_toread--;
 897         }
 898
 899         if( tk->i_idxposc < tk->i_idxnb)
 900         {
 901             toread[i_track].i_posf =
 902                 tk->p_index[tk->i_idxposc].i_pos;
 903             if( tk->i_idxposb > 0 )
 904             {
 905                 toread[i_track].i_posf += 8 + tk->i_idxposb;
 906             }
 907
 908         }
 909         else
 910         {
 911             toread[i_track].i_posf = -1;
 912         }
 913
 914         b_stream = VLC_TRUE; /* at least one read succeed */
 915
 916         if( tk->i_cat != VIDEO_ES )
 917             p_frame->i_dts = p_frame->i_pts;
 918         else
 919         {
 920             p_frame->i_dts = p_frame->i_pts;
 921             p_frame->i_pts = 0;
 922         }
 923
 924         //p_pes->i_rate = p_demux->stream.control.i_rate;
 925         es_out_Send( p_demux->out, tk->p_es, p_frame );
 926     }
 927 }
 928
 929
 930 /*****************************************************************************
 931  * Demux_UnSeekable: reads and demuxes data packets for unseekable file
 932  *****************************************************************************
 933  * Returns -1 in case of error, 0 in case of EOF, 1 otherwise
 934  *****************************************************************************/
 935 static int Demux_UnSeekable( demux_t *p_demux )
 936 {
 937     demux_sys_t     *p_sys = p_demux->p_sys;
 938     avi_track_t *p_stream_master = NULL;
 939     unsigned int i_stream;
 940     unsigned int i_packet;
 941
 942     es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_time + 1 );
 943
 944     /* *** find master stream for data packet skipping algo *** */
 945     /* *** -> first video, if any, or first audio ES *** */
 946     for( i_stream = 0; i_stream < p_sys->i_track; i_stream++ )
 947     {
 948         avi_track_t *tk = p_sys->track[i_stream];
 949         vlc_bool_t  b;
 950
 951         es_out_Control( p_demux->out, ES_OUT_GET_ES_STATE, tk->p_es, &b );
 952
 953         if( b && tk->i_cat == VIDEO_ES )
 954         {
 955             p_stream_master = tk;
 956         }
 957         else if( b )
 958         {
 959             p_stream_master = tk;
 960         }
 961     }
 962
 963     if( !p_stream_master )
 964     {
 965         msg_Warn( p_demux, "no more stream selected" );
 966         return( 0 );
 967     }
 968
 969     p_sys->i_time = AVI_GetPTS( p_stream_master );
 970
 971     for( i_packet = 0; i_packet < 10; i_packet++)
 972     {
 973 #define p_stream    p_sys->track[avi_pk.i_stream]
 974
 975         avi_packet_t    avi_pk;
 976
 977         if( AVI_PacketGetHeader( p_demux, &avi_pk ) )
 978         {
 979             return( 0 );
 980         }
 981
 982         if( avi_pk.i_stream >= p_sys->i_track ||
 983             ( avi_pk.i_cat != AUDIO_ES && avi_pk.i_cat != VIDEO_ES ) )
 984         {
 985             /* we haven't found an audio or video packet:
 986              *  - we have seek, found first next packet
 987              *  - others packets could be found, skip them
 988              */
 989             switch( avi_pk.i_fourcc )
 990             {
 991                 case AVIFOURCC_JUNK:
 992                 case AVIFOURCC_LIST:
 993                 case AVIFOURCC_RIFF:
 994                     return( !AVI_PacketNext( p_demux ) ? 1 : 0 );
 995                 case AVIFOURCC_idx1:
 996                     if( p_sys->b_odml )
 997                     {
 998                         return( !AVI_PacketNext( p_demux ) ? 1 : 0 );
 999                     }
1000                     return( 0 );    /* eof */
1001                 default:
1002                     msg_Warn( p_demux,
1003                               "seems to have lost position, resync" );
1004                     if( AVI_PacketSearch( p_demux ) )
1005                     {
1006                         msg_Err( p_demux, "resync failed" );
1007                         return( -1 );
1008                     }
1009             }
1010         }
1011         else
1012         {
1013             /* check for time */
1014             if( __ABS( AVI_GetPTS( p_stream ) -
1015                         AVI_GetPTS( p_stream_master ) )< 600*1000 )
1016             {
1017                 /* load it and send to decoder */
1018                 block_t *p_frame;
1019                 if( AVI_PacketRead( p_demux, &avi_pk, &p_frame ) || p_frame == NULL )
1020                 {
1021                     return( -1 );
1022                 }
1023                 p_frame->i_pts = AVI_GetPTS( p_stream ) + 1;
1024
1025                 if( avi_pk.i_cat != VIDEO_ES )
1026                     p_frame->i_dts = p_frame->i_pts;
1027                 else
1028                 {
1029                     p_frame->i_dts = p_frame->i_pts;
1030                     p_frame->i_pts = 0;
1031                 }
1032
1033                 //p_pes->i_rate = p_demux->stream.control.i_rate;
1034                 es_out_Send( p_demux->out, p_stream->p_es, p_frame );
1035             }
1036             else
1037             {
1038                 if( AVI_PacketNext( p_demux ) )
1039                 {
1040                     return( 0 );
1041                 }
1042             }
1043
1044             /* *** update stream time position *** */
1045             if( p_stream->i_samplesize )
1046             {
1047                 p_stream->i_idxposb += avi_pk.i_size;
1048             }
1049             else
1050             {
1051                 if( p_stream->i_cat == AUDIO_ES )
1052                 {
1053                     p_stream->i_blockno += p_stream->i_blocksize > 0 ? ( avi_pk.i_size + p_stream->i_blocksize - 1 ) / p_stream->i_blocksize : 1;
1054                 }
1055                 p_stream->i_idxposc++;
1056             }
1057
1058         }
1059 #undef p_stream
1060     }
1061
1062     return( 1 );
1063 }
1064
1065 /*****************************************************************************
1066  * Seek: goto to i_date or i_percent
1067  *****************************************************************************/
1068 static int Seek( demux_t *p_demux, mtime_t i_date, int i_percent )
1069 {
1070
1071     demux_sys_t *p_sys = p_demux->p_sys;
1072     unsigned int i_stream;
1073     msg_Dbg( p_demux, "seek requested: "I64Fd" secondes %d%%",
1074              i_date / 1000000, i_percent );
1075
1076     if( p_sys->b_seekable )
1077     {
1078         if( !p_sys->i_length )
1079         {
1080             avi_track_t *p_stream;
1081             int64_t i_pos;
1082
1083             /* use i_percent to create a true i_date */
1084             msg_Warn( p_demux, "mmh, seeking without index at %d%%"
1085                       " work only for interleaved file", i_percent );
1086             if( i_percent >= 100 )
1087             {
1088                 msg_Warn( p_demux, "cannot seek so far !" );
1089                 return VLC_EGENERIC;
1090             }
1091             i_percent = __MAX( i_percent, 0 );
1092
1093             /* try to find chunk that is at i_percent or the file */
1094             i_pos = __MAX( i_percent * stream_Size( p_demux->s ) / 100,
1095                            p_sys->i_movi_begin );
1096             /* search first selected stream */
1097             for( i_stream = 0, p_stream = NULL;
1098                         i_stream < p_sys->i_track; i_stream++ )
1099             {
1100                 p_stream = p_sys->track[i_stream];
1101                 if( p_stream->b_activated )
1102                 {
1103                     break;
1104                 }
1105             }
1106             if( !p_stream || !p_stream->b_activated )
1107             {
1108                 msg_Warn( p_demux, "cannot find any selected stream" );
1109                 return VLC_EGENERIC;
1110             }
1111
1112             /* be sure that the index exist */
1113             if( AVI_StreamChunkSet( p_demux, i_stream, 0 ) )
1114             {
1115                 msg_Warn( p_demux, "cannot seek" );
1116                 return VLC_EGENERIC;
1117             }
1118
1119             while( i_pos >= p_stream->p_index[p_stream->i_idxposc].i_pos +
1120                p_stream->p_index[p_stream->i_idxposc].i_length + 8 )
1121             {
1122                 /* search after i_idxposc */
1123                 if( AVI_StreamChunkSet( p_demux,
1124                                         i_stream, p_stream->i_idxposc + 1 ) )
1125                 {
1126                     msg_Warn( p_demux, "cannot seek" );
1127                     return VLC_EGENERIC;
1128                 }
1129             }
1130
1131             i_date = AVI_GetPTS( p_stream );
1132             /* TODO better support for i_samplesize != 0 */
1133             msg_Dbg( p_demux, "estimate date "I64Fd, i_date );
1134         }
1135
1136 #define p_stream    p_sys->track[i_stream]
1137         p_sys->i_time = 0;
1138         /* seek for chunk based streams */
1139         for( i_stream = 0; i_stream < p_sys->i_track; i_stream++ )
1140         {
1141             if( p_stream->b_activated && !p_stream->i_samplesize )
1142 /*            if( p_stream->b_activated ) */
1143             {
1144                 AVI_TrackSeek( p_demux, i_stream, i_date );
1145                 p_sys->i_time = __MAX( AVI_GetPTS( p_stream ),
1146                                         p_sys->i_time );
1147             }
1148         }
1149 #if 1
1150         if( p_sys->i_time )
1151         {
1152             i_date = p_sys->i_time;
1153         }
1154         /* seek for bytes based streams */
1155         for( i_stream = 0; i_stream < p_sys->i_track; i_stream++ )
1156         {
1157             if( p_stream->b_activated && p_stream->i_samplesize )
1158             {
1159                 AVI_TrackSeek( p_demux, i_stream, i_date );
1160 /*                p_sys->i_time = __MAX( AVI_GetPTS( p_stream ), p_sys->i_time );*/
1161             }
1162         }
1163         msg_Dbg( p_demux, "seek: "I64Fd" seconds", p_sys->i_time /1000000 );
1164         /* set true movie time */
1165 #endif
1166         if( !p_sys->i_time )
1167         {
1168             p_sys->i_time = i_date;
1169         }
1170 #undef p_stream
1171         return VLC_SUCCESS;
1172     }
1173     else
1174     {
1175         msg_Err( p_demux, "shouldn't yet be executed" );
1176         return VLC_EGENERIC;
1177     }
1178 }
1179
1180 /*****************************************************************************
1181  * Control:
1182  *****************************************************************************
1183  *
1184  *****************************************************************************/
1185 static double ControlGetPosition( demux_t *p_demux )
1186 {
1187     demux_sys_t *p_sys = p_demux->p_sys;
1188
1189     if( p_sys->i_length > 0 )
1190     {
1191         return (double)p_sys->i_time / (double)( p_sys->i_length * (mtime_t)1000000 );
1192     }
1193     else if( stream_Size( p_demux->s ) > 0 )
1194     {
1195         unsigned int i;
1196         int64_t i_tmp;
1197         int64_t i64 = 0;
1198
1199         /* search the more advanced selected es */
1200         for( i = 0; i < p_sys->i_track; i++ )
1201         {
1202             avi_track_t *tk = p_sys->track[i];
1203             if( tk->b_activated && tk->i_idxposc < tk->i_idxnb )
1204             {
1205                 i_tmp = tk->p_index[tk->i_idxposc].i_pos +
1206                         tk->p_index[tk->i_idxposc].i_length + 8;
1207                 if( i_tmp > i64 )
1208                 {
1209                     i64 = i_tmp;
1210                 }
1211             }
1212         }
1213         return (double)i64 / (double)stream_Size( p_demux->s );
1214     }
1215     return 0.0;
1216 }
1217
1218 static int    Control( demux_t *p_demux, int i_query, va_list args )
1219 {
1220     demux_sys_t *p_sys = p_demux->p_sys;
1221     int i;
1222     double   f, *pf;
1223     int64_t i64, *pi64;
1224     vlc_meta_t **pp_meta;
1225
1226     switch( i_query )
1227     {
1228         case DEMUX_GET_POSITION:
1229             pf = (double*)va_arg( args, double * );
1230             *pf = ControlGetPosition( p_demux );
1231             return VLC_SUCCESS;
1232         case DEMUX_SET_POSITION:
1233             f = (double)va_arg( args, double );
1234             if( p_sys->b_seekable )
1235             {
1236                 i64 = (mtime_t)(1000000.0 * p_sys->i_length * f );
1237                 return Seek( p_demux, i64, (int)(f * 100) );
1238             }
1239             else
1240             {
1241                 int64_t i_pos = stream_Size( p_demux->s ) * f;
1242                 return stream_Seek( p_demux->s, i_pos );
1243             }
1244
1245         case DEMUX_GET_TIME:
1246             pi64 = (int64_t*)va_arg( args, int64_t * );
1247             *pi64 = p_sys->i_time;
1248             return VLC_SUCCESS;
1249
1250         case DEMUX_SET_TIME:
1251         {
1252             int i_percent = 0;
1253
1254             i64 = (int64_t)va_arg( args, int64_t );
1255             if( p_sys->i_length > 0 )
1256             {
1257                 i_percent = 100 * i64 / (p_sys->i_length*1000000);
1258             }
1259             else if( p_sys->i_time > 0 )
1260             {
1261                 i_percent = (int)( 100.0 * ControlGetPosition( p_demux ) *
1262                                    (double)i64 / (double)p_sys->i_time );
1263             }
1264             return Seek( p_demux, i64, i_percent );
1265         }
1266         case DEMUX_GET_LENGTH:
1267             pi64 = (int64_t*)va_arg( args, int64_t * );
1268             *pi64 = p_sys->i_length * (mtime_t)1000000;
1269             return VLC_SUCCESS;
1270
1271         case DEMUX_GET_FPS:
1272             pf = (double*)va_arg( args, double * );
1273             *pf = 0.0;
1274             for( i = 0; i < (int)p_sys->i_track; i++ )
1275             {
1276                 avi_track_t *tk = p_sys->track[i];
1277                 if( tk->i_cat == VIDEO_ES && tk->i_scale > 0)
1278                 {
1279                     *pf = (float)tk->i_rate / (float)tk->i_scale;
1280                     break;
1281                 }
1282             }
1283             return VLC_SUCCESS;
1284         case DEMUX_GET_META:
1285             pp_meta = (vlc_meta_t**)va_arg( args, vlc_meta_t** );
1286             *pp_meta = vlc_meta_Duplicate( p_sys->meta );
1287             return VLC_SUCCESS;
1288
1289         default:
1290             return VLC_EGENERIC;
1291     }
1292 }
1293
1294 /*****************************************************************************
1295  * Function to convert pts to chunk or byte
1296  *****************************************************************************/
1297
1298 static mtime_t AVI_PTSToChunk( avi_track_t *tk, mtime_t i_pts )
1299 {
1300     return (mtime_t)((int64_t)i_pts *
1301                      (int64_t)tk->i_rate /
1302                      (int64_t)tk->i_scale /
1303                      (int64_t)1000000 );
1304 }
1305 static mtime_t AVI_PTSToByte( avi_track_t *tk, mtime_t i_pts )
1306 {
1307     return (mtime_t)((int64_t)i_pts *
1308                      (int64_t)tk->i_rate /
1309                      (int64_t)tk->i_scale /
1310                      (int64_t)1000000 *
1311                      (int64_t)tk->i_samplesize );
1312 }
1313
1314 static mtime_t AVI_GetDPTS( avi_track_t *tk, int64_t i_count )
1315 {
1316     mtime_t i_dpts;
1317
1318     i_dpts = (mtime_t)( (int64_t)1000000 *
1319                         (int64_t)i_count *
1320                         (int64_t)tk->i_scale /
1321                         (int64_t)tk->i_rate );
1322
1323     if( tk->i_samplesize )
1324     {
1325         return i_dpts / tk->i_samplesize;
1326     }
1327     return i_dpts;
1328 }
1329
1330 static mtime_t AVI_GetPTS( avi_track_t *tk )
1331 {
1332     if( tk->i_samplesize )
1333     {
1334         int64_t i_count = 0;
1335
1336         /* we need a valid entry we will emulate one */
1337         if( tk->i_idxposc == tk->i_idxnb )
1338         {
1339             if( tk->i_idxposc )
1340             {
1341                 /* use the last entry */
1342                 i_count = tk->p_index[tk->i_idxnb - 1].i_lengthtotal
1343                             + tk->p_index[tk->i_idxnb - 1].i_length;
1344             }
1345         }
1346         else
1347         {
1348             i_count = tk->p_index[tk->i_idxposc].i_lengthtotal;
1349         }
1350         return AVI_GetDPTS( tk, i_count + tk->i_idxposb );
1351     }
1352     else
1353     {
1354         if( tk->i_cat == AUDIO_ES )
1355         {
1356             return AVI_GetDPTS( tk, tk->i_blockno );
1357         }
1358         else
1359         {
1360             return AVI_GetDPTS( tk, tk->i_idxposc );
1361         }
1362     }
1363 }
1364
1365 static int AVI_StreamChunkFind( demux_t *p_demux, unsigned int i_stream )
1366 {
1367     demux_sys_t *p_sys = p_demux->p_sys;
1368     avi_packet_t avi_pk;
1369     int i_loop_count = 0;
1370
1371     /* find first chunk of i_stream that isn't in index */
1372
1373     if( p_sys->i_movi_lastchunk_pos >= p_sys->i_movi_begin + 12 )
1374     {
1375         stream_Seek( p_demux->s, p_sys->i_movi_lastchunk_pos );
1376         if( AVI_PacketNext( p_demux ) )
1377         {
1378             return VLC_EGENERIC;
1379         }
1380     }
1381     else
1382     {
1383         stream_Seek( p_demux->s, p_sys->i_movi_begin + 12 );
1384     }
1385
1386     for( ;; )
1387     {
1388         if( p_demux->b_die ) return VLC_EGENERIC;
1389
1390         if( AVI_PacketGetHeader( p_demux, &avi_pk ) )
1391         {
1392             msg_Warn( p_demux, "cannot get packet header" );
1393             return VLC_EGENERIC;
1394         }
1395         if( avi_pk.i_stream >= p_sys->i_track ||
1396             ( avi_pk.i_cat != AUDIO_ES && avi_pk.i_cat != VIDEO_ES ) )
1397         {
1398             if( AVI_PacketNext( p_demux ) )
1399             {
1400                 return VLC_EGENERIC;
1401             }
1402
1403             /* Prevents from eating all the CPU with broken files.
1404              * This value should be low enough so that it doesn't
1405              * affect the reading speed too much. */
1406             if( !(++i_loop_count % 1024) )
1407             {
1408                 if( p_demux->b_die ) return VLC_EGENERIC;
1409                 msleep( 10000 );
1410
1411                 if( !(i_loop_count % (1024 * 10)) )
1412                     msg_Warn( p_demux, "don't seem to find any data..." );
1413             }
1414         }
1415         else
1416         {
1417             /* add this chunk to the index */
1418             avi_entry_t index;
1419
1420             index.i_id = avi_pk.i_fourcc;
1421             index.i_flags =
1422                AVI_GetKeyFlag(p_sys->track[avi_pk.i_stream]->i_codec,
1423                               avi_pk.i_peek);
1424             index.i_pos = avi_pk.i_pos;
1425             index.i_length = avi_pk.i_size;
1426             AVI_IndexAddEntry( p_sys, avi_pk.i_stream, &index );
1427
1428             if( avi_pk.i_stream == i_stream  )
1429             {
1430                 return VLC_SUCCESS;
1431             }
1432
1433             if( AVI_PacketNext( p_demux ) )
1434             {
1435                 return VLC_EGENERIC;
1436             }
1437         }
1438     }
1439 }
1440
1441
1442 /* be sure that i_ck will be a valid index entry */
1443 static int AVI_StreamChunkSet( demux_t *p_demux, unsigned int i_stream,
1444                                unsigned int i_ck )
1445 {
1446     demux_sys_t *p_sys = p_demux->p_sys;
1447     avi_track_t *p_stream = p_sys->track[i_stream];
1448
1449     p_stream->i_idxposc = i_ck;
1450     p_stream->i_idxposb = 0;
1451
1452     if(  i_ck >= p_stream->i_idxnb )
1453     {
1454         p_stream->i_idxposc = p_stream->i_idxnb - 1;
1455         do
1456         {
1457             p_stream->i_idxposc++;
1458             if( AVI_StreamChunkFind( p_demux, i_stream ) )
1459             {
1460                 return VLC_EGENERIC;
1461             }
1462
1463         } while( p_stream->i_idxposc < i_ck );
1464     }
1465
1466     return VLC_SUCCESS;
1467 }
1468
1469
1470 /* XXX FIXME up to now, we assume that all chunk are one after one */
1471 static int AVI_StreamBytesSet( demux_t    *p_demux,
1472                                unsigned int i_stream,
1473                                off_t   i_byte )
1474 {
1475     demux_sys_t *p_sys = p_demux->p_sys;
1476     avi_track_t *p_stream = p_sys->track[i_stream];
1477
1478     if( ( p_stream->i_idxnb > 0 )
1479         &&( i_byte < p_stream->p_index[p_stream->i_idxnb - 1].i_lengthtotal +
1480                 p_stream->p_index[p_stream->i_idxnb - 1].i_length ) )
1481     {
1482         /* index is valid to find the ck */
1483         /* uses dichototmie to be fast enougth */
1484         int i_idxposc = __MIN( p_stream->i_idxposc, p_stream->i_idxnb - 1 );
1485         int i_idxmax  = p_stream->i_idxnb;
1486         int i_idxmin  = 0;
1487         for( ;; )
1488         {
1489             if( p_stream->p_index[i_idxposc].i_lengthtotal > i_byte )
1490             {
1491                 i_idxmax  = i_idxposc ;
1492                 i_idxposc = ( i_idxmin + i_idxposc ) / 2 ;
1493             }
1494             else
1495             {
1496                 if( p_stream->p_index[i_idxposc].i_lengthtotal +
1497                         p_stream->p_index[i_idxposc].i_length <= i_byte)
1498                 {
1499                     i_idxmin  = i_idxposc ;
1500                     i_idxposc = (i_idxmax + i_idxposc ) / 2 ;
1501                 }
1502                 else
1503                 {
1504                     p_stream->i_idxposc = i_idxposc;
1505                     p_stream->i_idxposb = i_byte -
1506                             p_stream->p_index[i_idxposc].i_lengthtotal;
1507                     return VLC_SUCCESS;
1508                 }
1509             }
1510         }
1511
1512     }
1513     else
1514     {
1515         p_stream->i_idxposc = p_stream->i_idxnb - 1;
1516         p_stream->i_idxposb = 0;
1517         do
1518         {
1519             p_stream->i_idxposc++;
1520             if( AVI_StreamChunkFind( p_demux, i_stream ) )
1521             {
1522                 return VLC_EGENERIC;
1523             }
1524
1525         } while( p_stream->p_index[p_stream->i_idxposc].i_lengthtotal +
1526                     p_stream->p_index[p_stream->i_idxposc].i_length <= i_byte );
1527
1528         p_stream->i_idxposb = i_byte -
1529                        p_stream->p_index[p_stream->i_idxposc].i_lengthtotal;
1530         return VLC_SUCCESS;
1531     }
1532 }
1533
1534 static int AVI_TrackSeek( demux_t *p_demux,
1535                            int i_stream,
1536                            mtime_t i_date )
1537 {
1538     demux_sys_t  *p_sys = p_demux->p_sys;
1539     avi_track_t  *tk = p_sys->track[i_stream];
1540
1541 #define p_stream    p_sys->track[i_stream]
1542     mtime_t i_oldpts;
1543
1544     i_oldpts = AVI_GetPTS( p_stream );
1545
1546     if( !p_stream->i_samplesize )
1547     {
1548         if( AVI_StreamChunkSet( p_demux,
1549                                 i_stream,
1550                                 AVI_PTSToChunk( p_stream, i_date ) ) )
1551         {
1552             return VLC_EGENERIC;
1553         }
1554
1555         if( p_stream->i_cat == AUDIO_ES )
1556         {
1557             unsigned int i;
1558             tk->i_blockno = 0;
1559             for( i = 0; i < tk->i_idxposc; i++ )
1560             {
1561                 if( tk->i_blocksize > 0 )
1562                 {
1563                     tk->i_blockno += ( tk->p_index[i].i_length + tk->i_blocksize - 1 ) / tk->i_blocksize;
1564                 }
1565                 else
1566                 {
1567                     tk->i_blockno++;
1568                 }
1569             }
1570         }
1571
1572         msg_Dbg( p_demux,
1573                  "old:"I64Fd" %s new "I64Fd,
1574                  i_oldpts,
1575                  i_oldpts > i_date ? ">" : "<",
1576                  i_date );
1577
1578         if( p_stream->i_cat == VIDEO_ES )
1579         {
1580             /* search key frame */
1581             if( i_date < i_oldpts )
1582             {
1583                 while( p_stream->i_idxposc > 0 &&
1584                    !( p_stream->p_index[p_stream->i_idxposc].i_flags &
1585                                                                 AVIIF_KEYFRAME ) )
1586                 {
1587                     if( AVI_StreamChunkSet( p_demux,
1588                                             i_stream,
1589                                             p_stream->i_idxposc - 1 ) )
1590                     {
1591                         return VLC_EGENERIC;
1592                     }
1593                 }
1594             }
1595             else
1596             {
1597                 while( p_stream->i_idxposc < p_stream->i_idxnb &&
1598                         !( p_stream->p_index[p_stream->i_idxposc].i_flags &
1599                                                                 AVIIF_KEYFRAME ) )
1600                 {
1601                     if( AVI_StreamChunkSet( p_demux,
1602                                             i_stream,
1603                                             p_stream->i_idxposc + 1 ) )
1604                     {
1605                         return VLC_EGENERIC;
1606                     }
1607                 }
1608             }
1609         }
1610     }
1611     else
1612     {
1613         if( AVI_StreamBytesSet( p_demux,
1614                                 i_stream,
1615                                 AVI_PTSToByte( p_stream, i_date ) ) )
1616         {
1617             return VLC_EGENERIC;
1618         }
1619     }
1620     return VLC_SUCCESS;
1621 #undef p_stream
1622 }
1623
1624 /****************************************************************************
1625  * Return VLC_TRUE if it's a key frame
1626  ****************************************************************************/
1627 static int AVI_GetKeyFlag( vlc_fourcc_t i_fourcc, uint8_t *p_byte )
1628 {
1629     switch( i_fourcc )
1630     {
1631         case FOURCC_DIV1:
1632             /* we have:
1633              *  startcode:      0x00000100   32bits
1634              *  framenumber     ?             5bits
1635              *  piture type     0(I),1(P)     2bits
1636              */
1637             if( GetDWBE( p_byte ) != 0x00000100 )
1638             {
1639                 /* it's not an msmpegv1 stream, strange...*/
1640                 return AVIIF_KEYFRAME;
1641             }
1642             return p_byte[4] & 0x06 ? 0 : AVIIF_KEYFRAME;
1643
1644         case FOURCC_DIV2:
1645         case FOURCC_DIV3:   /* wmv1 also */
1646             /* we have
1647              *  picture type    0(I),1(P)     2bits
1648              */
1649             return p_byte[0] & 0xC0 ? 0 : AVIIF_KEYFRAME;
1650         case FOURCC_mp4v:
1651             /* we should find first occurence of 0x000001b6 (32bits)
1652              *  startcode:      0x000001b6   32bits
1653              *  piture type     0(I),1(P)     2bits
1654              */
1655             if( GetDWBE( p_byte ) != 0x000001b6 )
1656             {
1657                 /* not true , need to find the first VOP header */
1658                 return AVIIF_KEYFRAME;
1659             }
1660             return p_byte[4] & 0xC0 ? 0 : AVIIF_KEYFRAME;
1661
1662         default:
1663             /* I can't do it, so say yes */
1664             return AVIIF_KEYFRAME;
1665     }
1666 }
1667
1668 vlc_fourcc_t AVI_FourccGetCodec( unsigned int i_cat, vlc_fourcc_t i_codec )
1669 {
1670     switch( i_cat )
1671     {
1672         case AUDIO_ES:
1673             wf_tag_to_fourcc( i_codec, &i_codec, NULL );
1674             return i_codec;
1675
1676         case VIDEO_ES:
1677             /* XXX DIV1 <- msmpeg4v1, DIV2 <- msmpeg4v2, DIV3 <- msmpeg4v3, mp4v for mpeg4 */
1678             switch( i_codec )
1679             {
1680                 case FOURCC_1:
1681                     return VLC_FOURCC('m','r','l','e');
1682                 case FOURCC_DIV1:
1683                 case FOURCC_div1:
1684                 case FOURCC_MPG4:
1685                 case FOURCC_mpg4:
1686                     return FOURCC_DIV1;
1687                 case FOURCC_DIV2:
1688                 case FOURCC_div2:
1689                 case FOURCC_MP42:
1690                 case FOURCC_mp42:
1691                 case FOURCC_MPG3:
1692                 case FOURCC_mpg3:
1693                     return FOURCC_DIV2;
1694                 case FOURCC_div3:
1695                 case FOURCC_MP43:
1696                 case FOURCC_mp43:
1697                 case FOURCC_DIV3:
1698                 case FOURCC_DIV4:
1699                 case FOURCC_div4:
1700                 case FOURCC_DIV5:
1701                 case FOURCC_div5:
1702                 case FOURCC_DIV6:
1703                 case FOURCC_div6:
1704                 case FOURCC_AP41:
1705                 case FOURCC_3IV1:
1706                 case FOURCC_3iv1:
1707                 case FOURCC_3IVD:
1708                 case FOURCC_3ivd:
1709                 case FOURCC_3VID:
1710                 case FOURCC_3vid:
1711                     return FOURCC_DIV3;
1712                 case FOURCC_DIVX:
1713                 case FOURCC_divx:
1714                 case FOURCC_MP4S:
1715                 case FOURCC_mp4s:
1716                 case FOURCC_M4S2:
1717                 case FOURCC_m4s2:
1718                 case FOURCC_xvid:
1719                 case FOURCC_XVID:
1720                 case FOURCC_XviD:
1721                 case FOURCC_DX50:
1722                 case FOURCC_dx50:
1723                 case FOURCC_mp4v:
1724                 case FOURCC_4:
1725                 case FOURCC_3IV2:
1726                 case FOURCC_3iv2:
1727                     return FOURCC_mp4v;
1728             }
1729         default:
1730             return VLC_FOURCC( 'u', 'n', 'd', 'f' );
1731     }
1732 }
1733
1734 /****************************************************************************
1735  *
1736  ****************************************************************************/
1737 static void AVI_ParseStreamHeader( vlc_fourcc_t i_id,
1738                                    int *pi_number, int *pi_type )
1739 {
1740 #define SET_PTR( p, v ) if( p ) *(p) = (v);
1741     int c1, c2;
1742
1743     c1 = ((uint8_t *)&i_id)[0];
1744     c2 = ((uint8_t *)&i_id)[1];
1745
1746     if( c1 < '0' || c1 > '9' || c2 < '0' || c2 > '9' )
1747     {
1748         SET_PTR( pi_number, 100 ); /* > max stream number */
1749         SET_PTR( pi_type, UNKNOWN_ES );
1750     }
1751     else
1752     {
1753         SET_PTR( pi_number, (c1 - '0') * 10 + (c2 - '0' ) );
1754         switch( VLC_TWOCC( ((uint8_t *)&i_id)[2], ((uint8_t *)&i_id)[3] ) )
1755         {
1756             case AVITWOCC_wb:
1757                 SET_PTR( pi_type, AUDIO_ES );
1758                 break;
1759             case AVITWOCC_dc:
1760             case AVITWOCC_db:
1761                 SET_PTR( pi_type, VIDEO_ES );
1762                 break;
1763             default:
1764                 SET_PTR( pi_type, UNKNOWN_ES );
1765                 break;
1766         }
1767     }
1768 #undef SET_PTR
1769 }
1770
1771 /****************************************************************************
1772  *
1773  ****************************************************************************/
1774 static int AVI_PacketGetHeader( demux_t *p_demux, avi_packet_t *p_pk )
1775 {
1776     uint8_t  *p_peek;
1777
1778     if( stream_Peek( p_demux->s, &p_peek, 16 ) < 16 )
1779     {
1780         return VLC_EGENERIC;
1781     }
1782     p_pk->i_fourcc  = VLC_FOURCC( p_peek[0], p_peek[1], p_peek[2], p_peek[3] );
1783     p_pk->i_size    = GetDWLE( p_peek + 4 );
1784     p_pk->i_pos     = stream_Tell( p_demux->s );
1785     if( p_pk->i_fourcc == AVIFOURCC_LIST || p_pk->i_fourcc == AVIFOURCC_RIFF )
1786     {
1787         p_pk->i_type = VLC_FOURCC( p_peek[8],  p_peek[9],
1788                                    p_peek[10], p_peek[11] );
1789     }
1790     else
1791     {
1792         p_pk->i_type = 0;
1793     }
1794
1795     memcpy( p_pk->i_peek, p_peek + 8, 8 );
1796
1797     AVI_ParseStreamHeader( p_pk->i_fourcc, &p_pk->i_stream, &p_pk->i_cat );
1798     return VLC_SUCCESS;
1799 }
1800
1801 static int AVI_PacketNext( demux_t *p_demux )
1802 {
1803     avi_packet_t    avi_ck;
1804     int             i_skip = 0;
1805
1806     if( AVI_PacketGetHeader( p_demux, &avi_ck ) )
1807     {
1808         return VLC_EGENERIC;
1809     }
1810
1811     if( avi_ck.i_fourcc == AVIFOURCC_LIST &&
1812         ( avi_ck.i_type == AVIFOURCC_rec || avi_ck.i_type == AVIFOURCC_movi ) )
1813     {
1814         i_skip = 12;
1815     }
1816     else if( avi_ck.i_fourcc == AVIFOURCC_RIFF &&
1817              avi_ck.i_type == AVIFOURCC_AVIX )
1818     {
1819         i_skip = 24;
1820     }
1821     else
1822     {
1823         i_skip = __EVEN( avi_ck.i_size ) + 8;
1824     }
1825
1826     if( stream_Read( p_demux->s, NULL, i_skip ) != i_skip )
1827     {
1828         return VLC_EGENERIC;
1829     }
1830     return VLC_SUCCESS;
1831 }
1832 static int AVI_PacketRead( demux_t   *p_demux,
1833                            avi_packet_t     *p_pk,
1834                            block_t          **pp_frame )
1835 {
1836     size_t i_size;
1837
1838     i_size = __EVEN( p_pk->i_size + 8 );
1839
1840     if( ( *pp_frame = stream_Block( p_demux->s, i_size ) ) == NULL )
1841     {
1842         return VLC_EGENERIC;
1843     }
1844     (*pp_frame)->p_buffer += 8;
1845     (*pp_frame)->i_buffer -= 8;
1846
1847     if( i_size != p_pk->i_size + 8 )
1848     {
1849         (*pp_frame)->i_buffer--;
1850     }
1851
1852     return VLC_SUCCESS;
1853 }
1854
1855 static int AVI_PacketSearch( demux_t *p_demux )
1856 {
1857     demux_sys_t     *p_sys = p_demux->p_sys;
1858     avi_packet_t    avi_pk;
1859     int             i_count = 0;
1860
1861     for( ;; )
1862     {
1863         if( stream_Read( p_demux->s, NULL, 1 ) != 1 )
1864         {
1865             return VLC_EGENERIC;
1866         }
1867         AVI_PacketGetHeader( p_demux, &avi_pk );
1868         if( avi_pk.i_stream < p_sys->i_track &&
1869             ( avi_pk.i_cat == AUDIO_ES || avi_pk.i_cat == VIDEO_ES ) )
1870         {
1871             return VLC_SUCCESS;
1872         }
1873         switch( avi_pk.i_fourcc )
1874         {
1875             case AVIFOURCC_JUNK:
1876             case AVIFOURCC_LIST:
1877             case AVIFOURCC_RIFF:
1878             case AVIFOURCC_idx1:
1879                 return VLC_SUCCESS;
1880         }
1881
1882         /* Prevents from eating all the CPU with broken files.
1883          * This value should be low enough so that it doesn't affect the
1884          * reading speed too much (not that we care much anyway because
1885          * this code is called only on broken files). */
1886         if( !(++i_count % 1024) )
1887         {
1888             if( p_demux->b_die ) return VLC_EGENERIC;
1889
1890             msleep( 10000 );
1891             if( !(i_count % (1024 * 10)) )
1892                 msg_Warn( p_demux, "trying to resync..." );
1893         }
1894     }
1895 }
1896
1897 /****************************************************************************
1898  * Index stuff.
1899  ****************************************************************************/
1900 static void AVI_IndexAddEntry( demux_sys_t *p_sys,
1901                                int i_stream,
1902                                avi_entry_t *p_index)
1903 {
1904     avi_track_t *tk = p_sys->track[i_stream];
1905
1906     /* Update i_movi_lastchunk_pos */
1907     if( p_sys->i_movi_lastchunk_pos < p_index->i_pos )
1908     {
1909         p_sys->i_movi_lastchunk_pos = p_index->i_pos;
1910     }
1911
1912     /* add the entry */
1913     if( tk->i_idxnb >= tk->i_idxmax )
1914     {
1915         tk->i_idxmax += 16384;
1916         tk->p_index = realloc( tk->p_index,
1917                                tk->i_idxmax * sizeof( avi_entry_t ) );
1918         if( tk->p_index == NULL )
1919         {
1920             return;
1921         }
1922     }
1923     /* calculate cumulate length */
1924     if( tk->i_idxnb > 0 )
1925     {
1926         p_index->i_lengthtotal =
1927             tk->p_index[tk->i_idxnb - 1].i_length +
1928                 tk->p_index[tk->i_idxnb - 1].i_lengthtotal;
1929     }
1930     else
1931     {
1932         p_index->i_lengthtotal = 0;
1933     }
1934
1935     tk->p_index[tk->i_idxnb++] = *p_index;
1936 }
1937
1938 static int AVI_IndexLoad_idx1( demux_t *p_demux )
1939 {
1940     demux_sys_t *p_sys = p_demux->p_sys;
1941
1942     avi_chunk_list_t    *p_riff;
1943     avi_chunk_list_t    *p_movi;
1944     avi_chunk_idx1_t    *p_idx1;
1945
1946     unsigned int i_stream;
1947     unsigned int i_index;
1948     off_t        i_offset;
1949     unsigned int i;
1950
1951     vlc_bool_t b_keyset[100];
1952
1953     p_riff = AVI_ChunkFind( &p_sys->ck_root, AVIFOURCC_RIFF, 0);
1954     p_idx1 = AVI_ChunkFind( p_riff, AVIFOURCC_idx1, 0);
1955     p_movi = AVI_ChunkFind( p_riff, AVIFOURCC_movi, 0);
1956
1957     if( !p_idx1 )
1958     {
1959         msg_Warn( p_demux, "cannot find idx1 chunk, no index defined" );
1960         return VLC_EGENERIC;
1961     }
1962
1963     /* *** calculate offset *** */
1964     /* Well, avi is __SHIT__ so test more than one entry
1965      * (needed for some avi files) */
1966     i_offset = 0;
1967     for( i = 0; i < __MIN( p_idx1->i_entry_count, 10 ); i++ )
1968     {
1969         if( p_idx1->entry[i].i_pos < p_movi->i_chunk_pos )
1970         {
1971             i_offset = p_movi->i_chunk_pos + 8;
1972             break;
1973         }
1974     }
1975
1976     /* Reset b_keyset */
1977     for( i_stream = 0; i_stream < p_sys->i_track; i_stream++ )
1978         b_keyset[i_stream] = VLC_FALSE;
1979
1980     for( i_index = 0; i_index < p_idx1->i_entry_count; i_index++ )
1981     {
1982         unsigned int i_cat;
1983
1984         AVI_ParseStreamHeader( p_idx1->entry[i_index].i_fourcc,
1985                                &i_stream,
1986                                &i_cat );
1987         if( i_stream < p_sys->i_track &&
1988             i_cat == p_sys->track[i_stream]->i_cat )
1989         {
1990             avi_entry_t index;
1991             index.i_id      = p_idx1->entry[i_index].i_fourcc;
1992             index.i_flags   =
1993                 p_idx1->entry[i_index].i_flags&(~AVIIF_FIXKEYFRAME);
1994             index.i_pos     = p_idx1->entry[i_index].i_pos + i_offset;
1995             index.i_length  = p_idx1->entry[i_index].i_length;
1996             AVI_IndexAddEntry( p_sys, i_stream, &index );
1997
1998             if( index.i_flags&AVIIF_KEYFRAME )
1999                 b_keyset[i_stream] = VLC_TRUE;
2000         }
2001     }
2002
2003     for( i_stream = 0; i_stream < p_sys->i_track; i_stream++ )
2004     {
2005         if( !b_keyset[i_stream] )
2006         {
2007             avi_track_t *tk = p_sys->track[i_stream];
2008
2009             msg_Dbg( p_demux, "no key frame set for track %d", i_stream );
2010             for( i_index = 0; i_index < tk->i_idxnb; i_index++ )
2011                 tk->p_index[i_index].i_flags |= AVIIF_KEYFRAME;
2012         }
2013     }
2014     return VLC_SUCCESS;
2015 }
2016
2017 static void __Parse_indx( demux_t    *p_demux,
2018                           int               i_stream,
2019                           avi_chunk_indx_t  *p_indx )
2020 {
2021     demux_sys_t         *p_sys    = p_demux->p_sys;
2022     avi_entry_t     index;
2023     int32_t             i;
2024
2025     msg_Dbg( p_demux, "loading subindex(0x%x) %d entries", p_indx->i_indextype, p_indx->i_entriesinuse );
2026     if( p_indx->i_indexsubtype == 0 )
2027     {
2028         for( i = 0; i < p_indx->i_entriesinuse; i++ )
2029         {
2030             index.i_id      = p_indx->i_id;
2031             index.i_flags   = p_indx->idx.std[i].i_size & 0x80000000 ? 0 : AVIIF_KEYFRAME;
2032             index.i_pos     = p_indx->i_baseoffset + p_indx->idx.std[i].i_offset - 8;
2033             index.i_length  = p_indx->idx.std[i].i_size&0x7fffffff;
2034
2035             AVI_IndexAddEntry( p_sys, i_stream, &index );
2036         }
2037     }
2038     else if( p_indx->i_indexsubtype == AVI_INDEX_2FIELD )
2039     {
2040         for( i = 0; i < p_indx->i_entriesinuse; i++ )
2041         {
2042             index.i_id      = p_indx->i_id;
2043             index.i_flags   = p_indx->idx.field[i].i_size & 0x80000000 ? 0 : AVIIF_KEYFRAME;
2044             index.i_pos     = p_indx->i_baseoffset + p_indx->idx.field[i].i_offset - 8;
2045             index.i_length  = p_indx->idx.field[i].i_size;
2046
2047             AVI_IndexAddEntry( p_sys, i_stream, &index );
2048         }
2049     }
2050     else
2051     {
2052         msg_Warn( p_demux, "unknow subtype index(0x%x)", p_indx->i_indexsubtype );
2053     }
2054 }
2055
2056 static void AVI_IndexLoad_indx( demux_t *p_demux )
2057 {
2058     demux_sys_t         *p_sys = p_demux->p_sys;
2059     unsigned int        i_stream;
2060     int32_t             i;
2061
2062     avi_chunk_list_t    *p_riff;
2063     avi_chunk_list_t    *p_hdrl;
2064
2065     p_riff = AVI_ChunkFind( &p_sys->ck_root, AVIFOURCC_RIFF, 0);
2066     p_hdrl = AVI_ChunkFind( p_riff, AVIFOURCC_hdrl, 0 );
2067
2068     for( i_stream = 0; i_stream < p_sys->i_track; i_stream++ )
2069     {
2070         avi_chunk_list_t    *p_strl;
2071         avi_chunk_indx_t    *p_indx;
2072
2073 #define p_stream  p_sys->track[i_stream]
2074         p_strl = AVI_ChunkFind( p_hdrl, AVIFOURCC_strl, i_stream );
2075         p_indx = AVI_ChunkFind( p_strl, AVIFOURCC_indx, 0 );
2076
2077         if( !p_indx )
2078         {
2079             msg_Warn( p_demux, "cannot find indx (misdetect/broken OpenDML file?)" );
2080             continue;
2081         }
2082
2083         if( p_indx->i_indextype == AVI_INDEX_OF_CHUNKS )
2084         {
2085             __Parse_indx( p_demux, i_stream, p_indx );
2086         }
2087         else if( p_indx->i_indextype == AVI_INDEX_OF_INDEXES )
2088         {
2089             avi_chunk_indx_t    ck_sub;
2090             for( i = 0; i < p_indx->i_entriesinuse; i++ )
2091             {
2092                 if( stream_Seek( p_demux->s, p_indx->idx.super[i].i_offset )||
2093                     AVI_ChunkRead( p_demux->s, &ck_sub, NULL  ) )
2094                 {
2095                     break;
2096                 }
2097                 __Parse_indx( p_demux, i_stream, &ck_sub );
2098             }
2099         }
2100         else
2101         {
2102             msg_Warn( p_demux, "unknow type index(0x%x)", p_indx->i_indextype );
2103         }
2104 #undef p_stream
2105     }
2106 }
2107
2108 static void AVI_IndexLoad( demux_t *p_demux )
2109 {
2110     demux_sys_t *p_sys = p_demux->p_sys;
2111     unsigned int i_stream;
2112
2113     for( i_stream = 0; i_stream < p_sys->i_track; i_stream++ )
2114     {
2115         p_sys->track[i_stream]->i_idxnb  = 0;
2116         p_sys->track[i_stream]->i_idxmax = 0;
2117         p_sys->track[i_stream]->p_index  = NULL;
2118     }
2119
2120     if( p_sys->b_odml )
2121     {
2122         AVI_IndexLoad_indx( p_demux );
2123     }
2124     else  if( AVI_IndexLoad_idx1( p_demux ) )
2125     {
2126         /* try indx if idx1 failed as some "normal" file have indx too */
2127         AVI_IndexLoad_indx( p_demux );
2128     }
2129
2130     for( i_stream = 0; i_stream < p_sys->i_track; i_stream++ )
2131     {
2132         msg_Dbg( p_demux, "stream[%d] created %d index entries",
2133                 i_stream, p_sys->track[i_stream]->i_idxnb );
2134     }
2135 }
2136
2137 static void AVI_IndexCreate( demux_t *p_demux )
2138 {
2139     demux_sys_t *p_sys = p_demux->p_sys;
2140
2141     avi_chunk_list_t    *p_riff;
2142     avi_chunk_list_t    *p_movi;
2143
2144     unsigned int i_stream;
2145     off_t i_movi_end;
2146
2147     p_riff = AVI_ChunkFind( &p_sys->ck_root, AVIFOURCC_RIFF, 0);
2148     p_movi = AVI_ChunkFind( p_riff, AVIFOURCC_movi, 0);
2149
2150     if( !p_movi )
2151     {
2152         msg_Err( p_demux, "cannot find p_movi" );
2153         return;
2154     }
2155
2156     for( i_stream = 0; i_stream < p_sys->i_track; i_stream++ )
2157     {
2158         p_sys->track[i_stream]->i_idxnb  = 0;
2159         p_sys->track[i_stream]->i_idxmax = 0;
2160         p_sys->track[i_stream]->p_index  = NULL;
2161     }
2162     i_movi_end = __MIN( (off_t)(p_movi->i_chunk_pos + p_movi->i_chunk_size),
2163                         stream_Size( p_demux->s ) );
2164
2165     stream_Seek( p_demux->s, p_movi->i_chunk_pos + 12 );
2166     msg_Warn( p_demux, "creating index from LIST-movi, will take time !" );
2167     for( ;; )
2168     {
2169         avi_packet_t pk;
2170
2171         if( p_demux->b_die )
2172         {
2173             return;
2174         }
2175
2176         if( AVI_PacketGetHeader( p_demux, &pk ) )
2177         {
2178             break;
2179         }
2180         if( pk.i_stream < p_sys->i_track &&
2181             pk.i_cat == p_sys->track[pk.i_stream]->i_cat )
2182         {
2183             avi_entry_t index;
2184             index.i_id      = pk.i_fourcc;
2185             index.i_flags   =
2186                AVI_GetKeyFlag(p_sys->track[pk.i_stream]->i_codec, pk.i_peek);
2187             index.i_pos     = pk.i_pos;
2188             index.i_length  = pk.i_size;
2189             AVI_IndexAddEntry( p_sys, pk.i_stream, &index );
2190         }
2191         else
2192         {
2193             switch( pk.i_fourcc )
2194             {
2195                 case AVIFOURCC_idx1:
2196                     if( p_sys->b_odml )
2197                     {
2198                         avi_chunk_list_t *p_sysx;
2199                         p_sysx = AVI_ChunkFind( &p_sys->ck_root,
2200                                                 AVIFOURCC_RIFF, 1 );
2201
2202                         msg_Dbg( p_demux, "looking for new RIFF chunk" );
2203                         if( stream_Seek( p_demux->s, p_sysx->i_chunk_pos + 24))
2204                         {
2205                             goto print_stat;
2206                         }
2207                         break;
2208                     }
2209                     goto print_stat;
2210                 case AVIFOURCC_RIFF:
2211                         msg_Dbg( p_demux, "new RIFF chunk found" );
2212                 case AVIFOURCC_rec:
2213                 case AVIFOURCC_JUNK:
2214                     break;
2215                 default:
2216                     msg_Warn( p_demux, "need resync, probably broken avi" );
2217                     if( AVI_PacketSearch( p_demux ) )
2218                     {
2219                         msg_Warn( p_demux, "lost sync, abord index creation" );
2220                         goto print_stat;
2221                     }
2222             }
2223         }
2224
2225         if( ( !p_sys->b_odml && pk.i_pos + pk.i_size >= i_movi_end ) ||
2226             AVI_PacketNext( p_demux ) )
2227         {
2228             break;
2229         }
2230     }
2231
2232 print_stat:
2233     for( i_stream = 0; i_stream < p_sys->i_track; i_stream++ )
2234     {
2235         msg_Dbg( p_demux,
2236                 "stream[%d] creating %d index entries",
2237                 i_stream,
2238                 p_sys->track[i_stream]->i_idxnb );
2239     }
2240 }
2241
2242 /*****************************************************************************
2243  * Stream management
2244  *****************************************************************************/
2245 static int AVI_TrackStopFinishedStreams( demux_t *p_demux )
2246 {
2247     demux_sys_t *p_sys = p_demux->p_sys;
2248     unsigned int i;
2249     int b_end = VLC_TRUE;
2250
2251     for( i = 0; i < p_sys->i_track; i++ )
2252     {
2253         avi_track_t *tk = p_sys->track[i];
2254         if( tk->i_idxposc >= tk->i_idxnb )
2255         {
2256             tk->b_activated = VLC_FALSE;
2257             es_out_Control( p_demux->out, ES_OUT_SET_ES_STATE, tk->p_es, VLC_FALSE );
2258         }
2259         else
2260         {
2261             b_end = VLC_FALSE;
2262         }
2263     }
2264     return( b_end );
2265 }
2266
2267 /****************************************************************************
2268  * AVI_MovieGetLength give max streams length in second
2269  ****************************************************************************/
2270 static mtime_t  AVI_MovieGetLength( demux_t *p_demux )
2271 {
2272     demux_sys_t  *p_sys = p_demux->p_sys;
2273     mtime_t      i_maxlength = 0;
2274     unsigned int i;
2275
2276     for( i = 0; i < p_sys->i_track; i++ )
2277     {
2278         avi_track_t *tk = p_sys->track[i];
2279         mtime_t i_length;
2280
2281         /* fix length for each stream */
2282         if( tk->i_idxnb < 1 || !tk->p_index )
2283         {
2284             continue;
2285         }
2286
2287         if( tk->i_samplesize )
2288         {
2289             i_length = AVI_GetDPTS( tk,
2290                                     tk->p_index[tk->i_idxnb-1].i_lengthtotal +
2291                                         tk->p_index[tk->i_idxnb-1].i_length );
2292         }
2293         else
2294         {
2295             i_length = AVI_GetDPTS( tk, tk->i_idxnb );
2296         }
2297         i_length /= (mtime_t)1000000;    /* in seconds */
2298
2299         msg_Dbg( p_demux,
2300                  "stream[%d] length:"I64Fd" (based on index)",
2301                  i,
2302                  i_length );
2303         i_maxlength = __MAX( i_maxlength, i_length );
2304     }
2305
2306     return i_maxlength;
2307 }
2308
2309