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

   1 /*****************************************************************************
   2  * avi.c
   3  *****************************************************************************
   4  * Copyright (C) 2001, 2002 VideoLAN
   5  * $Id: avi.c,v 1.7 2003/02/24 12:34:29 fenrir Exp $
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27 /* TODO: add OpenDML write support */
  28
  29 #include <stdlib.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <string.h>
  33 #include <errno.h>
  34 #include <fcntl.h>
  35
  36 #include <vlc/vlc.h>
  37 #include <vlc/input.h>
  38 #include <vlc/sout.h>
  39
  40 #ifdef HAVE_UNISTD_H
  41 #   include <unistd.h>
  42 #elif defined( _MSC_VER ) && defined( _WIN32 ) && !defined( UNDER_CE )
  43 #   include <io.h>
  44 #endif
  45
  46 #include "codecs.h"
  47
  48
  49 #define AVIF_HASINDEX       0x00000010  // Index at end of file?
  50 #define AVIF_MUSTUSEINDEX   0x00000020
  51 #define AVIF_ISINTERLEAVED  0x00000100
  52 #define AVIF_TRUSTCKTYPE    0x00000800  // Use CKType to find key frames?
  53 #define AVIF_WASCAPTUREFILE 0x00010000
  54 #define AVIF_COPYRIGHTED    0x00020000
  55
  56 /* Flags for index */
  57 #define AVIIF_LIST          0x00000001L /* chunk is a 'LIST' */
  58 #define AVIIF_KEYFRAME      0x00000010L /* this frame is a key frame.*/
  59 #define AVIIF_NOTIME        0x00000100L /* this frame doesn't take any time */
  60 #define AVIIF_COMPUSE       0x0FFF0000L /* these bits are for compressor use */
  61
  62 /*****************************************************************************
  63  * Exported prototypes
  64  *****************************************************************************/
  65 static int     Open   ( vlc_object_t * );
  66 static void    Close  ( vlc_object_t * );
  67
  68 static int Capability( int , void *, void * );
  69 static int AddStream( sout_instance_t *, sout_input_t * );
  70 static int DelStream( sout_instance_t *, sout_input_t * );
  71 static int Mux      ( sout_instance_t * );
  72
  73 static sout_buffer_t *avi_HeaderCreateRIFF( sout_instance_t *p_sout );
  74 static sout_buffer_t *avi_HeaderCreateidx1( sout_instance_t *p_sout );
  75
  76 static void SetFCC( uint8_t *p, char *fcc )
  77 {
  78     p[0] = fcc[0];
  79     p[1] = fcc[1];
  80     p[2] = fcc[2];
  81     p[3] = fcc[3];
  82 }
  83
  84 static void SetDWLE( uint8_t *p, uint32_t i_dw )
  85 {
  86     p[3] = ( i_dw >> 24 )&0xff;
  87     p[2] = ( i_dw >> 16 )&0xff;
  88     p[1] = ( i_dw >>  8 )&0xff;
  89     p[0] = ( i_dw       )&0xff;
  90 }
  91
  92 /*****************************************************************************
  93  * Module descriptor
  94  *****************************************************************************/
  95 vlc_module_begin();
  96     set_description( _("Avi muxer") );
  97     set_capability( "sout mux", 5 );
  98     add_shortcut( "avi" );
  99     set_callbacks( Open, Close );
 100 vlc_module_end();
 101
 102 // FIXME FIXME
 103 #define HDR_SIZE 10240
 104
 105 typedef struct avi_stream_s
 106 {
 107     int i_cat;
 108
 109     char fcc[4];
 110
 111     mtime_t i_duration;       // in µs
 112
 113     int     i_frames;        // total frame count
 114     int64_t i_totalsize;    // total stream size
 115
 116     float   f_fps;
 117     int     i_bitrate;
 118
 119     BITMAPINFOHEADER    *p_bih;
 120     WAVEFORMATEX        *p_wf;
 121
 122 } avi_stream_t;
 123
 124 typedef struct avi_idx1_entry_s
 125 {
 126     char     fcc[4];
 127     uint32_t i_flags;
 128     uint32_t i_pos;
 129     uint32_t i_length;
 130
 131 } avi_idx1_entry_t;
 132
 133 typedef struct avi_idx1_s
 134 {
 135     unsigned int i_entry_count;
 136     unsigned int i_entry_max;
 137
 138     avi_idx1_entry_t *entry;
 139 } avi_idx1_t;
 140
 141 typedef struct sout_mux_s
 142 {
 143     int i_streams;
 144     int i_stream_video;
 145
 146     off_t i_movi_size;
 147     avi_stream_t stream[100];
 148
 149     avi_idx1_t idx1;
 150     off_t i_idx1_size;
 151
 152 } sout_mux_t;
 153
 154 /*****************************************************************************
 155  * Open:
 156  *****************************************************************************/
 157 static int Open( vlc_object_t *p_this )
 158 {
 159     sout_instance_t     *p_sout = (sout_instance_t*)p_this;
 160     sout_mux_t          *p_mux;
 161     sout_buffer_t       *p_hdr;
 162
 163     p_mux = malloc( sizeof( sout_mux_t ) );
 164     p_mux->i_streams = 0;
 165     p_mux->i_stream_video = -1;
 166     p_mux->i_movi_size = 0;
 167
 168     p_mux->idx1.i_entry_count = 0;
 169     p_mux->idx1.i_entry_max = 10000;
 170     p_mux->idx1.entry = calloc( p_mux->idx1.i_entry_max, sizeof( avi_idx1_entry_t ) );
 171
 172     msg_Info( p_sout, "Open" );
 173
 174     p_sout->pf_mux_capacity  = Capability;
 175     p_sout->pf_mux_addstream = AddStream;
 176     p_sout->pf_mux_delstream = DelStream;
 177     p_sout->pf_mux           = Mux;
 178     p_sout->p_mux_data = (void*)p_mux;
 179     p_sout->i_mux_preheader  = 8; // (fourcc,length) header
 180
 181     /* room to add header at the end */
 182     p_hdr = sout_BufferNew( p_sout, HDR_SIZE );
 183     memset( p_hdr->p_buffer, 0, HDR_SIZE );
 184     sout_AccessOutWrite( p_sout->p_access, p_hdr );
 185
 186     return VLC_SUCCESS;
 187 }
 188
 189 /*****************************************************************************
 190  * Close:
 191  *****************************************************************************/
 192
 193 static void Close( vlc_object_t * p_this )
 194 {
 195     sout_instance_t     *p_sout = (sout_instance_t*)p_this;
 196     sout_mux_t          *p_mux = (sout_mux_t*)p_sout->p_mux_data;
 197     sout_buffer_t       *p_hdr, *p_idx1;
 198     int                 i_stream;
 199
 200     msg_Info( p_sout, "Close" );
 201
 202     /* first create idx1 chunk (write at the end of the stream */
 203     p_idx1 = avi_HeaderCreateidx1( p_sout );
 204     p_mux->i_idx1_size = p_idx1->i_size;
 205     sout_AccessOutWrite( p_sout->p_access, p_idx1 );
 206
 207     /* calculate some value for headers creations */
 208     for( i_stream = 0; i_stream < p_mux->i_streams; i_stream++ )
 209     {
 210         avi_stream_t *p_stream;
 211
 212         p_stream = &p_mux->stream[i_stream];
 213
 214         p_stream->f_fps = 25;
 215         if( p_stream->i_duration > 0 )
 216         {
 217             p_stream->f_fps = (float)p_stream->i_frames /
 218                               ( (float)p_stream->i_duration /
 219                                 (float)1000000 );
 220         }
 221         p_stream->i_bitrate = 128 * 1024;
 222         if( p_stream->i_duration > 0 )
 223         {
 224             p_stream->i_bitrate =
 225                 8 * (uint64_t)1000000 *
 226                     (uint64_t)p_stream->i_totalsize /
 227                     (uint64_t)p_stream->i_duration;
 228         }
 229         msg_Err( p_sout,"stream[%d] duration:%lld totalsize:%lld frames:%d fps:%f kb/s:%d",
 230                 i_stream,
 231                 p_stream->i_duration/1000000, p_stream->i_totalsize,
 232                 p_stream->i_frames,
 233                 p_stream->f_fps, p_stream->i_bitrate/1024 );
 234     }
 235
 236     p_hdr = avi_HeaderCreateRIFF( p_sout );
 237     sout_AccessOutSeek( p_sout->p_access, 0 );
 238     sout_AccessOutWrite( p_sout->p_access, p_hdr );
 239 }
 240
 241 static int Capability( int i_query, void *p_args, void *p_answer )
 242 {
 243    switch( i_query )
 244    {
 245         case SOUT_MUX_CAP_GET_ADD_STREAM_ANY_TIME:
 246             *(vlc_bool_t*)p_answer = VLC_TRUE;
 247             return( SOUT_MUX_CAP_ERR_OK );
 248         default:
 249             return( SOUT_MUX_CAP_ERR_UNIMPLEMENTED );
 250    }
 251 }
 252
 253 static int AddStream( sout_instance_t *p_sout, sout_input_t *p_input )
 254 {
 255     sout_mux_t          *p_mux = (sout_mux_t*)p_sout->p_mux_data;
 256     avi_stream_t        *p_stream;
 257
 258     if( p_mux->i_streams >= 100 )
 259     {
 260         msg_Err( p_sout, "too many streams" );
 261         return( -1 );
 262     }
 263     if( p_input->input_format.p_format == NULL )
 264     {
 265         msg_Err( p_sout, "stream descriptor missing" );
 266         return( -1 );
 267     }
 268
 269     msg_Dbg( p_sout, "adding input" );
 270     p_input->p_mux_data = malloc( sizeof( int ) );
 271
 272     *((int*)p_input->p_mux_data) = p_mux->i_streams;
 273     p_stream = &p_mux->stream[p_mux->i_streams];
 274
 275     switch( p_input->input_format.i_cat )
 276     {
 277         case AUDIO_ES:
 278             {
 279                 WAVEFORMATEX *p_wf =
 280                     (WAVEFORMATEX*)p_input->input_format.p_format;
 281
 282                 p_stream->i_cat = AUDIO_ES;
 283                 p_stream->fcc[0] = '0' + p_mux->i_streams / 10;
 284                 p_stream->fcc[1] = '0' + p_mux->i_streams % 10;
 285                 p_stream->fcc[2] = 'w';
 286                 p_stream->fcc[3] = 'b';
 287
 288                 p_stream->p_bih = NULL;
 289                 p_stream->p_wf  = malloc( sizeof( WAVEFORMATEX ) + p_wf->cbSize );
 290                 memcpy( p_stream->p_wf,
 291                         p_wf,
 292                         sizeof( WAVEFORMATEX ) + p_wf->cbSize);
 293             }
 294             break;
 295         case VIDEO_ES:
 296             {
 297                 BITMAPINFOHEADER *p_bih =
 298                     (BITMAPINFOHEADER*)p_input->input_format.p_format;;
 299
 300                 p_stream->i_cat = VIDEO_ES;
 301                 p_stream->fcc[0] = '0' + p_mux->i_streams / 10;
 302                 p_stream->fcc[1] = '0' + p_mux->i_streams % 10;
 303                 p_stream->fcc[2] = 'd';
 304                 p_stream->fcc[3] = 'c';
 305                 if( p_mux->i_stream_video < 0 )
 306                 {
 307                     p_mux->i_stream_video = p_mux->i_streams;
 308                 }
 309                 p_stream->p_wf  = NULL;
 310                 p_stream->p_bih = malloc( p_bih->biSize );
 311                 memcpy( p_stream->p_bih,
 312                         p_bih,
 313                         p_bih->biSize );
 314             }
 315             break;
 316         default:
 317             return( -1 );
 318     }
 319     p_stream->i_totalsize = 0;
 320     p_stream->i_frames     = 0;
 321     p_stream->i_duration  = 0;
 322
 323     p_mux->i_streams++;
 324     return( 0 );
 325 }
 326
 327 static int DelStream( sout_instance_t *p_sout, sout_input_t *p_input )
 328 {
 329 //    sout_mux_t          *p_mux = (sout_mux_t*)p_sout->p_mux_data;
 330
 331     msg_Dbg( p_sout, "removing input" );
 332
 333     free( p_input->p_mux_data ); p_input->p_mux_data = NULL;
 334
 335     return( 0 );
 336 }
 337
 338 static int Mux      ( sout_instance_t *p_sout )
 339 {
 340     sout_mux_t          *p_mux = (sout_mux_t*)p_sout->p_mux_data;
 341     avi_stream_t        *p_stream;
 342     int i_stream;
 343     int i;
 344
 345     for( i = 0; i < p_sout->i_nb_inputs; i++ )
 346     {
 347         int i_count;
 348         sout_fifo_t *p_fifo;
 349
 350         i_stream = *((int*)p_sout->pp_inputs[i]->p_mux_data );
 351         p_stream = &p_mux->stream[i_stream];
 352
 353         p_fifo = p_sout->pp_inputs[i]->p_fifo;
 354         i_count = p_fifo->i_depth;
 355         while( i_count > 0 )
 356         {
 357             avi_idx1_entry_t *p_idx;
 358             sout_buffer_t *p_data;
 359
 360             p_data = sout_FifoGet( p_fifo );
 361
 362             p_stream->i_frames++;
 363             p_stream->i_duration  += p_data->i_length;
 364             p_stream->i_totalsize += p_data->i_size;
 365
 366             /* add idx1 entry for this frame */
 367             p_idx = &p_mux->idx1.entry[p_mux->idx1.i_entry_count];
 368             memcpy( p_idx->fcc, p_stream->fcc, 4 );
 369             p_idx->i_flags = AVIIF_KEYFRAME;
 370             p_idx->i_pos   = p_mux->i_movi_size + 4;
 371             p_idx->i_length= p_data->i_size;
 372             p_mux->idx1.i_entry_count++;
 373             if( p_mux->idx1.i_entry_count >= p_mux->idx1.i_entry_max )
 374             {
 375                 p_mux->idx1.i_entry_max += 10000;
 376                 p_mux->idx1.entry = realloc( p_mux->idx1.entry,
 377                                              p_mux->idx1.i_entry_max * sizeof( avi_idx1_entry_t ) );
 378             }
 379
 380
 381             if( sout_BufferReallocFromPreHeader( p_sout, p_data, 8 ) )
 382             {
 383                 /* there isn't enough data in preheader */
 384                 sout_buffer_t *p_hdr;
 385
 386                 p_hdr = sout_BufferNew( p_sout, 8 );
 387                 SetFCC( p_hdr->p_buffer, p_stream->fcc );
 388                 SetDWLE( p_hdr->p_buffer + 4, p_data->i_size );
 389
 390                 sout_AccessOutWrite( p_sout->p_access, p_hdr );
 391                 p_mux->i_movi_size += p_hdr->i_size;
 392
 393             }
 394             else
 395             {
 396                 SetFCC( p_data->p_buffer, p_stream->fcc );
 397                 SetDWLE( p_data->p_buffer + 4, p_data->i_size - 8 );
 398             }
 399
 400             if( p_data->i_size & 0x01 )
 401             {
 402                 sout_BufferRealloc( p_sout, p_data, p_data->i_size + 1 );
 403                 p_data->i_size += 1;
 404             }
 405
 406             sout_AccessOutWrite( p_sout->p_access, p_data );
 407             p_mux->i_movi_size += p_data->i_size;
 408
 409             i_count--;
 410         }
 411
 412     }
 413     return( 0 );
 414 }
 415
 416 /****************************************************************************/
 417 /****************************************************************************/
 418 /****************************************************************************/
 419 /****************************************************************************/
 420
 421 typedef struct buffer_out_s
 422 {
 423     int      i_buffer_size;
 424     int      i_buffer;
 425     uint8_t  *p_buffer;
 426
 427 } buffer_out_t;
 428
 429 static void bo_Init( buffer_out_t *p_bo, int i_size, uint8_t *p_buffer )
 430 {
 431     p_bo->i_buffer_size = i_size;
 432     p_bo->i_buffer = 0;
 433     p_bo->p_buffer = p_buffer;
 434 }
 435 static void bo_AddByte( buffer_out_t *p_bo, uint8_t i )
 436 {
 437     if( p_bo->i_buffer < p_bo->i_buffer_size )
 438     {
 439         p_bo->p_buffer[p_bo->i_buffer] = i;
 440     }
 441     p_bo->i_buffer++;
 442 }
 443 static void bo_AddWordLE( buffer_out_t *p_bo, uint16_t i )
 444 {
 445     bo_AddByte( p_bo, i &0xff );
 446     bo_AddByte( p_bo, ( ( i >> 8) &0xff ) );
 447 }
 448 static void bo_AddWordBE( buffer_out_t *p_bo, uint16_t i )
 449 {
 450     bo_AddByte( p_bo, ( ( i >> 8) &0xff ) );
 451     bo_AddByte( p_bo, i &0xff );
 452 }
 453 static void bo_AddDWordLE( buffer_out_t *p_bo, uint32_t i )
 454 {
 455     bo_AddWordLE( p_bo, i &0xffff );
 456     bo_AddWordLE( p_bo, ( ( i >> 16) &0xffff ) );
 457 }
 458 static void bo_AddDWordBE( buffer_out_t *p_bo, uint32_t i )
 459 {
 460     bo_AddWordBE( p_bo, ( ( i >> 16) &0xffff ) );
 461     bo_AddWordBE( p_bo, i &0xffff );
 462 }
 463 #if 0
 464 static void bo_AddLWordLE( buffer_out_t *p_bo, uint64_t i )
 465 {
 466     bo_AddDWordLE( p_bo, i &0xffffffff );
 467     bo_AddDWordLE( p_bo, ( ( i >> 32) &0xffffffff ) );
 468 }
 469 static void bo_AddLWordBE( buffer_out_t *p_bo, uint64_t i )
 470 {
 471     bo_AddDWordBE( p_bo, ( ( i >> 32) &0xffffffff ) );
 472     bo_AddDWordBE( p_bo, i &0xffffffff );
 473 }
 474 #endif
 475
 476 static void bo_AddFCC( buffer_out_t *p_bo, char *fcc )
 477 {
 478     bo_AddByte( p_bo, fcc[0] );
 479     bo_AddByte( p_bo, fcc[1] );
 480     bo_AddByte( p_bo, fcc[2] );
 481     bo_AddByte( p_bo, fcc[3] );
 482 }
 483
 484 static void bo_AddMem( buffer_out_t *p_bo, int i_size, uint8_t *p_mem )
 485 {
 486     int i;
 487
 488     for( i = 0; i < i_size; i++ )
 489     {
 490         bo_AddByte( p_bo, p_mem[i] );
 491     }
 492 }
 493
 494 /****************************************************************************
 495  ****************************************************************************
 496  **
 497  ** avi header generation
 498  **
 499  ****************************************************************************
 500  ****************************************************************************/
 501 #define AVI_BOX_ENTER( fcc ) \
 502     buffer_out_t _bo_sav_; \
 503     bo_AddFCC( p_bo, fcc ); \
 504     _bo_sav_ = *p_bo; \
 505     bo_AddDWordLE( p_bo, 0 )
 506
 507 #define AVI_BOX_ENTER_LIST( fcc ) \
 508     AVI_BOX_ENTER( "LIST" ); \
 509     bo_AddFCC( p_bo, fcc )
 510
 511 #define AVI_BOX_EXIT( i_err ) \
 512     if( p_bo->i_buffer&0x01 ) bo_AddByte( p_bo, 0 ); \
 513     bo_AddDWordLE( &_bo_sav_, p_bo->i_buffer - _bo_sav_.i_buffer - 4 ); \
 514     return( i_err );
 515
 516 static int avi_HeaderAdd_avih( sout_instance_t *p_sout,
 517                                buffer_out_t *p_bo )
 518 {
 519     sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
 520     avi_stream_t *p_video = NULL;
 521     int         i_stream;
 522     uint32_t    i_microsecperframe;
 523     int         i_maxbytespersec;
 524     int         i_totalframes;
 525     AVI_BOX_ENTER( "avih" );
 526
 527     if( p_mux->i_stream_video >= 0 )
 528     {
 529         p_video = &p_mux->stream[p_mux->i_stream_video];
 530         if( p_video->i_frames <= 0 )
 531         {
 532             p_video = NULL;
 533         }
 534     }
 535
 536     if( p_video )
 537     {
 538         i_microsecperframe =
 539             (uint32_t)( (float)1000000 /
 540                         (float)p_mux->stream[p_mux->i_stream_video].f_fps );
 541         i_totalframes = p_mux->stream[p_mux->i_stream_video].i_frames;
 542     }
 543     else
 544     {
 545         msg_Warn( p_sout, "avi file without audio video track isn't a good idea..." );
 546         i_microsecperframe = 0;
 547         i_totalframes = 0;
 548     }
 549
 550     for( i_stream = 0,i_maxbytespersec = 0; i_stream < p_mux->i_streams; i_stream++ )
 551     {
 552         if( p_mux->stream[p_mux->i_stream_video].i_duration > 0 )
 553         {
 554             i_maxbytespersec +=
 555                 p_mux->stream[p_mux->i_stream_video].i_totalsize /
 556                 p_mux->stream[p_mux->i_stream_video].i_duration;
 557         }
 558     }
 559
 560     bo_AddDWordLE( p_bo, i_microsecperframe );
 561     bo_AddDWordLE( p_bo, i_maxbytespersec );
 562     bo_AddDWordLE( p_bo, 0 );                   /* padding */
 563     bo_AddDWordLE( p_bo, AVIF_TRUSTCKTYPE |
 564                          AVIF_HASINDEX |
 565                          AVIF_ISINTERLEAVED );  /* flags */
 566     bo_AddDWordLE( p_bo, i_totalframes );
 567     bo_AddDWordLE( p_bo, 0 );                   /* initial frame */
 568     bo_AddDWordLE( p_bo, p_mux->i_streams );    /* streams count */
 569     bo_AddDWordLE( p_bo, 1024 * 1024 );         /* suggested buffer size */
 570     if( p_video )
 571     {
 572         bo_AddDWordLE( p_bo, p_video->p_bih->biWidth );
 573         bo_AddDWordLE( p_bo, p_video->p_bih->biHeight );
 574     }
 575     else
 576     {
 577         bo_AddDWordLE( p_bo, 0 );
 578         bo_AddDWordLE( p_bo, 0 );
 579     }
 580     bo_AddDWordLE( p_bo, 0 );                   /* ???? */
 581     bo_AddDWordLE( p_bo, 0 );                   /* ???? */
 582     bo_AddDWordLE( p_bo, 0 );                   /* ???? */
 583     bo_AddDWordLE( p_bo, 0 );                   /* ???? */
 584
 585     AVI_BOX_EXIT( 0 );
 586 }
 587 static int avi_HeaderAdd_strh( sout_instance_t *p_sout,
 588                                buffer_out_t *p_bo,
 589                                avi_stream_t *p_stream )
 590 {
 591 //    sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
 592     AVI_BOX_ENTER( "strh" );
 593
 594     switch( p_stream->i_cat )
 595     {
 596         case VIDEO_ES:
 597             {
 598                 bo_AddFCC( p_bo, "vids" );
 599                 bo_AddDWordBE( p_bo, p_stream->p_bih->biCompression );
 600                 bo_AddDWordLE( p_bo, 0 );   /* flags */
 601                 bo_AddWordLE(  p_bo, 0 );   /* priority */
 602                 bo_AddWordLE(  p_bo, 0 );   /* langage */
 603                 bo_AddDWordLE( p_bo, 0 );   /* initial frame */
 604                 bo_AddDWordLE( p_bo, 1000 );/* scale */
 605                 bo_AddDWordLE( p_bo, (uint32_t)( 1000 * p_stream->f_fps ));
 606                 bo_AddDWordLE( p_bo, 0 );   /* start */
 607                 bo_AddDWordLE( p_bo, p_stream->i_frames );
 608                 bo_AddDWordLE( p_bo, 1024 * 1024 );
 609                 bo_AddDWordLE( p_bo, -1 );  /* quality */
 610                 bo_AddDWordLE( p_bo, 0 );   /* samplesize */
 611                 bo_AddWordLE(  p_bo, 0 );   /* ??? */
 612                 bo_AddWordLE(  p_bo, 0 );   /* ??? */
 613                 bo_AddWordLE(  p_bo, p_stream->p_bih->biWidth );
 614                 bo_AddWordLE(  p_bo, p_stream->p_bih->biHeight );
 615             }
 616             break;
 617         case AUDIO_ES:
 618             {
 619                 int i_rate, i_scale, i_samplesize;
 620
 621                 i_samplesize = p_stream->p_wf->nBlockAlign;
 622                 if( i_samplesize > 1 )
 623                 {
 624                     i_scale = i_samplesize;
 625                     i_rate = i_scale * p_stream->i_bitrate / 8;
 626                 }
 627                 else
 628                 {
 629                     i_samplesize = 1;
 630                     i_scale = 1000;
 631                     i_rate = 1000 * p_stream->i_bitrate / 8;
 632                 }
 633                 bo_AddFCC( p_bo, "auds" );
 634                 bo_AddDWordLE( p_bo, 0 );   /* tag */
 635                 bo_AddDWordLE( p_bo, 0 );   /* flags */
 636                 bo_AddWordLE(  p_bo, 0 );   /* priority */
 637                 bo_AddWordLE(  p_bo, 0 );   /* langage */
 638                 bo_AddDWordLE( p_bo, 0 );   /* initial frame */
 639                 bo_AddDWordLE( p_bo, i_scale );/* scale */
 640                 bo_AddDWordLE( p_bo, i_rate );
 641                 bo_AddDWordLE( p_bo, 0 );   /* start */
 642                 bo_AddDWordLE( p_bo, p_stream->i_frames );
 643                 bo_AddDWordLE( p_bo, 10 * 1024 );
 644                 bo_AddDWordLE( p_bo, -1 );  /* quality */
 645                 bo_AddDWordLE( p_bo, i_samplesize );
 646                 bo_AddWordLE(  p_bo, 0 );   /* ??? */
 647                 bo_AddWordLE(  p_bo, 0 );   /* ??? */
 648                 bo_AddWordLE(  p_bo, 0 );
 649                 bo_AddWordLE(  p_bo, 0 );
 650             }
 651             break;
 652     }
 653
 654     AVI_BOX_EXIT( 0 );
 655 }
 656
 657 static int avi_HeaderAdd_strf( sout_instance_t *p_sout,
 658                                buffer_out_t *p_bo,
 659                                avi_stream_t *p_stream )
 660 {
 661 //    sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
 662     AVI_BOX_ENTER( "strf" );
 663
 664     switch( p_stream->i_cat )
 665     {
 666         case AUDIO_ES:
 667             bo_AddWordLE( p_bo, p_stream->p_wf->wFormatTag );
 668             bo_AddWordLE( p_bo, p_stream->p_wf->nChannels );
 669             bo_AddDWordLE( p_bo, p_stream->p_wf->nSamplesPerSec );
 670             bo_AddDWordLE( p_bo, p_stream->p_wf->nAvgBytesPerSec );
 671             bo_AddWordLE( p_bo, p_stream->p_wf->nBlockAlign );
 672             bo_AddWordLE( p_bo, p_stream->p_wf->wBitsPerSample );
 673             bo_AddWordLE( p_bo, p_stream->p_wf->cbSize );
 674             bo_AddMem( p_bo, p_stream->p_wf->cbSize, (uint8_t*)&p_stream->p_wf[1] );
 675             break;
 676         case VIDEO_ES:
 677             bo_AddDWordLE( p_bo, p_stream->p_bih->biSize );
 678             bo_AddDWordLE( p_bo, p_stream->p_bih->biWidth );
 679             bo_AddDWordLE( p_bo, p_stream->p_bih->biHeight );
 680             bo_AddWordLE( p_bo, p_stream->p_bih->biPlanes );
 681             bo_AddWordLE( p_bo, p_stream->p_bih->biBitCount );
 682             if( VLC_FOURCC( 0, 0, 0, 1 ) == 0x00000001 )
 683             {
 684                 bo_AddDWordBE( p_bo, p_stream->p_bih->biCompression );
 685             }
 686             else
 687             {
 688                 bo_AddDWordLE( p_bo, p_stream->p_bih->biCompression );
 689             }
 690             bo_AddDWordLE( p_bo, p_stream->p_bih->biSizeImage );
 691             bo_AddDWordLE( p_bo, p_stream->p_bih->biXPelsPerMeter );
 692             bo_AddDWordLE( p_bo, p_stream->p_bih->biYPelsPerMeter );
 693             bo_AddDWordLE( p_bo, p_stream->p_bih->biClrUsed );
 694             bo_AddDWordLE( p_bo, p_stream->p_bih->biClrImportant );
 695             bo_AddMem( p_bo,
 696                        p_stream->p_bih->biSize - sizeof( BITMAPINFOHEADER ),
 697                        (uint8_t*)&p_stream->p_bih[1] );
 698             break;
 699     }
 700
 701     AVI_BOX_EXIT( 0 );
 702 }
 703
 704 static int avi_HeaderAdd_strl( sout_instance_t *p_sout,
 705                                buffer_out_t *p_bo,
 706                                avi_stream_t *p_stream )
 707 {
 708 //    sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
 709     AVI_BOX_ENTER_LIST( "strl" );
 710
 711     avi_HeaderAdd_strh( p_sout, p_bo, p_stream );
 712     avi_HeaderAdd_strf( p_sout, p_bo, p_stream );
 713
 714     AVI_BOX_EXIT( 0 );
 715 }
 716
 717 static sout_buffer_t *avi_HeaderCreateRIFF( sout_instance_t *p_sout )
 718 {
 719     sout_mux_t          *p_mux = (sout_mux_t*)p_sout->p_mux_data;
 720     sout_buffer_t       *p_hdr;
 721     int                 i_stream;
 722     int                 i_maxbytespersec;
 723     int                 i_junk;
 724     buffer_out_t        bo;
 725
 726     p_hdr = sout_BufferNew( p_sout, HDR_SIZE );
 727     memset( p_hdr->p_buffer, 0, HDR_SIZE );
 728
 729     bo_Init( &bo, HDR_SIZE, p_hdr->p_buffer );
 730
 731     bo_AddFCC( &bo, "RIFF" );
 732     bo_AddDWordLE( &bo, p_mux->i_movi_size + HDR_SIZE - 8 + p_mux->i_idx1_size );
 733     bo_AddFCC( &bo, "AVI " );
 734
 735     bo_AddFCC( &bo, "LIST" );
 736     bo_AddDWordLE( &bo, HDR_SIZE - 8);
 737     bo_AddFCC( &bo, "hdrl" );
 738
 739     avi_HeaderAdd_avih( p_sout, &bo );
 740     for( i_stream = 0,i_maxbytespersec = 0; i_stream < p_mux->i_streams; i_stream++ )
 741     {
 742         avi_HeaderAdd_strl( p_sout, &bo, &p_mux->stream[i_stream] );
 743     }
 744
 745     i_junk = HDR_SIZE - bo.i_buffer - 8 - 12;
 746     bo_AddFCC( &bo, "JUNK" );
 747     bo_AddDWordLE( &bo, i_junk );
 748
 749     bo.i_buffer += i_junk;
 750     bo_AddFCC( &bo, "LIST" );
 751     bo_AddDWordLE( &bo, p_mux->i_movi_size + 4 );
 752     bo_AddFCC( &bo, "movi" );
 753
 754     return( p_hdr );
 755 }
 756
 757 static sout_buffer_t * avi_HeaderCreateidx1( sout_instance_t *p_sout )
 758 {
 759     sout_mux_t          *p_mux = (sout_mux_t*)p_sout->p_mux_data;
 760     sout_buffer_t       *p_idx1;
 761     uint32_t            i_idx1_size;
 762     unsigned int        i;
 763     buffer_out_t        bo;
 764
 765     i_idx1_size = 16 * p_mux->idx1.i_entry_count;
 766
 767     p_idx1 = sout_BufferNew( p_sout, i_idx1_size + 8 );
 768     memset( p_idx1->p_buffer, 0, i_idx1_size );
 769
 770     bo_Init( &bo, i_idx1_size, p_idx1->p_buffer );
 771     bo_AddFCC( &bo, "idx1" );
 772     bo_AddDWordLE( &bo, i_idx1_size );
 773
 774     for( i = 0; i < p_mux->idx1.i_entry_count; i++ )
 775     {
 776         bo_AddFCC( &bo, p_mux->idx1.entry[i].fcc );
 777         bo_AddDWordLE( &bo, p_mux->idx1.entry[i].i_flags );
 778         bo_AddDWordLE( &bo, p_mux->idx1.entry[i].i_pos );
 779         bo_AddDWordLE( &bo, p_mux->idx1.entry[i].i_length );
 780     }
 781
 782     return( p_idx1 );
 783 }
 784
 785