开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 查看源码
avi.c
资源名称：vlc-0.8.1.tar.gz　[点击查看]
上传用户：riyaled888
上传日期：2009-03-27
资源大小：7338k
文件大小：27k
源码类别：

多媒体

开发平台：

MultiPlatform

avi.c：源码内容
  1. /*****************************************************************************
  2.  * avi.c
  3.  *****************************************************************************
  4.  * Copyright (C) 2001, 2002 VideoLAN
  5.  * $Id: avi.c 8373 2004-08-04 20:09:31Z fenrir $
  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.  *****************************************************************************/
  24. /*****************************************************************************
  25.  * Preamble
  26.  *****************************************************************************/
  27. /* TODO: add OpenDML write support */
  29. #include <stdlib.h>
  31. #include <vlc/vlc.h>
  32. #include <vlc/input.h>
  33. #include <vlc/sout.h>
  35. #include "codecs.h"
  37. /*****************************************************************************
  38.  * Module descriptor
  39.  *****************************************************************************/
  40. static int  Open   ( vlc_object_t * );
  41. static void Close  ( vlc_object_t * );
  43. vlc_module_begin();
  44.     set_description( _("AVI muxer") );
  45.     set_capability( "sout mux", 5 );
  46.     add_shortcut( "avi" );
  47.     set_callbacks( Open, Close );
  48. vlc_module_end();
  51. /*****************************************************************************
  52.  * Local prototypes
  53.  *****************************************************************************/
  54. static int Control( sout_mux_t *, int, va_list );
  55. static int AddStream( sout_mux_t *, sout_input_t * );
  56. static int DelStream( sout_mux_t *, sout_input_t * );
  57. static int Mux      ( sout_mux_t * );
  59. typedef struct avi_stream_s
  60. {
  61.     int i_cat;
  63.     char fcc[4];
  65.     mtime_t i_duration;       // in 祍
  67.     int     i_frames;        // total frame count
  68.     int64_t i_totalsize;    // total stream size
  70.     float   f_fps;
  71.     int     i_bitrate;
  73.     BITMAPINFOHEADER    *p_bih;
  74.     WAVEFORMATEX        *p_wf;
  76. } avi_stream_t;
  78. typedef struct avi_idx1_entry_s
  79. {
  80.     char     fcc[4];
  81.     uint32_t i_flags;
  82.     uint32_t i_pos;
  83.     uint32_t i_length;
  85. } avi_idx1_entry_t;
  87. typedef struct avi_idx1_s
  88. {
  89.     unsigned int i_entry_count;
  90.     unsigned int i_entry_max;
  92.     avi_idx1_entry_t *entry;
  93. } avi_idx1_t;
  95. struct sout_mux_sys_t
  96. {
  97.     vlc_bool_t b_write_header;
  99.     int i_streams;
  100.     int i_stream_video;
  102.     off_t i_movi_size;
  103.     avi_stream_t stream[100];
  105.     avi_idx1_t idx1;
  106.     off_t i_idx1_size;
  108. };
  110. // FIXME FIXME
  111. #define HDR_SIZE 10240
  113. /* Flags in avih */
  114. #define AVIF_HASINDEX       0x00000010  // Index at end of file?
  115. #define AVIF_ISINTERLEAVED  0x00000100
  116. #define AVIF_TRUSTCKTYPE    0x00000800  // Use CKType to find key frames?
  118. /* Flags for index */
  119. #define AVIIF_KEYFRAME      0x00000010L /* this frame is a key frame.*/
  122. static block_t *avi_HeaderCreateRIFF( sout_mux_t * );
  123. static block_t *avi_HeaderCreateidx1( sout_mux_t * );
  125. static void SetFCC( uint8_t *p, char *fcc )
  126. {
  127.     memcpy( p, fcc, 4 );
  128. }
  130. /*****************************************************************************
  131.  * Open:
  132.  *****************************************************************************/
  133. static int Open( vlc_object_t *p_this )
  134. {
  135.     sout_mux_t      *p_mux = (sout_mux_t*)p_this;
  136.     sout_mux_sys_t  *p_sys = p_mux->p_sys;
  138.     msg_Dbg( p_mux, "AVI muxer opened" );
  140.     p_sys = malloc( sizeof( sout_mux_sys_t ) );
  141.     p_sys->i_streams = 0;
  142.     p_sys->i_stream_video = -1;
  143.     p_sys->i_movi_size = 0;
  145.     p_sys->idx1.i_entry_count = 0;
  146.     p_sys->idx1.i_entry_max = 10000;
  147.     p_sys->idx1.entry = calloc( p_sys->idx1.i_entry_max,
  148.                                 sizeof( avi_idx1_entry_t ) );
  149.     p_sys->b_write_header = VLC_TRUE;
  152.     p_mux->pf_control   = Control;
  153.     p_mux->pf_addstream = AddStream;
  154.     p_mux->pf_delstream = DelStream;
  155.     p_mux->pf_mux       = Mux;
  156.     p_mux->p_sys        = p_sys;
  158.     return VLC_SUCCESS;
  159. }
  161. /*****************************************************************************
  162.  * Close:
  163.  *****************************************************************************/
  164. static void Close( vlc_object_t * p_this )
  165. {
  166.     sout_mux_t      *p_mux = (sout_mux_t*)p_this;
  167.     sout_mux_sys_t  *p_sys = p_mux->p_sys;
  169.     block_t       *p_hdr, *p_idx1;
  170.     int                 i_stream;
  172.     msg_Dbg( p_mux, "AVI muxer closed" );
  174.     /* first create idx1 chunk (write at the end of the stream */
  175.     p_idx1 = avi_HeaderCreateidx1( p_mux );
  176.     p_sys->i_idx1_size = p_idx1->i_buffer;
  177.     sout_AccessOutWrite( p_mux->p_access, p_idx1 );
  179.     /* calculate some value for headers creations */
  180.     for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
  181.     {
  182.         avi_stream_t *p_stream;
  184.         p_stream = &p_sys->stream[i_stream];
  186.         p_stream->f_fps = 25;
  187.         if( p_stream->i_duration > 0 )
  188.         {
  189.             p_stream->f_fps = (float)p_stream->i_frames /
  190.                               ( (float)p_stream->i_duration /
  191.                                 (float)1000000 );
  192.         }
  193.         p_stream->i_bitrate = 128 * 1024;
  194.         if( p_stream->i_duration > 0 )
  195.         {
  196.             p_stream->i_bitrate =
  197.                 8 * (uint64_t)1000000 *
  198.                     (uint64_t)p_stream->i_totalsize /
  199.                     (uint64_t)p_stream->i_duration;
  200.         }
  201.         msg_Info( p_mux, "stream[%d] duration:"I64Fd" totalsize:"I64Fd
  202.                   " frames:%d fps:%f kb/s:%d",
  203.                   i_stream,
  204.                   (int64_t)p_stream->i_duration / (int64_t)1000000,
  205.                   p_stream->i_totalsize,
  206.                   p_stream->i_frames,
  207.                   p_stream->f_fps, p_stream->i_bitrate/1024 );
  208.     }
  210.     p_hdr = avi_HeaderCreateRIFF( p_mux );
  211.     sout_AccessOutSeek( p_mux->p_access, 0 );
  212.     sout_AccessOutWrite( p_mux->p_access, p_hdr );
  213. }
  215. static int Control( sout_mux_t *p_mux, int i_query, va_list args )
  216. {
  217.     vlc_bool_t *pb_bool;
  218.     char **ppsz;
  220.    switch( i_query )
  221.    {
  222.        case MUX_CAN_ADD_STREAM_WHILE_MUXING:
  223.            pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
  224.            *pb_bool = VLC_FALSE;
  225.            return VLC_SUCCESS;
  227.        case MUX_GET_ADD_STREAM_WAIT:
  228.            pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t * );
  229.            *pb_bool = VLC_TRUE;
  230.            return VLC_SUCCESS;
  232.        case MUX_GET_MIME:
  233.            ppsz = (char**)va_arg( args, char ** );
  234.            *ppsz = strdup( "video/avi" );
  235.            return VLC_SUCCESS;
  237.         default:
  238.             return VLC_EGENERIC;
  239.    }
  240. }
  242. static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input )
  243. {
  244.     sout_mux_sys_t  *p_sys = p_mux->p_sys;
  245.     avi_stream_t    *p_stream;
  247.     if( p_sys->i_streams >= 100 )
  248.     {
  249.         msg_Err( p_mux, "too many streams" );
  250.         return( -1 );
  251.     }
  253.     msg_Dbg( p_mux, "adding input" );
  254.     p_input->p_sys = malloc( sizeof( int ) );
  256.     *((int*)p_input->p_sys) = p_sys->i_streams;
  257.     p_stream = &p_sys->stream[p_sys->i_streams];
  259.     switch( p_input->p_fmt->i_cat )
  260.     {
  261.         case AUDIO_ES:
  262.             p_stream->i_cat = AUDIO_ES;
  263.             p_stream->fcc[0] = '0' + p_sys->i_streams / 10;
  264.             p_stream->fcc[1] = '0' + p_sys->i_streams % 10;
  265.             p_stream->fcc[2] = 'w';
  266.             p_stream->fcc[3] = 'b';
  268.             p_stream->p_bih = NULL;
  270.             p_stream->p_wf  = malloc( sizeof( WAVEFORMATEX ) +
  271.                                       p_input->p_fmt->i_extra );
  272. #define p_wf p_stream->p_wf
  273.             p_wf->cbSize = p_input->p_fmt->i_extra;
  274.             if( p_wf->cbSize > 0 )
  275.             {
  276.                 memcpy( &p_wf[1],
  277.                         p_input->p_fmt->p_extra,
  278.                         p_input->p_fmt->i_extra );
  279.             }
  280.             p_wf->nChannels      = p_input->p_fmt->audio.i_channels;
  281.             p_wf->nSamplesPerSec = p_input->p_fmt->audio.i_rate;
  282.             p_wf->nBlockAlign    = p_input->p_fmt->audio.i_blockalign;
  283.             p_wf->nAvgBytesPerSec= p_input->p_fmt->i_bitrate / 8;
  284.             p_wf->wBitsPerSample = 0;
  286.             switch( p_input->p_fmt->i_codec )
  287.             {
  288.                 case VLC_FOURCC( 'a', '5', '2', ' ' ):
  289.                     p_wf->wFormatTag = WAVE_FORMAT_A52;
  290.                     break;
  291.                 case VLC_FOURCC( 'm', 'p', 'g', 'a' ):
  292.                     p_wf->wFormatTag = WAVE_FORMAT_MPEGLAYER3;
  293.                     break;
  294.                 case VLC_FOURCC( 'w', 'm', 'a', '1' ):
  295.                     p_wf->wFormatTag = WAVE_FORMAT_WMA1;
  296.                     break;
  297.                 case VLC_FOURCC( 'w', 'm', 'a', '2' ):
  298.                     p_wf->wFormatTag = WAVE_FORMAT_WMA2;
  299.                     break;
  300.                 case VLC_FOURCC( 'w', 'm', 'a', '3' ):
  301.                     p_wf->wFormatTag = WAVE_FORMAT_WMA3;
  302.                     break;
  303.                     /* raw codec */
  304.                 case VLC_FOURCC( 'u', '8', ' ', ' ' ):
  305.                     p_wf->wFormatTag = WAVE_FORMAT_PCM;
  306.                     p_wf->nBlockAlign= p_wf->nChannels;
  307.                     p_wf->wBitsPerSample = 8;
  308.                     break;
  309.                 case VLC_FOURCC( 's', '1', '6', 'l' ):
  310.                     p_wf->wFormatTag = WAVE_FORMAT_PCM;
  311.                     p_wf->nBlockAlign= 2 * p_wf->nChannels;
  312.                     p_wf->wBitsPerSample = 16;
  313.                     break;
  314.                 case VLC_FOURCC( 's', '2', '4', 'l' ):
  315.                     p_wf->wFormatTag = WAVE_FORMAT_PCM;
  316.                     p_wf->nBlockAlign= 3 * p_wf->nChannels;
  317.                     p_wf->wBitsPerSample = 24;
  318.                     break;
  319.                 case VLC_FOURCC( 's', '3', '2', 'l' ):
  320.                     p_wf->wFormatTag = WAVE_FORMAT_PCM;
  321.                     p_wf->nBlockAlign= 4 * p_wf->nChannels;
  322.                     p_wf->wBitsPerSample = 32;
  323.                     break;
  324.                 default:
  325.                     return VLC_EGENERIC;
  326.             }
  327. #undef p_wf
  328.             break;
  329.         case VIDEO_ES:
  330.             p_stream->i_cat = VIDEO_ES;
  331.             p_stream->fcc[0] = '0' + p_sys->i_streams / 10;
  332.             p_stream->fcc[1] = '0' + p_sys->i_streams % 10;
  333.             p_stream->fcc[2] = 'd';
  334.             p_stream->fcc[3] = 'c';
  335.             if( p_sys->i_stream_video < 0 )
  336.             {
  337.                 p_sys->i_stream_video = p_sys->i_streams;
  338.             }
  339.             p_stream->p_wf  = NULL;
  340.             p_stream->p_bih = malloc( sizeof( BITMAPINFOHEADER ) +
  341.                                       p_input->p_fmt->i_extra );
  342. #define p_bih p_stream->p_bih
  343.             p_bih->biSize  = sizeof( BITMAPINFOHEADER ) +
  344.                              p_input->p_fmt->i_extra;
  345.             if( p_input->p_fmt->i_extra > 0 )
  346.             {
  347.                 memcpy( &p_bih[1],
  348.                         p_input->p_fmt->p_extra,
  349.                         p_input->p_fmt->i_extra );
  350.             }
  351.             p_bih->biWidth = p_input->p_fmt->video.i_width;
  352.             p_bih->biHeight= p_input->p_fmt->video.i_height;
  353.             p_bih->biPlanes= 1;
  354.             p_bih->biBitCount       = 24;
  355.             p_bih->biSizeImage      = 0;
  356.             p_bih->biXPelsPerMeter  = 0;
  357.             p_bih->biYPelsPerMeter  = 0;
  358.             p_bih->biClrUsed        = 0;
  359.             p_bih->biClrImportant   = 0;
  360.             switch( p_input->p_fmt->i_codec )
  361.             {
  362.                 case VLC_FOURCC( 'm', 'p', '4', 'v' ):
  363.                     p_bih->biCompression = VLC_FOURCC( 'X', 'V', 'I', 'D' );
  364.                     break;
  365.                 default:
  366.                     p_bih->biCompression = p_input->p_fmt->i_codec;
  367.                     break;
  368.             }
  369. #undef p_bih
  370.             break;
  371.         default:
  372.             return( VLC_EGENERIC );
  373.     }
  374.     p_stream->i_totalsize = 0;
  375.     p_stream->i_frames    = 0;
  376.     p_stream->i_duration  = 0;
  378.     /* fixed later */
  379.     p_stream->f_fps = 25;
  380.     p_stream->i_bitrate = 128 * 1024;
  382.     p_sys->i_streams++;
  383.     return( VLC_SUCCESS );
  384. }
  386. static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input )
  387. {
  389.     msg_Dbg( p_mux, "removing input" );
  391.     free( p_input->p_sys );
  392.     return( 0 );
  393. }
  395. static int Mux      ( sout_mux_t *p_mux )
  396. {
  397.     sout_mux_sys_t  *p_sys = p_mux->p_sys;
  398.     avi_stream_t    *p_stream;
  399.     int i_stream;
  400.     int i;
  402.     if( p_sys->b_write_header )
  403.     {
  404.         block_t *p_hdr;
  406.         msg_Dbg( p_mux, "writing header" );
  408.         p_hdr = avi_HeaderCreateRIFF( p_mux );
  409.         sout_AccessOutWrite( p_mux->p_access, p_hdr );
  411.         p_sys->b_write_header = VLC_FALSE;
  412.     }
  414.     for( i = 0; i < p_mux->i_nb_inputs; i++ )
  415.     {
  416.         int i_count;
  417.         block_fifo_t *p_fifo;
  419.         i_stream = *((int*)p_mux->pp_inputs[i]->p_sys );
  420.         p_stream = &p_sys->stream[i_stream];
  422.         p_fifo = p_mux->pp_inputs[i]->p_fifo;
  423.         i_count = p_fifo->i_depth;
  424.         while( i_count > 1 )
  425.         {
  426.             avi_idx1_entry_t *p_idx;
  427.             block_t *p_data;
  429.             p_data = block_FifoGet( p_fifo );
  430.             if( p_fifo->i_depth > 0 )
  431.             {
  432.                 block_t *p_next = block_FifoShow( p_fifo );
  433.                 p_data->i_length = p_next->i_dts - p_data->i_dts;
  434.             }
  436.             p_stream->i_frames++;
  437.             if( p_data->i_length < 0 )
  438.             {
  439.                 msg_Warn( p_mux, "argg length < 0 l" );
  440.                 block_Release( p_data );
  441.                 i_count--;
  442.                 continue;
  443.             }
  444.             p_stream->i_duration  += p_data->i_length;
  445.             p_stream->i_totalsize += p_data->i_buffer;
  447.             /* add idx1 entry for this frame */
  448.             p_idx = &p_sys->idx1.entry[p_sys->idx1.i_entry_count];
  449.             memcpy( p_idx->fcc, p_stream->fcc, 4 );
  450.             p_idx->i_flags = AVIIF_KEYFRAME;
  451.             p_idx->i_pos   = p_sys->i_movi_size + 4;
  452.             p_idx->i_length= p_data->i_buffer;
  453.             p_sys->idx1.i_entry_count++;
  454.             if( p_sys->idx1.i_entry_count >= p_sys->idx1.i_entry_max )
  455.             {
  456.                 p_sys->idx1.i_entry_max += 10000;
  457.                 p_sys->idx1.entry = realloc( p_sys->idx1.entry,
  458.                                              p_sys->idx1.i_entry_max * sizeof( avi_idx1_entry_t ) );
  459.             }
  461.             p_data = block_Realloc( p_data, 8, p_data->i_buffer );
  462.             if( p_data )
  463.             {
  464.                 SetFCC( p_data->p_buffer, p_stream->fcc );
  465.                 SetDWLE( p_data->p_buffer + 4, p_data->i_buffer - 8 );
  467.                 if( p_data->i_buffer & 0x01 )
  468.                 {
  469.                     p_data = block_Realloc( p_data, 0, p_data->i_buffer + 1 );
  470.                 }
  472.                 p_sys->i_movi_size += p_data->i_buffer;
  473.                 sout_AccessOutWrite( p_mux->p_access, p_data );
  474.             }
  476.             i_count--;
  477.         }
  479.     }
  480.     return( 0 );
  481. }
  483. /****************************************************************************/
  484. /****************************************************************************/
  485. /****************************************************************************/
  486. /****************************************************************************/
  488. typedef struct buffer_out_s
  489. {
  490.     int      i_buffer_size;
  491.     int      i_buffer;
  492.     uint8_t  *p_buffer;
  494. } buffer_out_t;
  496. static void bo_Init( buffer_out_t *p_bo, int i_size, uint8_t *p_buffer )
  497. {
  498.     p_bo->i_buffer_size = i_size;
  499.     p_bo->i_buffer = 0;
  500.     p_bo->p_buffer = p_buffer;
  501. }
  502. static void bo_AddByte( buffer_out_t *p_bo, uint8_t i )
  503. {
  504.     if( p_bo->i_buffer < p_bo->i_buffer_size )
  505.     {
  506.         p_bo->p_buffer[p_bo->i_buffer] = i;
  507.     }
  508.     p_bo->i_buffer++;
  509. }
  510. static void bo_AddWordLE( buffer_out_t *p_bo, uint16_t i )
  511. {
  512.     bo_AddByte( p_bo, i &0xff );
  513.     bo_AddByte( p_bo, ( ( i >> 8) &0xff ) );
  514. }
  515. static void bo_AddWordBE( buffer_out_t *p_bo, uint16_t i )
  516. {
  517.     bo_AddByte( p_bo, ( ( i >> 8) &0xff ) );
  518.     bo_AddByte( p_bo, i &0xff );
  519. }
  520. static void bo_AddDWordLE( buffer_out_t *p_bo, uint32_t i )
  521. {
  522.     bo_AddWordLE( p_bo, i &0xffff );
  523.     bo_AddWordLE( p_bo, ( ( i >> 16) &0xffff ) );
  524. }
  525. static void bo_AddDWordBE( buffer_out_t *p_bo, uint32_t i )
  526. {
  527.     bo_AddWordBE( p_bo, ( ( i >> 16) &0xffff ) );
  528.     bo_AddWordBE( p_bo, i &0xffff );
  529. }
  530. #if 0
  531. static void bo_AddLWordLE( buffer_out_t *p_bo, uint64_t i )
  532. {
  533.     bo_AddDWordLE( p_bo, i &0xffffffff );
  534.     bo_AddDWordLE( p_bo, ( ( i >> 32) &0xffffffff ) );
  535. }
  536. static void bo_AddLWordBE( buffer_out_t *p_bo, uint64_t i )
  537. {
  538.     bo_AddDWordBE( p_bo, ( ( i >> 32) &0xffffffff ) );
  539.     bo_AddDWordBE( p_bo, i &0xffffffff );
  540. }
  541. #endif
  543. static void bo_AddFCC( buffer_out_t *p_bo, char *fcc )
  544. {
  545.     bo_AddByte( p_bo, fcc[0] );
  546.     bo_AddByte( p_bo, fcc[1] );
  547.     bo_AddByte( p_bo, fcc[2] );
  548.     bo_AddByte( p_bo, fcc[3] );
  549. }
  551. static void bo_AddMem( buffer_out_t *p_bo, int i_size, uint8_t *p_mem )
  552. {
  553.     int i;
  555.     for( i = 0; i < i_size; i++ )
  556.     {
  557.         bo_AddByte( p_bo, p_mem[i] );
  558.     }
  559. }
  561. /****************************************************************************
  562.  ****************************************************************************
  563.  **
  564.  ** avi header generation
  565.  **
  566.  ****************************************************************************
  567.  ****************************************************************************/
  568. #define AVI_BOX_ENTER( fcc ) 
  569.     buffer_out_t _bo_sav_; 
  570.     bo_AddFCC( p_bo, fcc ); 
  571.     _bo_sav_ = *p_bo; 
  572.     bo_AddDWordLE( p_bo, 0 )
  574. #define AVI_BOX_ENTER_LIST( fcc ) 
  575.     AVI_BOX_ENTER( "LIST" ); 
  576.     bo_AddFCC( p_bo, fcc )
  578. #define AVI_BOX_EXIT( i_err ) 
  579.     if( p_bo->i_buffer&0x01 ) bo_AddByte( p_bo, 0 ); 
  580.     bo_AddDWordLE( &_bo_sav_, p_bo->i_buffer - _bo_sav_.i_buffer - 4 ); 
  581.     return( i_err );
  583. static int avi_HeaderAdd_avih( sout_mux_t *p_mux,
  584.                                buffer_out_t *p_bo )
  585. {
  586.     sout_mux_sys_t  *p_sys = p_mux->p_sys;
  587.     avi_stream_t    *p_video = NULL;
  588.     int         i_stream;
  589.     uint32_t    i_microsecperframe;
  590.     int         i_maxbytespersec;
  591.     int         i_totalframes;
  592.     AVI_BOX_ENTER( "avih" );
  594.     if( p_sys->i_stream_video >= 0 )
  595.     {
  596.         p_video = &p_sys->stream[p_sys->i_stream_video];
  597.         if( p_video->i_frames <= 0 )
  598.         {
  599.         //    p_video = NULL;
  600.         }
  601.     }
  603.     if( p_video )
  604.     {
  605.         i_microsecperframe =
  606.             (uint32_t)( (float)1000000 /
  607.                         (float)p_sys->stream[p_sys->i_stream_video].f_fps );
  608.         i_totalframes = p_sys->stream[p_sys->i_stream_video].i_frames;
  609.     }
  610.     else
  611.     {
  612.         msg_Warn( p_mux, "avi file without video track isn't a good idea..." );
  613.         i_microsecperframe = 0;
  614.         i_totalframes = 0;
  615.     }
  617.     for( i_stream = 0,i_maxbytespersec = 0; i_stream < p_sys->i_streams; i_stream++ )
  618.     {
  619.         if( p_sys->stream[i_stream].i_duration > 0 )
  620.         {
  621.             i_maxbytespersec +=
  622.                 p_sys->stream[p_sys->i_stream_video].i_totalsize /
  623.                 p_sys->stream[p_sys->i_stream_video].i_duration;
  624.         }
  625.     }
  627.     bo_AddDWordLE( p_bo, i_microsecperframe );
  628.     bo_AddDWordLE( p_bo, i_maxbytespersec );
  629.     bo_AddDWordLE( p_bo, 0 );                   /* padding */
  630.     bo_AddDWordLE( p_bo, AVIF_TRUSTCKTYPE |
  631.                          AVIF_HASINDEX |
  632.                          AVIF_ISINTERLEAVED );  /* flags */
  633.     bo_AddDWordLE( p_bo, i_totalframes );
  634.     bo_AddDWordLE( p_bo, 0 );                   /* initial frame */
  635.     bo_AddDWordLE( p_bo, p_sys->i_streams );    /* streams count */
  636.     bo_AddDWordLE( p_bo, 1024 * 1024 );         /* suggested buffer size */
  637.     if( p_video )
  638.     {
  639.         bo_AddDWordLE( p_bo, p_video->p_bih->biWidth );
  640.         bo_AddDWordLE( p_bo, p_video->p_bih->biHeight );
  641.     }
  642.     else
  643.     {
  644.         bo_AddDWordLE( p_bo, 0 );
  645.         bo_AddDWordLE( p_bo, 0 );
  646.     }
  647.     bo_AddDWordLE( p_bo, 0 );                   /* ???? */
  648.     bo_AddDWordLE( p_bo, 0 );                   /* ???? */
  649.     bo_AddDWordLE( p_bo, 0 );                   /* ???? */
  650.     bo_AddDWordLE( p_bo, 0 );                   /* ???? */
  652.     AVI_BOX_EXIT( 0 );
  653. }
  654. static int avi_HeaderAdd_strh( sout_mux_t   *p_mux,
  655.                                buffer_out_t *p_bo,
  656.                                avi_stream_t *p_stream )
  657. {
  658.     AVI_BOX_ENTER( "strh" );
  660.     switch( p_stream->i_cat )
  661.     {
  662.         case VIDEO_ES:
  663.             {
  664.                 bo_AddFCC( p_bo, "vids" );
  665.                 bo_AddDWordBE( p_bo, p_stream->p_bih->biCompression );
  666.                 bo_AddDWordLE( p_bo, 0 );   /* flags */
  667.                 bo_AddWordLE(  p_bo, 0 );   /* priority */
  668.                 bo_AddWordLE(  p_bo, 0 );   /* langage */
  669.                 bo_AddDWordLE( p_bo, 0 );   /* initial frame */
  670.                 bo_AddDWordLE( p_bo, 1000 );/* scale */
  671.                 bo_AddDWordLE( p_bo, (uint32_t)( 1000 * p_stream->f_fps ));
  672.                 bo_AddDWordLE( p_bo, 0 );   /* start */
  673.                 bo_AddDWordLE( p_bo, p_stream->i_frames );
  674.                 bo_AddDWordLE( p_bo, 1024 * 1024 );
  675.                 bo_AddDWordLE( p_bo, -1 );  /* quality */
  676.                 bo_AddDWordLE( p_bo, 0 );   /* samplesize */
  677.                 bo_AddWordLE(  p_bo, 0 );   /* ??? */
  678.                 bo_AddWordLE(  p_bo, 0 );   /* ??? */
  679.                 bo_AddWordLE(  p_bo, p_stream->p_bih->biWidth );
  680.                 bo_AddWordLE(  p_bo, p_stream->p_bih->biHeight );
  681.             }
  682.             break;
  683.         case AUDIO_ES:
  684.             {
  685.                 int i_rate, i_scale, i_samplesize;
  687.                 i_samplesize = p_stream->p_wf->nBlockAlign;
  688.                 if( i_samplesize > 1 )
  689.                 {
  690.                     i_scale = i_samplesize;
  691.                     i_rate = /*i_scale **/ p_stream->i_bitrate / 8;
  692.                 }
  693.                 else
  694.                 {
  695.                     i_samplesize = 1;
  696.                     i_scale = 1000;
  697.                     i_rate = 1000 * p_stream->i_bitrate / 8;
  698.                 }
  699.                 bo_AddFCC( p_bo, "auds" );
  700.                 bo_AddDWordLE( p_bo, 0 );   /* tag */
  701.                 bo_AddDWordLE( p_bo, 0 );   /* flags */
  702.                 bo_AddWordLE(  p_bo, 0 );   /* priority */
  703.                 bo_AddWordLE(  p_bo, 0 );   /* langage */
  704.                 bo_AddDWordLE( p_bo, 0 );   /* initial frame */
  705.                 bo_AddDWordLE( p_bo, i_scale );/* scale */
  706.                 bo_AddDWordLE( p_bo, i_rate );
  707.                 bo_AddDWordLE( p_bo, 0 );   /* start */
  708.                 bo_AddDWordLE( p_bo, p_stream->i_frames );
  709.                 bo_AddDWordLE( p_bo, 10 * 1024 );
  710.                 bo_AddDWordLE( p_bo, -1 );  /* quality */
  711.                 bo_AddDWordLE( p_bo, i_samplesize );
  712.                 bo_AddWordLE(  p_bo, 0 );   /* ??? */
  713.                 bo_AddWordLE(  p_bo, 0 );   /* ??? */
  714.                 bo_AddWordLE(  p_bo, 0 );
  715.                 bo_AddWordLE(  p_bo, 0 );
  716.             }
  717.             break;
  718.     }
  720.     AVI_BOX_EXIT( 0 );
  721. }
  723. static int avi_HeaderAdd_strf( sout_mux_t *p_mux,
  724.                                buffer_out_t *p_bo,
  725.                                avi_stream_t *p_stream )
  726. {
  727.     AVI_BOX_ENTER( "strf" );
  729.     switch( p_stream->i_cat )
  730.     {
  731.         case AUDIO_ES:
  732.             bo_AddWordLE( p_bo, p_stream->p_wf->wFormatTag );
  733.             bo_AddWordLE( p_bo, p_stream->p_wf->nChannels );
  734.             bo_AddDWordLE( p_bo, p_stream->p_wf->nSamplesPerSec );
  735.             bo_AddDWordLE( p_bo, p_stream->p_wf->nAvgBytesPerSec );
  736.             bo_AddWordLE( p_bo, p_stream->p_wf->nBlockAlign );
  737.             bo_AddWordLE( p_bo, p_stream->p_wf->wBitsPerSample );
  738.             bo_AddWordLE( p_bo, p_stream->p_wf->cbSize );
  739.             bo_AddMem( p_bo, p_stream->p_wf->cbSize, (uint8_t*)&p_stream->p_wf[1] );
  740.             break;
  741.         case VIDEO_ES:
  742.             bo_AddDWordLE( p_bo, p_stream->p_bih->biSize );
  743.             bo_AddDWordLE( p_bo, p_stream->p_bih->biWidth );
  744.             bo_AddDWordLE( p_bo, p_stream->p_bih->biHeight );
  745.             bo_AddWordLE( p_bo, p_stream->p_bih->biPlanes );
  746.             bo_AddWordLE( p_bo, p_stream->p_bih->biBitCount );
  747.             if( VLC_FOURCC( 0, 0, 0, 1 ) == 0x00000001 )
  748.             {
  749.                 bo_AddDWordBE( p_bo, p_stream->p_bih->biCompression );
  750.             }
  751.             else
  752.             {
  753.                 bo_AddDWordLE( p_bo, p_stream->p_bih->biCompression );
  754.             }
  755.             bo_AddDWordLE( p_bo, p_stream->p_bih->biSizeImage );
  756.             bo_AddDWordLE( p_bo, p_stream->p_bih->biXPelsPerMeter );
  757.             bo_AddDWordLE( p_bo, p_stream->p_bih->biYPelsPerMeter );
  758.             bo_AddDWordLE( p_bo, p_stream->p_bih->biClrUsed );
  759.             bo_AddDWordLE( p_bo, p_stream->p_bih->biClrImportant );
  760.             bo_AddMem( p_bo,
  761.                        p_stream->p_bih->biSize - sizeof( BITMAPINFOHEADER ),
  762.                        (uint8_t*)&p_stream->p_bih[1] );
  763.             break;
  764.     }
  766.     AVI_BOX_EXIT( 0 );
  767. }
  769. static int avi_HeaderAdd_strl( sout_mux_t *p_mux,
  770.                                buffer_out_t *p_bo,
  771.                                avi_stream_t *p_stream )
  772. {
  773.     AVI_BOX_ENTER_LIST( "strl" );
  775.     avi_HeaderAdd_strh( p_mux, p_bo, p_stream );
  776.     avi_HeaderAdd_strf( p_mux, p_bo, p_stream );
  778.     AVI_BOX_EXIT( 0 );
  779. }
  781. static block_t *avi_HeaderCreateRIFF( sout_mux_t *p_mux )
  782. {
  783.     sout_mux_sys_t      *p_sys = p_mux->p_sys;
  784.     block_t       *p_hdr;
  785.     int                 i_stream;
  786.     int                 i_maxbytespersec;
  787.     int                 i_junk;
  788.     buffer_out_t        bo;
  790.     p_hdr = block_New( p_mux, HDR_SIZE );
  791.     memset( p_hdr->p_buffer, 0, HDR_SIZE );
  793.     bo_Init( &bo, HDR_SIZE, p_hdr->p_buffer );
  795.     bo_AddFCC( &bo, "RIFF" );
  796.     bo_AddDWordLE( &bo, p_sys->i_movi_size + HDR_SIZE - 8 + p_sys->i_idx1_size );
  797.     bo_AddFCC( &bo, "AVI " );
  799.     bo_AddFCC( &bo, "LIST" );
  800.     bo_AddDWordLE( &bo, HDR_SIZE - 8);
  801.     bo_AddFCC( &bo, "hdrl" );
  803.     avi_HeaderAdd_avih( p_mux, &bo );
  804.     for( i_stream = 0,i_maxbytespersec = 0; i_stream < p_sys->i_streams; i_stream++ )
  805.     {
  806.         avi_HeaderAdd_strl( p_mux, &bo, &p_sys->stream[i_stream] );
  807.     }
  809.     i_junk = HDR_SIZE - bo.i_buffer - 8 - 12;
  810.     bo_AddFCC( &bo, "JUNK" );
  811.     bo_AddDWordLE( &bo, i_junk );
  813.     bo.i_buffer += i_junk;
  814.     bo_AddFCC( &bo, "LIST" );
  815.     bo_AddDWordLE( &bo, p_sys->i_movi_size + 4 );
  816.     bo_AddFCC( &bo, "movi" );
  818.     return( p_hdr );
  819. }
  821. static block_t * avi_HeaderCreateidx1( sout_mux_t *p_mux )
  822. {
  823.     sout_mux_sys_t      *p_sys = p_mux->p_sys;
  824.     block_t       *p_idx1;
  825.     uint32_t            i_idx1_size;
  826.     unsigned int        i;
  827.     buffer_out_t        bo;
  829.     i_idx1_size = 16 * p_sys->idx1.i_entry_count;
  831.     p_idx1 = block_New( p_mux, i_idx1_size + 8 );
  832.     memset( p_idx1->p_buffer, 0, i_idx1_size );
  834.     bo_Init( &bo, i_idx1_size, p_idx1->p_buffer );
  835.     bo_AddFCC( &bo, "idx1" );
  836.     bo_AddDWordLE( &bo, i_idx1_size );
  838.     for( i = 0; i < p_sys->idx1.i_entry_count; i++ )
  839.     {
  840.         bo_AddFCC( &bo, p_sys->idx1.entry[i].fcc );
  841.         bo_AddDWordLE( &bo, p_sys->idx1.entry[i].i_flags );
  842.         bo_AddDWordLE( &bo, p_sys->idx1.entry[i].i_pos );
  843.         bo_AddDWordLE( &bo, p_sys->idx1.entry[i].i_length );
  844.     }
  846.     return( p_idx1 );
  847. }