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