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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
avi.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：28k
源码类别：

midi

开发平台：

Unix_Linux

avi.c：源码内容
  1. /*****************************************************************************
  2.  * avi.c
  3.  *****************************************************************************
  4.  * Copyright (C) 2001, 2002 the VideoLAN team
  5.  * $Id: 2e7cb9f5389c622920c2bc58a53189424ccbf2c9 $
  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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22.  *****************************************************************************/
  24. /*****************************************************************************
  25.  * Preamble
  26.  *****************************************************************************/
  27. /* TODO: add OpenDML write support */
  30. #ifdef HAVE_CONFIG_H
  31. # include "config.h"
  32. #endif
  34. #include <vlc_common.h>
  35. #include <vlc_plugin.h>
  36. #include <vlc_sout.h>
  37. #include <vlc_block.h>
  38. #include <vlc_codecs.h>
  40. /*****************************************************************************
  41.  * Module descriptor
  42.  *****************************************************************************/
  43. static int  Open   ( vlc_object_t * );
  44. static void Close  ( vlc_object_t * );
  46. vlc_module_begin ()
  47.     set_description( N_("AVI muxer") )
  48.     set_category( CAT_SOUT )
  49.     set_subcategory( SUBCAT_SOUT_MUX )
  50.     set_capability( "sout mux", 5 )
  51.     add_shortcut( "avi" )
  52.     set_callbacks( Open, Close )
  53. vlc_module_end ()
  56. /*****************************************************************************
  57.  * Local prototypes
  58.  *****************************************************************************/
  59. static int Control( sout_mux_t *, int, va_list );
  60. static int AddStream( sout_mux_t *, sout_input_t * );
  61. static int DelStream( sout_mux_t *, sout_input_t * );
  62. static int Mux      ( sout_mux_t * );
  64. typedef struct avi_stream_s
  65. {
  66.     int i_cat;
  68.     char fcc[4];
  70.     mtime_t i_duration;       // in µs
  72.     int     i_frames;        // total frame count
  73.     int64_t i_totalsize;    // total stream size
  75.     float   f_fps;
  76.     int     i_bitrate;
  78.     BITMAPINFOHEADER    *p_bih;
  79.     WAVEFORMATEX        *p_wf;
  81. } avi_stream_t;
  83. typedef struct avi_idx1_entry_s
  84. {
  85.     char     fcc[4];
  86.     uint32_t i_flags;
  87.     uint32_t i_pos;
  88.     uint32_t i_length;
  90. } avi_idx1_entry_t;
  92. typedef struct avi_idx1_s
  93. {
  94.     unsigned int i_entry_count;
  95.     unsigned int i_entry_max;
  97.     avi_idx1_entry_t *entry;
  98. } avi_idx1_t;
  100. struct sout_mux_sys_t
  101. {
  102.     bool b_write_header;
  104.     int i_streams;
  105.     int i_stream_video;
  107.     off_t i_movi_size;
  108.     avi_stream_t stream[100];
  110.     avi_idx1_t idx1;
  111.     off_t i_idx1_size;
  113. };
  115. // FIXME FIXME
  116. #define HDR_SIZE 10240
  118. /* Flags in avih */
  119. #define AVIF_HASINDEX       0x00000010  // Index at end of file?
  120. #define AVIF_ISINTERLEAVED  0x00000100
  121. #define AVIF_TRUSTCKTYPE    0x00000800  // Use CKType to find key frames?
  123. /* Flags for index */
  124. #define AVIIF_KEYFRAME      0x00000010L /* this frame is a key frame.*/
  127. static block_t *avi_HeaderCreateRIFF( sout_mux_t * );
  128. static block_t *avi_HeaderCreateidx1( sout_mux_t * );
  130. static void SetFCC( uint8_t *p, char *fcc )
  131. {
  132.     memcpy( p, fcc, 4 );
  133. }
  135. /*****************************************************************************
  136.  * Open:
  137.  *****************************************************************************/
  138. static int Open( vlc_object_t *p_this )
  139. {
  140.     sout_mux_t      *p_mux = (sout_mux_t*)p_this;
  141.     sout_mux_sys_t  *p_sys = p_mux->p_sys;
  143.     msg_Dbg( p_mux, "AVI muxer opened" );
  145.     p_sys = malloc( sizeof( sout_mux_sys_t ) );
  146.     if( !p_sys )
  147.         return VLC_ENOMEM;
  148.     p_sys->i_streams = 0;
  149.     p_sys->i_stream_video = -1;
  150.     p_sys->i_movi_size = 0;
  152.     p_sys->idx1.i_entry_count = 0;
  153.     p_sys->idx1.i_entry_max = 10000;
  154.     p_sys->idx1.entry = calloc( p_sys->idx1.i_entry_max,
  155.                                 sizeof( avi_idx1_entry_t ) );
  156.     if( !p_sys->idx1.entry )
  157.     {
  158.         free( p_sys );
  159.         return VLC_ENOMEM;
  160.     }
  161.     p_sys->b_write_header = true;
  164.     p_mux->pf_control   = Control;
  165.     p_mux->pf_addstream = AddStream;
  166.     p_mux->pf_delstream = DelStream;
  167.     p_mux->pf_mux       = Mux;
  168.     p_mux->p_sys        = p_sys;
  170.     return VLC_SUCCESS;
  171. }
  173. /*****************************************************************************
  174.  * Close:
  175.  *****************************************************************************/
  176. static void Close( vlc_object_t * p_this )
  177. {
  178.     sout_mux_t      *p_mux = (sout_mux_t*)p_this;
  179.     sout_mux_sys_t  *p_sys = p_mux->p_sys;
  181.     block_t       *p_hdr, *p_idx1;
  182.     int                 i_stream;
  184.     msg_Dbg( p_mux, "AVI muxer closed" );
  186.     /* first create idx1 chunk (write at the end of the stream */
  187.     p_idx1 = avi_HeaderCreateidx1( p_mux );
  188.     p_sys->i_idx1_size = p_idx1->i_buffer;
  189.     sout_AccessOutWrite( p_mux->p_access, p_idx1 );
  191.     /* calculate some value for headers creations */
  192.     for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
  193.     {
  194.         avi_stream_t *p_stream;
  196.         p_stream = &p_sys->stream[i_stream];
  198.         p_stream->f_fps = 25;
  199.         if( p_stream->i_duration > 0 )
  200.         {
  201.             p_stream->f_fps = (float)p_stream->i_frames /
  202.                               ( (float)p_stream->i_duration /
  203.                                 (float)1000000 );
  204.         }
  205.         p_stream->i_bitrate = 128 * 1024;
  206.         if( p_stream->i_duration > 0 )
  207.         {
  208.             p_stream->i_bitrate =
  209.                 8 * (uint64_t)1000000 *
  210.                     (uint64_t)p_stream->i_totalsize /
  211.                     (uint64_t)p_stream->i_duration;
  212.         }
  213.         msg_Info( p_mux, "stream[%d] duration:%"PRId64" totalsize:%"PRId64
  214.                   " frames:%d fps:%f kb/s:%d",
  215.                   i_stream,
  216.                   (int64_t)p_stream->i_duration / (int64_t)1000000,
  217.                   p_stream->i_totalsize,
  218.                   p_stream->i_frames,
  219.                   p_stream->f_fps, p_stream->i_bitrate/1024 );
  220.     }
  222.     p_hdr = avi_HeaderCreateRIFF( p_mux );
  223.     sout_AccessOutSeek( p_mux->p_access, 0 );
  224.     sout_AccessOutWrite( p_mux->p_access, p_hdr );
  225. }
  227. static int Control( sout_mux_t *p_mux, int i_query, va_list args )
  228. {
  229.     VLC_UNUSED(p_mux);
  230.     bool *pb_bool;
  231.     char **ppsz;
  233.    switch( i_query )
  234.    {
  235.        case MUX_CAN_ADD_STREAM_WHILE_MUXING:
  236.            pb_bool = (bool*)va_arg( args, bool * );
  237.            *pb_bool = false;
  238.            return VLC_SUCCESS;
  240.        case MUX_GET_ADD_STREAM_WAIT:
  241.            pb_bool = (bool*)va_arg( args, bool * );
  242.            *pb_bool = true;
  243.            return VLC_SUCCESS;
  245.        case MUX_GET_MIME:
  246.            ppsz = (char**)va_arg( args, char ** );
  247.            *ppsz = strdup( "video/avi" );
  248.            return VLC_SUCCESS;
  250.         default:
  251.             return VLC_EGENERIC;
  252.    }
  253. }
  255. static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input )
  256. {
  257.     sout_mux_sys_t  *p_sys = p_mux->p_sys;
  258.     avi_stream_t    *p_stream;
  260.     if( p_sys->i_streams >= 100 )
  261.     {
  262.         msg_Err( p_mux, "too many streams" );
  263.         return VLC_EGENERIC;
  264.     }
  266.     msg_Dbg( p_mux, "adding input" );
  267.     p_input->p_sys = malloc( sizeof( int ) );
  268.     if( !p_input->p_sys )
  269.         return VLC_ENOMEM;
  271.     *((int*)p_input->p_sys) = p_sys->i_streams;
  272.     p_stream = &p_sys->stream[p_sys->i_streams];
  274.     switch( p_input->p_fmt->i_cat )
  275.     {
  276.         case AUDIO_ES:
  277.             p_stream->i_cat = AUDIO_ES;
  278.             p_stream->fcc[0] = '0' + p_sys->i_streams / 10;
  279.             p_stream->fcc[1] = '0' + p_sys->i_streams % 10;
  280.             p_stream->fcc[2] = 'w';
  281.             p_stream->fcc[3] = 'b';
  283.             p_stream->p_bih = NULL;
  285.             p_stream->p_wf  = malloc( sizeof( WAVEFORMATEX ) +
  286.                                       p_input->p_fmt->i_extra );
  287.             if( !p_stream->p_wf )
  288.             {
  289.                 free( p_input->p_sys );
  290.                 return VLC_ENOMEM;
  291.             }
  292. #define p_wf p_stream->p_wf
  293.             p_wf->cbSize = p_input->p_fmt->i_extra;
  294.             if( p_wf->cbSize > 0 )
  295.             {
  296.                 memcpy( &p_wf[1],
  297.                         p_input->p_fmt->p_extra,
  298.                         p_input->p_fmt->i_extra );
  299.             }
  300.             p_wf->nChannels      = p_input->p_fmt->audio.i_channels;
  301.             p_wf->nSamplesPerSec = p_input->p_fmt->audio.i_rate;
  302.             p_wf->nBlockAlign    = p_input->p_fmt->audio.i_blockalign;
  303.             p_wf->nAvgBytesPerSec= p_input->p_fmt->i_bitrate / 8;
  304.             p_wf->wBitsPerSample = 0;
  306.             switch( p_input->p_fmt->i_codec )
  307.             {
  308.                 case VLC_FOURCC( 'a', '5', '2', ' ' ):
  309.                     p_wf->wFormatTag = WAVE_FORMAT_A52;
  310.                     break;
  311.                 case VLC_FOURCC( 'm', 'p', 'g', 'a' ):
  312.                 case VLC_FOURCC( 'm', 'p', '3', ' ' ):
  313.                     p_wf->wFormatTag = WAVE_FORMAT_MPEGLAYER3;
  314.                     break;
  315.                 case VLC_FOURCC( 'w', 'm', 'a', '1' ):
  316.                     p_wf->wFormatTag = WAVE_FORMAT_WMA1;
  317.                     break;
  318.                 case VLC_FOURCC( 'w', 'm', 'a', ' ' ):
  319.                 case VLC_FOURCC( 'w', 'm', 'a', '2' ):
  320.                     p_wf->wFormatTag = WAVE_FORMAT_WMA2;
  321.                     break;
  322.                 case VLC_FOURCC( 'w', 'm', 'a', 'p' ):
  323.                     p_wf->wFormatTag = WAVE_FORMAT_WMAP;
  324.                     break;
  325.                 case VLC_FOURCC( 'w', 'm', 'a', 'l' ):
  326.                     p_wf->wFormatTag = WAVE_FORMAT_WMAL;
  327.                     break;
  328.                     /* raw codec */
  329.                 case VLC_FOURCC( 'u', '8', ' ', ' ' ):
  330.                     p_wf->wFormatTag = WAVE_FORMAT_PCM;
  331.                     p_wf->nBlockAlign= p_wf->nChannels;
  332.                     p_wf->wBitsPerSample = 8;
  333.                     break;
  334.                 case VLC_FOURCC( 's', '1', '6', 'l' ):
  335.                     p_wf->wFormatTag = WAVE_FORMAT_PCM;
  336.                     p_wf->nBlockAlign= 2 * p_wf->nChannels;
  337.                     p_wf->wBitsPerSample = 16;
  338.                     break;
  339.                 case VLC_FOURCC( 's', '2', '4', 'l' ):
  340.                     p_wf->wFormatTag = WAVE_FORMAT_PCM;
  341.                     p_wf->nBlockAlign= 3 * p_wf->nChannels;
  342.                     p_wf->wBitsPerSample = 24;
  343.                     break;
  344.                 case VLC_FOURCC( 's', '3', '2', 'l' ):
  345.                     p_wf->wFormatTag = WAVE_FORMAT_PCM;
  346.                     p_wf->nBlockAlign= 4 * p_wf->nChannels;
  347.                     p_wf->wBitsPerSample = 32;
  348.                     break;
  349.                 default:
  350.                     return VLC_EGENERIC;
  351.             }
  352. #undef p_wf
  353.             break;
  354.         case VIDEO_ES:
  355.             p_stream->i_cat = VIDEO_ES;
  356.             p_stream->fcc[0] = '0' + p_sys->i_streams / 10;
  357.             p_stream->fcc[1] = '0' + p_sys->i_streams % 10;
  358.             p_stream->fcc[2] = 'd';
  359.             p_stream->fcc[3] = 'c';
  360.             if( p_sys->i_stream_video < 0 )
  361.             {
  362.                 p_sys->i_stream_video = p_sys->i_streams;
  363.             }
  364.             p_stream->p_wf  = NULL;
  365.             p_stream->p_bih = malloc( sizeof( BITMAPINFOHEADER ) +
  366.                                       p_input->p_fmt->i_extra );
  367.             if( !p_stream->p_bih )
  368.             {
  369.                 free( p_input->p_sys );
  370.                 return VLC_ENOMEM;
  371.             }
  372. #define p_bih p_stream->p_bih
  373.             p_bih->biSize  = sizeof( BITMAPINFOHEADER ) +
  374.                              p_input->p_fmt->i_extra;
  375.             if( p_input->p_fmt->i_extra > 0 )
  376.             {
  377.                 memcpy( &p_bih[1],
  378.                         p_input->p_fmt->p_extra,
  379.                         p_input->p_fmt->i_extra );
  380.             }
  381.             p_bih->biWidth = p_input->p_fmt->video.i_width;
  382.             p_bih->biHeight= p_input->p_fmt->video.i_height;
  383.             p_bih->biPlanes= 1;
  384.             p_bih->biBitCount       = 24;
  385.             p_bih->biSizeImage      = 0;
  386.             p_bih->biXPelsPerMeter  = 0;
  387.             p_bih->biYPelsPerMeter  = 0;
  388.             p_bih->biClrUsed        = 0;
  389.             p_bih->biClrImportant   = 0;
  390.             switch( p_input->p_fmt->i_codec )
  391.             {
  392.                 case VLC_FOURCC( 'm', 'p', '4', 'v' ):
  393.                     p_bih->biCompression = VLC_FOURCC( 'X', 'V', 'I', 'D' );
  394.                     break;
  395.                 default:
  396.                     p_bih->biCompression = p_input->p_fmt->i_codec;
  397.                     break;
  398.             }
  399. #undef p_bih
  400.             break;
  401.         default:
  402.             return( VLC_EGENERIC );
  403.     }
  404.     p_stream->i_totalsize = 0;
  405.     p_stream->i_frames    = 0;
  406.     p_stream->i_duration  = 0;
  408.     /* fixed later */
  409.     p_stream->f_fps = 25;
  410.     p_stream->i_bitrate = 128 * 1024;
  412.     p_sys->i_streams++;
  413.     return( VLC_SUCCESS );
  414. }
  416. static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input )
  417. {
  418.     msg_Dbg( p_mux, "removing input" );
  420.     free( p_input->p_sys );
  421.     return 0;
  422. }
  424. static int Mux      ( sout_mux_t *p_mux )
  425. {
  426.     sout_mux_sys_t  *p_sys = p_mux->p_sys;
  427.     avi_stream_t    *p_stream;
  428.     int i_stream, i;
  430.     if( p_sys->b_write_header )
  431.     {
  432.         block_t *p_hdr;
  434.         msg_Dbg( p_mux, "writing header" );
  436.         p_hdr = avi_HeaderCreateRIFF( p_mux );
  437.         sout_AccessOutWrite( p_mux->p_access, p_hdr );
  439.         p_sys->b_write_header = false;
  440.     }
  442.     for( i = 0; i < p_mux->i_nb_inputs; i++ )
  443.     {
  444.         int i_count;
  445.         block_fifo_t *p_fifo;
  447.         i_stream = *((int*)p_mux->pp_inputs[i]->p_sys );
  448.         p_stream = &p_sys->stream[i_stream];
  450.         p_fifo = p_mux->pp_inputs[i]->p_fifo;
  451.         i_count = block_FifoCount(  p_fifo );
  452.         while( i_count > 1 )
  453.         {
  454.             avi_idx1_entry_t *p_idx;
  455.             block_t *p_data;
  457.             p_data = block_FifoGet( p_fifo );
  458.             if( block_FifoCount( p_fifo ) > 0 )
  459.             {
  460.                 block_t *p_next = block_FifoShow( p_fifo );
  461.                 p_data->i_length = p_next->i_dts - p_data->i_dts;
  462.             }
  464.             p_stream->i_frames++;
  465.             if( p_data->i_length < 0 )
  466.             {
  467.                 msg_Warn( p_mux, "argg length < 0 l" );
  468.                 block_Release( p_data );
  469.                 i_count--;
  470.                 continue;
  471.             }
  472.             p_stream->i_duration  += p_data->i_length;
  473.             p_stream->i_totalsize += p_data->i_buffer;
  475.             /* add idx1 entry for this frame */
  476.             p_idx = &p_sys->idx1.entry[p_sys->idx1.i_entry_count];
  477.             memcpy( p_idx->fcc, p_stream->fcc, 4 );
  478.             p_idx->i_flags = 0;
  479.             if( ( p_data->i_flags & BLOCK_FLAG_TYPE_MASK ) == 0 || ( p_data->i_flags & BLOCK_FLAG_TYPE_I ) )
  480.                 p_idx->i_flags = AVIIF_KEYFRAME;
  481.             p_idx->i_pos   = p_sys->i_movi_size + 4;
  482.             p_idx->i_length= p_data->i_buffer;
  483.             p_sys->idx1.i_entry_count++;
  484.             if( p_sys->idx1.i_entry_count >= p_sys->idx1.i_entry_max )
  485.             {
  486.                 p_sys->idx1.i_entry_max += 10000;
  487.                 p_sys->idx1.entry = realloc( p_sys->idx1.entry,
  488.                                              p_sys->idx1.i_entry_max * sizeof( avi_idx1_entry_t ) );
  489.             }
  491.             p_data = block_Realloc( p_data, 8, p_data->i_buffer );
  492.             if( p_data )
  493.             {
  494.                 SetFCC( p_data->p_buffer, p_stream->fcc );
  495.                 SetDWLE( p_data->p_buffer + 4, p_data->i_buffer - 8 );
  497.                 if( p_data->i_buffer & 0x01 )
  498.                 {
  499.                     p_data = block_Realloc( p_data, 0, p_data->i_buffer + 1 );
  500.                     p_data->p_buffer[ p_data->i_buffer - 1 ] = '';
  501.                 }
  503.                 p_sys->i_movi_size += p_data->i_buffer;
  504.                 sout_AccessOutWrite( p_mux->p_access, p_data );
  505.             }
  507.             i_count--;
  508.         }
  510.     }
  511.     return( 0 );
  512. }
  514. /****************************************************************************/
  515. /****************************************************************************/
  516. /****************************************************************************/
  517. /****************************************************************************/
  519. typedef struct buffer_out_s
  520. {
  521.     int      i_buffer_size;
  522.     int      i_buffer;
  523.     uint8_t  *p_buffer;
  525. } buffer_out_t;
  527. static void bo_Init( buffer_out_t *p_bo, int i_size, uint8_t *p_buffer )
  528. {
  529.     p_bo->i_buffer_size = i_size;
  530.     p_bo->i_buffer = 0;
  531.     p_bo->p_buffer = p_buffer;
  532. }
  533. static void bo_AddByte( buffer_out_t *p_bo, uint8_t i )
  534. {
  535.     if( p_bo->i_buffer < p_bo->i_buffer_size )
  536.     {
  537.         p_bo->p_buffer[p_bo->i_buffer] = i;
  538.     }
  539.     p_bo->i_buffer++;
  540. }
  541. static void bo_AddWordLE( buffer_out_t *p_bo, uint16_t i )
  542. {
  543.     bo_AddByte( p_bo, i &0xff );
  544.     bo_AddByte( p_bo, ( ( i >> 8) &0xff ) );
  545. }
  546. static void bo_AddWordBE( buffer_out_t *p_bo, uint16_t i )
  547. {
  548.     bo_AddByte( p_bo, ( ( i >> 8) &0xff ) );
  549.     bo_AddByte( p_bo, i &0xff );
  550. }
  551. static void bo_AddDWordLE( buffer_out_t *p_bo, uint32_t i )
  552. {
  553.     bo_AddWordLE( p_bo, i &0xffff );
  554.     bo_AddWordLE( p_bo, ( ( i >> 16) &0xffff ) );
  555. }
  556. static void bo_AddDWordBE( buffer_out_t *p_bo, uint32_t i )
  557. {
  558.     bo_AddWordBE( p_bo, ( ( i >> 16) &0xffff ) );
  559.     bo_AddWordBE( p_bo, i &0xffff );
  560. }
  561. #if 0
  562. static void bo_AddLWordLE( buffer_out_t *p_bo, uint64_t i )
  563. {
  564.     bo_AddDWordLE( p_bo, i &0xffffffff );
  565.     bo_AddDWordLE( p_bo, ( ( i >> 32) &0xffffffff ) );
  566. }
  567. static void bo_AddLWordBE( buffer_out_t *p_bo, uint64_t i )
  568. {
  569.     bo_AddDWordBE( p_bo, ( ( i >> 32) &0xffffffff ) );
  570.     bo_AddDWordBE( p_bo, i &0xffffffff );
  571. }
  572. #endif
  574. static void bo_AddFCC( buffer_out_t *p_bo, const char *fcc )
  575. {
  576.     bo_AddByte( p_bo, fcc[0] );
  577.     bo_AddByte( p_bo, fcc[1] );
  578.     bo_AddByte( p_bo, fcc[2] );
  579.     bo_AddByte( p_bo, fcc[3] );
  580. }
  582. static void bo_AddMem( buffer_out_t *p_bo, int i_size, uint8_t *p_mem )
  583. {
  584.     int i;
  586.     for( i = 0; i < i_size; i++ )
  587.     {
  588.         bo_AddByte( p_bo, p_mem[i] );
  589.     }
  590. }
  592. /****************************************************************************
  593.  ****************************************************************************
  594.  **
  595.  ** avi header generation
  596.  **
  597.  ****************************************************************************
  598.  ****************************************************************************/
  599. #define AVI_BOX_ENTER( fcc ) 
  600.     buffer_out_t _bo_sav_; 
  601.     bo_AddFCC( p_bo, fcc ); 
  602.     _bo_sav_ = *p_bo; 
  603.     bo_AddDWordLE( p_bo, 0 )
  605. #define AVI_BOX_ENTER_LIST( fcc ) 
  606.     AVI_BOX_ENTER( "LIST" ); 
  607.     bo_AddFCC( p_bo, fcc )
  609. #define AVI_BOX_EXIT( i_err ) 
  610.     if( p_bo->i_buffer&0x01 ) bo_AddByte( p_bo, 0 ); 
  611.     bo_AddDWordLE( &_bo_sav_, p_bo->i_buffer - _bo_sav_.i_buffer - 4 ); 
  612.     return( i_err );
  614. static int avi_HeaderAdd_avih( sout_mux_t *p_mux,
  615.                                buffer_out_t *p_bo )
  616. {
  617.     sout_mux_sys_t  *p_sys = p_mux->p_sys;
  618.     avi_stream_t    *p_video = NULL;
  619.     int         i_stream;
  620.     uint32_t    i_microsecperframe;
  621.     int         i_maxbytespersec;
  622.     int         i_totalframes;
  623.     AVI_BOX_ENTER( "avih" );
  625.     if( p_sys->i_stream_video >= 0 )
  626.     {
  627.         p_video = &p_sys->stream[p_sys->i_stream_video];
  628.         if( p_video->i_frames <= 0 )
  629.         {
  630.         //    p_video = NULL;
  631.         }
  632.     }
  634.     if( p_video )
  635.     {
  636.         i_microsecperframe =
  637.             (uint32_t)( (float)1000000 /
  638.                         (float)p_sys->stream[p_sys->i_stream_video].f_fps );
  639.         i_totalframes = p_sys->stream[p_sys->i_stream_video].i_frames;
  640.     }
  641.     else
  642.     {
  643.         msg_Warn( p_mux, "avi file without video track isn't a good idea..." );
  644.         i_microsecperframe = 0;
  645.         i_totalframes = 0;
  646.     }
  648.     for( i_stream = 0,i_maxbytespersec = 0; i_stream < p_sys->i_streams; i_stream++ )
  649.     {
  650.         if( p_sys->stream[i_stream].i_duration > 0 )
  651.         {
  652.             i_maxbytespersec +=
  653.                 p_sys->stream[i_stream].i_totalsize /
  654.                 p_sys->stream[i_stream].i_duration;
  655.         }
  656.     }
  658.     bo_AddDWordLE( p_bo, i_microsecperframe );
  659.     bo_AddDWordLE( p_bo, i_maxbytespersec );
  660.     bo_AddDWordLE( p_bo, 0 );                   /* padding */
  661.     bo_AddDWordLE( p_bo, AVIF_TRUSTCKTYPE |
  662.                          AVIF_HASINDEX |
  663.                          AVIF_ISINTERLEAVED );  /* flags */
  664.     bo_AddDWordLE( p_bo, i_totalframes );
  665.     bo_AddDWordLE( p_bo, 0 );                   /* initial frame */
  666.     bo_AddDWordLE( p_bo, p_sys->i_streams );    /* streams count */
  667.     bo_AddDWordLE( p_bo, 1024 * 1024 );         /* suggested buffer size */
  668.     if( p_video )
  669.     {
  670.         bo_AddDWordLE( p_bo, p_video->p_bih->biWidth );
  671.         bo_AddDWordLE( p_bo, p_video->p_bih->biHeight );
  672.     }
  673.     else
  674.     {
  675.         bo_AddDWordLE( p_bo, 0 );
  676.         bo_AddDWordLE( p_bo, 0 );
  677.     }
  678.     bo_AddDWordLE( p_bo, 0 );                   /* ???? */
  679.     bo_AddDWordLE( p_bo, 0 );                   /* ???? */
  680.     bo_AddDWordLE( p_bo, 0 );                   /* ???? */
  681.     bo_AddDWordLE( p_bo, 0 );                   /* ???? */
  683.     AVI_BOX_EXIT( 0 );
  684. }
  685. static int avi_HeaderAdd_strh( buffer_out_t *p_bo, avi_stream_t *p_stream )
  686. {
  687.     AVI_BOX_ENTER( "strh" );
  689.     switch( p_stream->i_cat )
  690.     {
  691.         case VIDEO_ES:
  692.             {
  693.                 bo_AddFCC( p_bo, "vids" );
  694.                 bo_AddDWordBE( p_bo, p_stream->p_bih->biCompression );
  695.                 bo_AddDWordLE( p_bo, 0 );   /* flags */
  696.                 bo_AddWordLE(  p_bo, 0 );   /* priority */
  697.                 bo_AddWordLE(  p_bo, 0 );   /* langage */
  698.                 bo_AddDWordLE( p_bo, 0 );   /* initial frame */
  699.                 bo_AddDWordLE( p_bo, 1000 );/* scale */
  700.                 bo_AddDWordLE( p_bo, (uint32_t)( 1000 * p_stream->f_fps ));
  701.                 bo_AddDWordLE( p_bo, 0 );   /* start */
  702.                 bo_AddDWordLE( p_bo, p_stream->i_frames );
  703.                 bo_AddDWordLE( p_bo, 1024 * 1024 );
  704.                 bo_AddDWordLE( p_bo, -1 );  /* quality */
  705.                 bo_AddDWordLE( p_bo, 0 );   /* samplesize */
  706.                 bo_AddWordLE(  p_bo, 0 );   /* ??? */
  707.                 bo_AddWordLE(  p_bo, 0 );   /* ??? */
  708.                 bo_AddWordLE(  p_bo, p_stream->p_bih->biWidth );
  709.                 bo_AddWordLE(  p_bo, p_stream->p_bih->biHeight );
  710.             }
  711.             break;
  712.         case AUDIO_ES:
  713.             {
  714.                 int i_rate, i_scale, i_samplesize;
  716.                 i_samplesize = p_stream->p_wf->nBlockAlign;
  717.                 if( i_samplesize > 1 )
  718.                 {
  719.                     i_scale = i_samplesize;
  720.                     i_rate = /*i_scale **/ p_stream->i_bitrate / 8;
  721.                 }
  722.                 else
  723.                 {
  724.                     i_samplesize = 1;
  725.                     i_scale = 1000;
  726.                     i_rate = 1000 * p_stream->i_bitrate / 8;
  727.                 }
  728.                 bo_AddFCC( p_bo, "auds" );
  729.                 bo_AddDWordLE( p_bo, 0 );   /* tag */
  730.                 bo_AddDWordLE( p_bo, 0 );   /* flags */
  731.                 bo_AddWordLE(  p_bo, 0 );   /* priority */
  732.                 bo_AddWordLE(  p_bo, 0 );   /* langage */
  733.                 bo_AddDWordLE( p_bo, 0 );   /* initial frame */
  734.                 bo_AddDWordLE( p_bo, i_scale );/* scale */
  735.                 bo_AddDWordLE( p_bo, i_rate );
  736.                 bo_AddDWordLE( p_bo, 0 );   /* start */
  737.                 bo_AddDWordLE( p_bo, p_stream->i_frames );
  738.                 bo_AddDWordLE( p_bo, 10 * 1024 );
  739.                 bo_AddDWordLE( p_bo, -1 );  /* quality */
  740.                 bo_AddDWordLE( p_bo, i_samplesize );
  741.                 bo_AddWordLE(  p_bo, 0 );   /* ??? */
  742.                 bo_AddWordLE(  p_bo, 0 );   /* ??? */
  743.                 bo_AddWordLE(  p_bo, 0 );
  744.                 bo_AddWordLE(  p_bo, 0 );
  745.             }
  746.             break;
  747.     }
  749.     AVI_BOX_EXIT( 0 );
  750. }
  752. static int avi_HeaderAdd_strf( buffer_out_t *p_bo, avi_stream_t *p_stream )
  753. {
  754.     AVI_BOX_ENTER( "strf" );
  756.     switch( p_stream->i_cat )
  757.     {
  758.         case AUDIO_ES:
  759.             bo_AddWordLE( p_bo, p_stream->p_wf->wFormatTag );
  760.             bo_AddWordLE( p_bo, p_stream->p_wf->nChannels );
  761.             bo_AddDWordLE( p_bo, p_stream->p_wf->nSamplesPerSec );
  762.             bo_AddDWordLE( p_bo, p_stream->p_wf->nAvgBytesPerSec );
  763.             bo_AddWordLE( p_bo, p_stream->p_wf->nBlockAlign );
  764.             bo_AddWordLE( p_bo, p_stream->p_wf->wBitsPerSample );
  765.             bo_AddWordLE( p_bo, p_stream->p_wf->cbSize );
  766.             bo_AddMem( p_bo, p_stream->p_wf->cbSize, (uint8_t*)&p_stream->p_wf[1] );
  767.             break;
  768.         case VIDEO_ES:
  769.             bo_AddDWordLE( p_bo, p_stream->p_bih->biSize );
  770.             bo_AddDWordLE( p_bo, p_stream->p_bih->biWidth );
  771.             bo_AddDWordLE( p_bo, p_stream->p_bih->biHeight );
  772.             bo_AddWordLE( p_bo, p_stream->p_bih->biPlanes );
  773.             bo_AddWordLE( p_bo, p_stream->p_bih->biBitCount );
  774.             if( VLC_FOURCC( 0, 0, 0, 1 ) == 0x00000001 )
  775.             {
  776.                 bo_AddDWordBE( p_bo, p_stream->p_bih->biCompression );
  777.             }
  778.             else
  779.             {
  780.                 bo_AddDWordLE( p_bo, p_stream->p_bih->biCompression );
  781.             }
  782.             bo_AddDWordLE( p_bo, p_stream->p_bih->biSizeImage );
  783.             bo_AddDWordLE( p_bo, p_stream->p_bih->biXPelsPerMeter );
  784.             bo_AddDWordLE( p_bo, p_stream->p_bih->biYPelsPerMeter );
  785.             bo_AddDWordLE( p_bo, p_stream->p_bih->biClrUsed );
  786.             bo_AddDWordLE( p_bo, p_stream->p_bih->biClrImportant );
  787.             bo_AddMem( p_bo,
  788.                        p_stream->p_bih->biSize - sizeof( BITMAPINFOHEADER ),
  789.                        (uint8_t*)&p_stream->p_bih[1] );
  790.             break;
  791.     }
  793.     AVI_BOX_EXIT( 0 );
  794. }
  796. static int avi_HeaderAdd_strl( buffer_out_t *p_bo, avi_stream_t *p_stream )
  797. {
  798.     AVI_BOX_ENTER_LIST( "strl" );
  800.     avi_HeaderAdd_strh( p_bo, p_stream );
  801.     avi_HeaderAdd_strf( p_bo, p_stream );
  803.     AVI_BOX_EXIT( 0 );
  804. }
  806. static block_t *avi_HeaderCreateRIFF( sout_mux_t *p_mux )
  807. {
  808.     sout_mux_sys_t      *p_sys = p_mux->p_sys;
  809.     block_t       *p_hdr;
  810.     int                 i_stream;
  811.     int                 i_maxbytespersec;
  812.     int                 i_junk;
  813.     buffer_out_t        bo;
  815.     p_hdr = block_New( p_mux, HDR_SIZE );
  816.     memset( p_hdr->p_buffer, 0, HDR_SIZE );
  818.     bo_Init( &bo, HDR_SIZE, p_hdr->p_buffer );
  820.     bo_AddFCC( &bo, "RIFF" );
  821.     bo_AddDWordLE( &bo, p_sys->i_movi_size + HDR_SIZE - 8 + p_sys->i_idx1_size );
  822.     bo_AddFCC( &bo, "AVI " );
  824.     bo_AddFCC( &bo, "LIST" );
  825.     bo_AddDWordLE( &bo, HDR_SIZE - 8);
  826.     bo_AddFCC( &bo, "hdrl" );
  828.     avi_HeaderAdd_avih( p_mux, &bo );
  829.     for( i_stream = 0,i_maxbytespersec = 0; i_stream < p_sys->i_streams; i_stream++ )
  830.     {
  831.         avi_HeaderAdd_strl( &bo, &p_sys->stream[i_stream] );
  832.     }
  834.     i_junk = HDR_SIZE - bo.i_buffer - 8 - 12;
  835.     bo_AddFCC( &bo, "JUNK" );
  836.     bo_AddDWordLE( &bo, i_junk );
  838.     bo.i_buffer += i_junk;
  839.     bo_AddFCC( &bo, "LIST" );
  840.     bo_AddDWordLE( &bo, p_sys->i_movi_size + 4 );
  841.     bo_AddFCC( &bo, "movi" );
  843.     return( p_hdr );
  844. }
  846. static block_t * avi_HeaderCreateidx1( sout_mux_t *p_mux )
  847. {
  848.     sout_mux_sys_t      *p_sys = p_mux->p_sys;
  849.     block_t       *p_idx1;
  850.     uint32_t            i_idx1_size;
  851.     unsigned int        i;
  852.     buffer_out_t        bo;
  854.     i_idx1_size = 16 * p_sys->idx1.i_entry_count;
  856.     p_idx1 = block_New( p_mux, i_idx1_size + 8 );
  857.     memset( p_idx1->p_buffer, 0, i_idx1_size );
  859.     bo_Init( &bo, i_idx1_size, p_idx1->p_buffer );
  860.     bo_AddFCC( &bo, "idx1" );
  861.     bo_AddDWordLE( &bo, i_idx1_size );
  863.     for( i = 0; i < p_sys->idx1.i_entry_count; i++ )
  864.     {
  865.         bo_AddFCC( &bo, p_sys->idx1.entry[i].fcc );
  866.         bo_AddDWordLE( &bo, p_sys->idx1.entry[i].i_flags );
  867.         bo_AddDWordLE( &bo, p_sys->idx1.entry[i].i_pos );
  868.         bo_AddDWordLE( &bo, p_sys->idx1.entry[i].i_length );
  869.     }
  871.     return( p_idx1 );
  872. }