/*****************************************************************************
* avi.c
*****************************************************************************
- * Copyright (C) 2001, 2002 VideoLAN
- * $Id: avi.c,v 1.5 2003/02/16 14:10:44 fenrir Exp $
+ * Copyright (C) 2001-2009 VLC authors and VideoLAN
+ * $Id$
*
* Authors: Laurent Aimar <fenrir@via.ecp.fr>
*
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation; either version 2.1 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License for more details.
*
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA.
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
/*****************************************************************************
*****************************************************************************/
/* TODO: add OpenDML write support */
-#include <stdlib.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <string.h>
-#include <errno.h>
-#include <fcntl.h>
-
-#include <vlc/vlc.h>
-#include <vlc/input.h>
-#include <vlc/sout.h>
-
-#ifdef HAVE_UNISTD_H
-# include <unistd.h>
-#elif defined( _MSC_VER ) && defined( _WIN32 ) && !defined( UNDER_CE )
-# include <io.h>
-#endif
-
-#include "codecs.h"
-
-#define AVIF_HASINDEX 0x00000010 // Index at end of file?
-#define AVIF_MUSTUSEINDEX 0x00000020
-#define AVIF_ISINTERLEAVED 0x00000100
-#define AVIF_TRUSTCKTYPE 0x00000800 // Use CKType to find key frames?
-#define AVIF_WASCAPTUREFILE 0x00010000
-#define AVIF_COPYRIGHTED 0x00020000
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
-/* Flags for index */
-#define AVIIF_LIST 0x00000001L /* chunk is a 'LIST' */
-#define AVIIF_KEYFRAME 0x00000010L /* this frame is a key frame.*/
-#define AVIIF_NOTIME 0x00000100L /* this frame doesn't take any time */
-#define AVIIF_COMPUSE 0x0FFF0000L /* these bits are for compressor use */
+#include <vlc_common.h>
+#include <vlc_plugin.h>
+#include <vlc_sout.h>
+#include <vlc_block.h>
+#include <vlc_codecs.h>
+#include <vlc_bits.h>
/*****************************************************************************
- * Exported prototypes
+ * Module descriptor
*****************************************************************************/
-static int Open ( vlc_object_t * );
-static void Close ( vlc_object_t * );
-
-static int AddStream( sout_instance_t *, sout_input_t * );
-static int DelStream( sout_instance_t *, sout_input_t * );
-static int Mux ( sout_instance_t * );
+static int Open ( vlc_object_t * );
+static void Close ( vlc_object_t * );
+
+#define SOUT_CFG_PREFIX "sout-avi-"
+
+#define CFG_ARTIST_TEXT N_("Artist")
+#define CFG_DATE_TEXT N_("Date")
+#define CFG_GENRE_TEXT N_("Genre")
+#define CFG_COPYRIGHT_TEXT N_("Copyright")
+#define CFG_COMMENT_TEXT N_("Comment")
+#define CFG_NAME_TEXT N_("Name")
+#define CFG_SUBJECT_TEXT N_("Subject")
+#define CFG_ENCODER_TEXT N_("Encoder")
+#define CFG_KEYWORDS_TEXT N_("Keywords")
+
+vlc_module_begin ()
+ set_description( N_("AVI muxer") )
+ set_category( CAT_SOUT )
+ set_subcategory( SUBCAT_SOUT_MUX )
+ set_capability( "sout mux", 5 )
+ add_shortcut( "avi" )
+
+ add_string( SOUT_CFG_PREFIX "artist", NULL, CFG_ARTIST_TEXT, NULL, true )
+ add_string( SOUT_CFG_PREFIX "date", NULL, CFG_DATE_TEXT, NULL, true )
+ add_string( SOUT_CFG_PREFIX "genre", NULL, CFG_GENRE_TEXT, NULL, true )
+ add_string( SOUT_CFG_PREFIX "copyright", NULL, CFG_COPYRIGHT_TEXT, NULL, true )
+ add_string( SOUT_CFG_PREFIX "comment", NULL, CFG_COMMENT_TEXT, NULL, true )
+ add_string( SOUT_CFG_PREFIX "name", NULL, CFG_NAME_TEXT, NULL, true )
+ add_string( SOUT_CFG_PREFIX "subject", NULL, CFG_SUBJECT_TEXT, NULL, true )
+ add_string( SOUT_CFG_PREFIX "encoder",
+ "VLC Media Player - " VERSION_MESSAGE,
+ CFG_ENCODER_TEXT, NULL, true )
+ add_string( SOUT_CFG_PREFIX "keywords", NULL, CFG_KEYWORDS_TEXT, NULL, true )
+
+ set_callbacks( Open, Close )
+vlc_module_end ()
-static sout_buffer_t *avi_HeaderCreateRIFF( sout_instance_t *p_sout );
-static sout_buffer_t *avi_HeaderCreateidx1( sout_instance_t *p_sout );
-
-static void SetFCC( uint8_t *p, char *fcc )
-{
- p[0] = fcc[0];
- p[1] = fcc[1];
- p[2] = fcc[2];
- p[3] = fcc[3];
-}
-
-static void SetDWLE( uint8_t *p, uint32_t i_dw )
-{
- p[3] = ( i_dw >> 24 )&0xff;
- p[2] = ( i_dw >> 16 )&0xff;
- p[1] = ( i_dw >> 8 )&0xff;
- p[0] = ( i_dw )&0xff;
-}
/*****************************************************************************
- * Module descriptor
+ * Local prototypes
*****************************************************************************/
-vlc_module_begin();
- set_description( _("Avi muxer") );
- set_capability( "sout mux", 5 );
- add_shortcut( "avi" );
- set_callbacks( Open, Close );
-vlc_module_end();
-
-// FIXME FIXME
-#define HDR_SIZE 10240
+static int Control( sout_mux_t *, int, va_list );
+static int AddStream( sout_mux_t *, sout_input_t * );
+static void DelStream( sout_mux_t *, sout_input_t * );
+static int Mux ( sout_mux_t * );
typedef struct avi_stream_s
{
char fcc[4];
- mtime_t i_duration; // in µs
+ mtime_t i_duration; // in µs
int i_frames; // total frame count
int64_t i_totalsize; // total stream size
float f_fps;
int i_bitrate;
- BITMAPINFOHEADER *p_bih;
- WAVEFORMATEX *p_wf;
+ VLC_BITMAPINFOHEADER *p_bih;
+ WAVEFORMATEX *p_wf;
} avi_stream_t;
avi_idx1_entry_t *entry;
} avi_idx1_t;
-typedef struct sout_mux_s
+struct sout_mux_sys_t
{
+ bool b_write_header;
+
int i_streams;
int i_stream_video;
avi_idx1_t idx1;
off_t i_idx1_size;
-} sout_mux_t;
+};
+
+#define HDR_BASE_SIZE 512 /* single video&audio ~ 400 bytes header */
+
+/* Flags in avih */
+#define AVIF_HASINDEX 0x00000010 // Index at end of file?
+#define AVIF_ISINTERLEAVED 0x00000100
+#define AVIF_TRUSTCKTYPE 0x00000800 // Use CKType to find key frames?
+
+/* Flags for index */
+#define AVIIF_KEYFRAME 0x00000010L /* this frame is a key frame.*/
+
+
+static block_t *avi_HeaderCreateRIFF( sout_mux_t * );
+static block_t *avi_HeaderCreateidx1( sout_mux_t * );
+
+static void SetFCC( uint8_t *p, char *fcc )
+{
+ memcpy( p, fcc, 4 );
+}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
- sout_instance_t *p_sout = (sout_instance_t*)p_this;
- sout_mux_t *p_mux;
- sout_buffer_t *p_hdr;
-
- p_mux = malloc( sizeof( sout_mux_t ) );
- p_mux->i_streams = 0;
- p_mux->i_stream_video = -1;
- p_mux->i_movi_size = 0;
-
- p_mux->idx1.i_entry_count = 0;
- p_mux->idx1.i_entry_max = 10000;
- p_mux->idx1.entry = calloc( p_mux->idx1.i_entry_max, sizeof( avi_idx1_entry_t ) );
-
- msg_Info( p_sout, "Open" );
+ sout_mux_t *p_mux = (sout_mux_t*)p_this;
+ sout_mux_sys_t *p_sys;
+
+ msg_Dbg( p_mux, "AVI muxer opened" );
+
+ p_sys = malloc( sizeof( sout_mux_sys_t ) );
+ if( !p_sys )
+ return VLC_ENOMEM;
+ p_sys->i_streams = 0;
+ p_sys->i_stream_video = -1;
+ p_sys->i_movi_size = 0;
+
+ p_sys->idx1.i_entry_count = 0;
+ p_sys->idx1.i_entry_max = 10000;
+ p_sys->idx1.entry = calloc( p_sys->idx1.i_entry_max,
+ sizeof( avi_idx1_entry_t ) );
+ if( !p_sys->idx1.entry )
+ {
+ free( p_sys );
+ return VLC_ENOMEM;
+ }
+ p_sys->b_write_header = true;
- p_sout->pf_mux_addstream = AddStream;
- p_sout->pf_mux_delstream = DelStream;
- p_sout->pf_mux = Mux;
- p_sout->p_mux_data = (void*)p_mux;
- p_sout->i_mux_preheader = 8; // (fourcc,length) header
- /* room to add header at the end */
- p_hdr = sout_BufferNew( p_sout, HDR_SIZE );
- memset( p_hdr->p_buffer, 0, HDR_SIZE );
- sout_AccessWrite( p_sout->p_access, p_hdr );
+ p_mux->pf_control = Control;
+ p_mux->pf_addstream = AddStream;
+ p_mux->pf_delstream = DelStream;
+ p_mux->pf_mux = Mux;
+ p_mux->p_sys = p_sys;
return VLC_SUCCESS;
}
/*****************************************************************************
* Close:
*****************************************************************************/
-
static void Close( vlc_object_t * p_this )
{
- sout_instance_t *p_sout = (sout_instance_t*)p_this;
- sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
- sout_buffer_t *p_hdr, *p_idx1;
+ sout_mux_t *p_mux = (sout_mux_t*)p_this;
+ sout_mux_sys_t *p_sys = p_mux->p_sys;
+
+ block_t *p_hdr, *p_idx1;
int i_stream;
- msg_Info( p_sout, "Close" );
+ msg_Dbg( p_mux, "AVI muxer closed" );
/* first create idx1 chunk (write at the end of the stream */
- p_idx1 = avi_HeaderCreateidx1( p_sout );
- p_mux->i_idx1_size = p_idx1->i_size;
- sout_AccessWrite( p_sout->p_access, p_idx1 );
+ p_idx1 = avi_HeaderCreateidx1( p_mux );
+ if( p_idx1 )
+ {
+ p_sys->i_idx1_size = p_idx1->i_buffer;
+ sout_AccessOutWrite( p_mux->p_access, p_idx1 );
+ }
+ else p_sys->i_idx1_size = 0;
/* calculate some value for headers creations */
- for( i_stream = 0; i_stream < p_mux->i_streams; i_stream++ )
+ for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
{
avi_stream_t *p_stream;
- p_stream = &p_mux->stream[i_stream];
+ p_stream = &p_sys->stream[i_stream];
p_stream->f_fps = 25;
if( p_stream->i_duration > 0 )
(uint64_t)p_stream->i_totalsize /
(uint64_t)p_stream->i_duration;
}
- msg_Err( p_sout,"stream[%d] duration:%lld totalsize:%lld frames:%d fps:%f kb/s:%d",
- i_stream,
- p_stream->i_duration/1000000, p_stream->i_totalsize,
- p_stream->i_frames,
- p_stream->f_fps, p_stream->i_bitrate/1024 );
+ msg_Info( p_mux, "stream[%d] duration:%"PRId64" totalsize:%"PRId64
+ " frames:%d fps:%f KiB/s:%d",
+ i_stream,
+ (int64_t)p_stream->i_duration / (int64_t)1000000,
+ p_stream->i_totalsize,
+ p_stream->i_frames,
+ p_stream->f_fps, p_stream->i_bitrate/1024 );
+ }
+
+ p_hdr = avi_HeaderCreateRIFF( p_mux );
+ if ( p_hdr )
+ {
+ sout_AccessOutSeek( p_mux->p_access, 0 );
+ sout_AccessOutWrite( p_mux->p_access, p_hdr );
}
- p_hdr = avi_HeaderCreateRIFF( p_sout );
- sout_AccessSeek( p_sout->p_access, 0 );
- sout_AccessWrite( p_sout->p_access, p_hdr );
+ for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
+ {
+ avi_stream_t *p_stream;
+ p_stream = &p_sys->stream[i_stream];
+ free( p_stream->p_bih );
+ free( p_stream->p_wf );
+ }
+ free( p_sys->idx1.entry );
+ free( p_sys );
}
+static int Control( sout_mux_t *p_mux, int i_query, va_list args )
+{
+ VLC_UNUSED(p_mux);
+ bool *pb_bool;
+ char **ppsz;
+
+ switch( i_query )
+ {
+ case MUX_CAN_ADD_STREAM_WHILE_MUXING:
+ pb_bool = (bool*)va_arg( args, bool * );
+ *pb_bool = false;
+ return VLC_SUCCESS;
+
+ case MUX_GET_ADD_STREAM_WAIT:
+ pb_bool = (bool*)va_arg( args, bool * );
+ *pb_bool = true;
+ return VLC_SUCCESS;
+
+ case MUX_GET_MIME:
+ ppsz = (char**)va_arg( args, char ** );
+ *ppsz = strdup( "video/avi" );
+ return VLC_SUCCESS;
+
+ default:
+ return VLC_EGENERIC;
+ }
+}
-static int AddStream( sout_instance_t *p_sout, sout_input_t *p_input )
+static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input )
{
- sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
- avi_stream_t *p_stream;
+ sout_mux_sys_t *p_sys = p_mux->p_sys;
+ avi_stream_t *p_stream;
- if( p_mux->i_streams >= 100 )
- {
- msg_Err( p_sout, "too many streams" );
- return( -1 );
- }
- if( p_input->input_format.p_format == NULL )
+ if( p_sys->i_streams >= 100 )
{
- msg_Err( p_sout, "stream descriptor missing" );
- return( -1 );
+ msg_Err( p_mux, "too many streams" );
+ return VLC_EGENERIC;
}
- msg_Dbg( p_sout, "adding input" );
- p_input->p_mux_data = malloc( sizeof( int ) );
+ msg_Dbg( p_mux, "adding input" );
+ p_input->p_sys = malloc( sizeof( int ) );
+ if( !p_input->p_sys )
+ return VLC_ENOMEM;
- *((int*)p_input->p_mux_data) = p_mux->i_streams;
- p_stream = &p_mux->stream[p_mux->i_streams];
+ *((int*)p_input->p_sys) = p_sys->i_streams;
+ p_stream = &p_sys->stream[p_sys->i_streams];
- switch( p_input->input_format.i_cat )
+ switch( p_input->p_fmt->i_cat )
{
case AUDIO_ES:
+ p_stream->i_cat = AUDIO_ES;
+ p_stream->fcc[0] = '0' + p_sys->i_streams / 10;
+ p_stream->fcc[1] = '0' + p_sys->i_streams % 10;
+ p_stream->fcc[2] = 'w';
+ p_stream->fcc[3] = 'b';
+
+ p_stream->p_bih = NULL;
+
+ WAVEFORMATEX *p_wf = malloc( sizeof( WAVEFORMATEX ) +
+ p_input->p_fmt->i_extra );
+ if( !p_wf )
+ {
+ free( p_input->p_sys );
+ p_input->p_sys = NULL;
+ return VLC_ENOMEM;
+ }
+
+ p_wf->cbSize = p_input->p_fmt->i_extra;
+ if( p_wf->cbSize > 0 )
{
- WAVEFORMATEX *p_wf =
- (WAVEFORMATEX*)p_input->input_format.p_format;
-
- p_stream->i_cat = AUDIO_ES;
- p_stream->fcc[0] = '0' + p_mux->i_streams / 10;
- p_stream->fcc[1] = '0' + p_mux->i_streams % 10;
- p_stream->fcc[2] = 'w';
- p_stream->fcc[3] = 'b';
-
- p_stream->p_bih = NULL;
- p_stream->p_wf = malloc( sizeof( WAVEFORMATEX ) + p_wf->cbSize );
- memcpy( p_stream->p_wf,
- p_wf,
- sizeof( WAVEFORMATEX ) + p_wf->cbSize);
+ memcpy( &p_wf[1],
+ p_input->p_fmt->p_extra,
+ p_input->p_fmt->i_extra );
}
+ p_wf->nChannels = p_input->p_fmt->audio.i_channels;
+ p_wf->nSamplesPerSec = p_input->p_fmt->audio.i_rate;
+ p_wf->nBlockAlign = p_input->p_fmt->audio.i_blockalign;
+ p_wf->nAvgBytesPerSec= p_input->p_fmt->i_bitrate / 8;
+ p_wf->wBitsPerSample = 0;
+
+ switch( p_input->p_fmt->i_codec )
+ {
+ case VLC_CODEC_A52:
+ p_wf->wFormatTag = WAVE_FORMAT_A52;
+ p_wf->nBlockAlign= 1;
+ break;
+ case VLC_CODEC_MP3:
+ p_wf->wFormatTag = WAVE_FORMAT_MPEGLAYER3;
+ p_wf->nBlockAlign= 1;
+ break;
+ case VLC_CODEC_WMA1:
+ p_wf->wFormatTag = WAVE_FORMAT_WMA1;
+ break;
+ case VLC_CODEC_WMA2:
+ p_wf->wFormatTag = WAVE_FORMAT_WMA2;
+ break;
+ case VLC_CODEC_WMAP:
+ p_wf->wFormatTag = WAVE_FORMAT_WMAP;
+ break;
+ case VLC_CODEC_WMAL:
+ p_wf->wFormatTag = WAVE_FORMAT_WMAL;
+ break;
+ /* raw codec */
+ case VLC_CODEC_U8:
+ p_wf->wFormatTag = WAVE_FORMAT_PCM;
+ p_wf->nBlockAlign= p_wf->nChannels;
+ p_wf->wBitsPerSample = 8;
+ p_wf->nAvgBytesPerSec = (p_wf->wBitsPerSample/8) *
+ p_wf->nSamplesPerSec * p_wf->nChannels;
+ break;
+ case VLC_CODEC_S16L:
+ p_wf->wFormatTag = WAVE_FORMAT_PCM;
+ p_wf->nBlockAlign= 2 * p_wf->nChannels;
+ p_wf->wBitsPerSample = 16;
+ p_wf->nAvgBytesPerSec = (p_wf->wBitsPerSample/8) *
+ p_wf->nSamplesPerSec * p_wf->nChannels;
+ break;
+ case VLC_CODEC_S24L:
+ p_wf->wFormatTag = WAVE_FORMAT_PCM;
+ p_wf->nBlockAlign= 3 * p_wf->nChannels;
+ p_wf->wBitsPerSample = 24;
+ p_wf->nAvgBytesPerSec = (p_wf->wBitsPerSample/8) *
+ p_wf->nSamplesPerSec * p_wf->nChannels;
+ break;
+ case VLC_CODEC_S32L:
+ p_wf->wFormatTag = WAVE_FORMAT_PCM;
+ p_wf->nBlockAlign= 4 * p_wf->nChannels;
+ p_wf->wBitsPerSample = 32;
+ p_wf->nAvgBytesPerSec = (p_wf->wBitsPerSample/8) *
+ p_wf->nSamplesPerSec * p_wf->nChannels;
+ break;
+ default:
+ free( p_wf );
+ free( p_input->p_sys );
+ p_input->p_sys = NULL;
+ return VLC_EGENERIC;
+ }
+ p_stream->p_wf = p_wf;
break;
case VIDEO_ES:
+ p_stream->i_cat = VIDEO_ES;
+ p_stream->fcc[0] = '0' + p_sys->i_streams / 10;
+ p_stream->fcc[1] = '0' + p_sys->i_streams % 10;
+ p_stream->fcc[2] = 'd';
+ p_stream->fcc[3] = 'c';
+ if( p_sys->i_stream_video < 0 )
{
- BITMAPINFOHEADER *p_bih =
- (BITMAPINFOHEADER*)p_input->input_format.p_format;;
-
- p_stream->i_cat = VIDEO_ES;
- p_stream->fcc[0] = '0' + p_mux->i_streams / 10;
- p_stream->fcc[1] = '0' + p_mux->i_streams % 10;
- p_stream->fcc[2] = 'd';
- p_stream->fcc[3] = 'c';
- if( p_mux->i_stream_video < 0 )
- {
- p_mux->i_stream_video = p_mux->i_streams;
- }
- p_stream->p_wf = NULL;
- p_stream->p_bih = malloc( p_bih->biSize );
- memcpy( p_stream->p_bih,
- p_bih,
- p_bih->biSize );
+ p_sys->i_stream_video = p_sys->i_streams;
+ }
+ p_stream->p_wf = NULL;
+ VLC_BITMAPINFOHEADER *p_bih = malloc( sizeof( VLC_BITMAPINFOHEADER ) +
+ p_input->p_fmt->i_extra );
+ if( !p_bih )
+ {
+ free( p_input->p_sys );
+ p_input->p_sys = NULL;
+ return VLC_ENOMEM;
+ }
+
+ p_bih->biSize = sizeof( VLC_BITMAPINFOHEADER ) +
+ p_input->p_fmt->i_extra;
+ if( p_input->p_fmt->i_extra > 0 )
+ {
+ memcpy( &p_bih[1],
+ p_input->p_fmt->p_extra,
+ p_input->p_fmt->i_extra );
}
+ p_bih->biWidth = p_input->p_fmt->video.i_width;
+ p_bih->biHeight= p_input->p_fmt->video.i_height;
+ p_bih->biPlanes= 1;
+ p_bih->biBitCount = 24;
+ p_bih->biSizeImage = 0;
+ p_bih->biXPelsPerMeter = 0;
+ p_bih->biYPelsPerMeter = 0;
+ p_bih->biClrUsed = 0;
+ p_bih->biClrImportant = 0;
+ switch( p_input->p_fmt->i_codec )
+ {
+ case VLC_CODEC_MP4V:
+ p_bih->biCompression = VLC_FOURCC( 'X', 'V', 'I', 'D' );
+ break;
+ default:
+ p_bih->biCompression = p_input->p_fmt->i_original_fourcc ?: p_input->p_fmt->i_codec;
+ break;
+ }
+ p_stream->p_bih = p_bih;
break;
default:
- return( -1 );
+ free( p_input->p_sys );
+ p_input->p_sys = NULL;
+ return( VLC_EGENERIC );
}
p_stream->i_totalsize = 0;
- p_stream->i_frames = 0;
+ p_stream->i_frames = 0;
p_stream->i_duration = 0;
- p_mux->i_streams++;
- return( 0 );
+ /* fixed later */
+ p_stream->f_fps = 25;
+ p_stream->i_bitrate = 128 * 1024;
+
+ p_sys->i_streams++;
+ return( VLC_SUCCESS );
}
-static int DelStream( sout_instance_t *p_sout, sout_input_t *p_input )
+static void DelStream( sout_mux_t *p_mux, sout_input_t *p_input )
{
-// sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
-
- msg_Dbg( p_sout, "removing input" );
+ msg_Dbg( p_mux, "removing input" );
- free( p_input->p_mux_data ); p_input->p_mux_data = NULL;
-
- return( 0 );
+ free( p_input->p_sys );
}
-static int Mux ( sout_instance_t *p_sout )
+static int Mux ( sout_mux_t *p_mux )
{
- sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
- avi_stream_t *p_stream;
- int i_stream;
- int i;
+ sout_mux_sys_t *p_sys = p_mux->p_sys;
+ avi_stream_t *p_stream;
+ int i_stream, i;
- for( i = 0; i < p_sout->i_nb_inputs; i++ )
+ if( p_sys->b_write_header )
+ {
+ msg_Dbg( p_mux, "writing header" );
+
+ block_t *p_hdr = avi_HeaderCreateRIFF( p_mux );
+ if ( !p_hdr )
+ return VLC_EGENERIC;
+ sout_AccessOutWrite( p_mux->p_access, p_hdr );
+
+ p_sys->b_write_header = false;
+ }
+
+ for( i = 0; i < p_mux->i_nb_inputs; i++ )
{
int i_count;
- sout_fifo_t *p_fifo;
+ block_fifo_t *p_fifo;
+
+ if (!p_mux->pp_inputs[i]->p_sys)
+ continue;
- i_stream = *((int*)p_sout->pp_inputs[i]->p_mux_data );
- p_stream = &p_mux->stream[i_stream];
+ i_stream = *((int*)p_mux->pp_inputs[i]->p_sys );
+ p_stream = &p_sys->stream[i_stream];
- p_fifo = p_sout->pp_inputs[i]->p_fifo;
- i_count = p_fifo->i_depth;
- while( i_count > 0 )
+ p_fifo = p_mux->pp_inputs[i]->p_fifo;
+ i_count = block_FifoCount( p_fifo );
+ while( i_count > 1 )
{
avi_idx1_entry_t *p_idx;
- sout_buffer_t *p_data;
+ block_t *p_data;
+
+ p_data = block_FifoGet( p_fifo );
+ if( block_FifoCount( p_fifo ) > 0 )
+ {
+ block_t *p_next = block_FifoShow( p_fifo );
+ p_data->i_length = p_next->i_dts - p_data->i_dts;
+ }
- p_data = sout_FifoGet( p_fifo );
+
+ if( p_stream->i_frames == 0 &&p_stream->i_cat == VIDEO_ES )
+ {
+ /* Add header present at the end of BITMAP info header
+ to first frame in case of XVID */
+ if( p_stream->p_bih->biCompression
+ == VLC_FOURCC( 'X', 'V', 'I', 'D' ) )
+ {
+ int i_header_length =
+ p_stream->p_bih->biSize - sizeof(VLC_BITMAPINFOHEADER);
+ p_data = block_Realloc( p_data,
+ i_header_length, p_data->i_buffer );
+ if( !p_data)
+ return VLC_ENOMEM;
+ memcpy(p_data->p_buffer,&p_stream->p_bih[1], i_header_length);
+ }
+ }
p_stream->i_frames++;
+ if( p_data->i_length < 0 )
+ {
+ msg_Warn( p_mux, "argg length < 0 l" );
+ block_Release( p_data );
+ i_count--;
+ continue;
+ }
p_stream->i_duration += p_data->i_length;
- p_stream->i_totalsize += p_data->i_size;
+ p_stream->i_totalsize += p_data->i_buffer;
/* add idx1 entry for this frame */
- p_idx = &p_mux->idx1.entry[p_mux->idx1.i_entry_count];
+ p_idx = &p_sys->idx1.entry[p_sys->idx1.i_entry_count];
memcpy( p_idx->fcc, p_stream->fcc, 4 );
- p_idx->i_flags = AVIIF_KEYFRAME;
- p_idx->i_pos = p_mux->i_movi_size + 4;
- p_idx->i_length= p_data->i_size;
- p_mux->idx1.i_entry_count++;
- if( p_mux->idx1.i_entry_count >= p_mux->idx1.i_entry_max )
+ p_idx->i_flags = 0;
+ if( ( p_data->i_flags & BLOCK_FLAG_TYPE_MASK ) == 0 || ( p_data->i_flags & BLOCK_FLAG_TYPE_I ) )
+ p_idx->i_flags = AVIIF_KEYFRAME;
+ p_idx->i_pos = p_sys->i_movi_size + 4;
+ p_idx->i_length= p_data->i_buffer;
+ p_sys->idx1.i_entry_count++;
+ if( p_sys->idx1.i_entry_count >= p_sys->idx1.i_entry_max )
{
- p_mux->idx1.i_entry_max += 10000;
- p_mux->idx1.entry = realloc( p_mux->idx1.entry,
- p_mux->idx1.i_entry_max * sizeof( avi_idx1_entry_t ) );
+ p_sys->idx1.i_entry_max += 10000;
+ p_sys->idx1.entry = xrealloc( p_sys->idx1.entry,
+ p_sys->idx1.i_entry_max * sizeof( avi_idx1_entry_t ) );
}
-
- if( sout_BufferReallocFromPreHeader( p_sout, p_data, 8 ) )
- {
- /* there isn't enough data in preheader */
- sout_buffer_t *p_hdr;
-
- p_hdr = sout_BufferNew( p_sout, 8 );
- SetFCC( p_hdr->p_buffer, p_stream->fcc );
- SetDWLE( p_hdr->p_buffer + 4, p_data->i_size );
-
- sout_AccessWrite( p_sout->p_access, p_hdr );
- p_mux->i_movi_size += p_hdr->i_size;
-
- }
- else
+ p_data = block_Realloc( p_data, 8, p_data->i_buffer );
+ if( p_data )
{
SetFCC( p_data->p_buffer, p_stream->fcc );
- SetDWLE( p_data->p_buffer + 4, p_data->i_size - 8 );
- }
+ SetDWLE( p_data->p_buffer + 4, p_data->i_buffer - 8 );
- if( p_data->i_size & 0x01 )
- {
- sout_BufferRealloc( p_sout, p_data, p_data->i_size + 1 );
- p_data->i_size += 1;
- }
+ if( p_data->i_buffer & 0x01 )
+ {
+ p_data = block_Realloc( p_data, 0, p_data->i_buffer + 1 );
+ if ( p_data )
+ p_data->p_buffer[ p_data->i_buffer - 1 ] = '\0';
+ }
- sout_AccessWrite( p_sout->p_access, p_data );
- p_mux->i_movi_size += p_data->i_size;
+ if ( p_data )
+ {
+ p_sys->i_movi_size += p_data->i_buffer;
+ sout_AccessOutWrite( p_mux->p_access, p_data );
+ }
+ }
i_count--;
}
return( 0 );
}
-/****************************************************************************/
-/****************************************************************************/
-/****************************************************************************/
-/****************************************************************************/
-
-typedef struct buffer_out_s
-{
- int i_buffer_size;
- int i_buffer;
- uint8_t *p_buffer;
-
-} buffer_out_t;
-
-static void bo_Init( buffer_out_t *p_bo, int i_size, uint8_t *p_buffer )
-{
- p_bo->i_buffer_size = i_size;
- p_bo->i_buffer = 0;
- p_bo->p_buffer = p_buffer;
-}
-static void bo_AddByte( buffer_out_t *p_bo, uint8_t i )
-{
- if( p_bo->i_buffer < p_bo->i_buffer_size )
- {
- p_bo->p_buffer[p_bo->i_buffer] = i;
- }
- p_bo->i_buffer++;
-}
-static void bo_AddWordLE( buffer_out_t *p_bo, uint16_t i )
-{
- bo_AddByte( p_bo, i &0xff );
- bo_AddByte( p_bo, ( ( i >> 8) &0xff ) );
-}
-static void bo_AddWordBE( buffer_out_t *p_bo, uint16_t i )
-{
- bo_AddByte( p_bo, ( ( i >> 8) &0xff ) );
- bo_AddByte( p_bo, i &0xff );
-}
-static void bo_AddDWordLE( buffer_out_t *p_bo, uint32_t i )
-{
- bo_AddWordLE( p_bo, i &0xffff );
- bo_AddWordLE( p_bo, ( ( i >> 16) &0xffff ) );
-}
-static void bo_AddDWordBE( buffer_out_t *p_bo, uint32_t i )
-{
- bo_AddWordBE( p_bo, ( ( i >> 16) &0xffff ) );
- bo_AddWordBE( p_bo, i &0xffff );
-}
-#if 0
-static void bo_AddLWordLE( buffer_out_t *p_bo, uint64_t i )
-{
- bo_AddDWordLE( p_bo, i &0xffffffff );
- bo_AddDWordLE( p_bo, ( ( i >> 32) &0xffffffff ) );
-}
-static void bo_AddLWordBE( buffer_out_t *p_bo, uint64_t i )
-{
- bo_AddDWordBE( p_bo, ( ( i >> 32) &0xffffffff ) );
- bo_AddDWordBE( p_bo, i &0xffffffff );
-}
-#endif
-
-static void bo_AddFCC( buffer_out_t *p_bo, char *fcc )
-{
- bo_AddByte( p_bo, fcc[0] );
- bo_AddByte( p_bo, fcc[1] );
- bo_AddByte( p_bo, fcc[2] );
- bo_AddByte( p_bo, fcc[3] );
-}
-
-static void bo_AddMem( buffer_out_t *p_bo, int i_size, uint8_t *p_mem )
-{
- int i;
-
- for( i = 0; i < i_size; i++ )
- {
- bo_AddByte( p_bo, p_mem[i] );
- }
-}
-
/****************************************************************************
****************************************************************************
**
****************************************************************************
****************************************************************************/
#define AVI_BOX_ENTER( fcc ) \
- buffer_out_t _bo_sav_; \
- bo_AddFCC( p_bo, fcc ); \
- _bo_sav_ = *p_bo; \
- bo_AddDWordLE( p_bo, 0 )
+ int i_datasize_offset; \
+ bo_add_fourcc( p_bo, fcc ); \
+ i_datasize_offset = p_bo->b->i_buffer; \
+ bo_add_32le( p_bo, 0 )
#define AVI_BOX_ENTER_LIST( fcc ) \
AVI_BOX_ENTER( "LIST" ); \
- bo_AddFCC( p_bo, fcc )
+ bo_add_fourcc( p_bo, fcc )
#define AVI_BOX_EXIT( i_err ) \
- if( p_bo->i_buffer&0x01 ) bo_AddByte( p_bo, 0 ); \
- bo_AddDWordLE( &_bo_sav_, p_bo->i_buffer - _bo_sav_.i_buffer - 4 ); \
+ if( p_bo->b->i_buffer&0x01 ) bo_add_8( p_bo, 0 ); \
+ bo_set_32le( p_bo, i_datasize_offset, p_bo->b->i_buffer - i_datasize_offset - 4 ); \
return( i_err );
-static int avi_HeaderAdd_avih( sout_instance_t *p_sout,
- buffer_out_t *p_bo )
+static int avi_HeaderAdd_avih( sout_mux_t *p_mux,
+ bo_t *p_bo )
{
- sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
- avi_stream_t *p_video = NULL;
+ sout_mux_sys_t *p_sys = p_mux->p_sys;
+ avi_stream_t *p_video = NULL;
int i_stream;
uint32_t i_microsecperframe;
int i_maxbytespersec;
int i_totalframes;
AVI_BOX_ENTER( "avih" );
- if( p_mux->i_stream_video >= 0 )
+ if( p_sys->i_stream_video >= 0 )
{
- p_video = &p_mux->stream[p_mux->i_stream_video];
+ p_video = &p_sys->stream[p_sys->i_stream_video];
if( p_video->i_frames <= 0 )
{
- p_video = NULL;
+ // p_video = NULL;
}
}
{
i_microsecperframe =
(uint32_t)( (float)1000000 /
- (float)p_mux->stream[p_mux->i_stream_video].f_fps );
- i_totalframes = p_mux->stream[p_mux->i_stream_video].i_frames;
+ (float)p_sys->stream[p_sys->i_stream_video].f_fps );
+ i_totalframes = p_sys->stream[p_sys->i_stream_video].i_frames;
}
else
{
- msg_Warn( p_sout, "avi file without audio video track isn't a good idea..." );
+ msg_Warn( p_mux, "avi file without video track isn't a good idea..." );
i_microsecperframe = 0;
i_totalframes = 0;
}
- for( i_stream = 0,i_maxbytespersec = 0; i_stream < p_mux->i_streams; i_stream++ )
+ for( i_stream = 0,i_maxbytespersec = 0; i_stream < p_sys->i_streams; i_stream++ )
{
- if( p_mux->stream[p_mux->i_stream_video].i_duration > 0 )
+ if( p_sys->stream[i_stream].i_duration > 0 )
{
i_maxbytespersec +=
- p_mux->stream[p_mux->i_stream_video].i_totalsize /
- p_mux->stream[p_mux->i_stream_video].i_duration;
+ p_sys->stream[i_stream].i_totalsize /
+ p_sys->stream[i_stream].i_duration;
}
}
- bo_AddDWordLE( p_bo, i_microsecperframe );
- bo_AddDWordLE( p_bo, i_maxbytespersec );
- bo_AddDWordLE( p_bo, 0 ); /* padding */
- bo_AddDWordLE( p_bo, AVIF_TRUSTCKTYPE |
- AVIF_HASINDEX |
- AVIF_ISINTERLEAVED ); /* flags */
- bo_AddDWordLE( p_bo, i_totalframes );
- bo_AddDWordLE( p_bo, 0 ); /* initial frame */
- bo_AddDWordLE( p_bo, p_mux->i_streams ); /* streams count */
- bo_AddDWordLE( p_bo, 1024 * 1024 ); /* suggested buffer size */
+ bo_add_32le( p_bo, i_microsecperframe );
+ bo_add_32le( p_bo, i_maxbytespersec );
+ bo_add_32le( p_bo, 0 ); /* padding */
+ bo_add_32le( p_bo, AVIF_TRUSTCKTYPE |
+ AVIF_HASINDEX |
+ AVIF_ISINTERLEAVED ); /* flags */
+ bo_add_32le( p_bo, i_totalframes );
+ bo_add_32le( p_bo, 0 ); /* initial frame */
+ bo_add_32le( p_bo, p_sys->i_streams ); /* streams count */
+ bo_add_32le( p_bo, 1024 * 1024 ); /* suggested buffer size */
if( p_video )
{
- bo_AddDWordLE( p_bo, p_video->p_bih->biWidth );
- bo_AddDWordLE( p_bo, p_video->p_bih->biHeight );
+ bo_add_32le( p_bo, p_video->p_bih->biWidth );
+ bo_add_32le( p_bo, p_video->p_bih->biHeight );
}
else
{
- bo_AddDWordLE( p_bo, 0 );
- bo_AddDWordLE( p_bo, 0 );
+ bo_add_32le( p_bo, 0 );
+ bo_add_32le( p_bo, 0 );
}
- bo_AddDWordLE( p_bo, 0 ); /* ???? */
- bo_AddDWordLE( p_bo, 0 ); /* ???? */
- bo_AddDWordLE( p_bo, 0 ); /* ???? */
- bo_AddDWordLE( p_bo, 0 ); /* ???? */
+ bo_add_32le( p_bo, 0 ); /* ???? */
+ bo_add_32le( p_bo, 0 ); /* ???? */
+ bo_add_32le( p_bo, 0 ); /* ???? */
+ bo_add_32le( p_bo, 0 ); /* ???? */
AVI_BOX_EXIT( 0 );
}
-static int avi_HeaderAdd_strh( sout_instance_t *p_sout,
- buffer_out_t *p_bo,
- avi_stream_t *p_stream )
+static int avi_HeaderAdd_strh( bo_t *p_bo, avi_stream_t *p_stream )
{
-// sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
AVI_BOX_ENTER( "strh" );
switch( p_stream->i_cat )
{
case VIDEO_ES:
{
- bo_AddFCC( p_bo, "vids" );
- bo_AddDWordBE( p_bo, p_stream->p_bih->biCompression );
- bo_AddDWordLE( p_bo, 0 ); /* flags */
- bo_AddWordLE( p_bo, 0 ); /* priority */
- bo_AddWordLE( p_bo, 0 ); /* langage */
- bo_AddDWordLE( p_bo, 0 ); /* initial frame */
- bo_AddDWordLE( p_bo, 1000 );/* scale */
- bo_AddDWordLE( p_bo, (uint32_t)( 1000 * p_stream->f_fps ));
- bo_AddDWordLE( p_bo, 0 ); /* start */
- bo_AddDWordLE( p_bo, p_stream->i_frames );
- bo_AddDWordLE( p_bo, 1024 * 1024 );
- bo_AddDWordLE( p_bo, -1 ); /* quality */
- bo_AddDWordLE( p_bo, 0 ); /* samplesize */
- bo_AddWordLE( p_bo, 0 ); /* ??? */
- bo_AddWordLE( p_bo, 0 ); /* ??? */
- bo_AddWordLE( p_bo, p_stream->p_bih->biWidth );
- bo_AddWordLE( p_bo, p_stream->p_bih->biHeight );
+ bo_add_fourcc( p_bo, "vids" );
+ bo_add_32be( p_bo, p_stream->p_bih->biCompression );
+ bo_add_32le( p_bo, 0 ); /* flags */
+ bo_add_16le( p_bo, 0 ); /* priority */
+ bo_add_16le( p_bo, 0 ); /* langage */
+ bo_add_32le( p_bo, 0 ); /* initial frame */
+ bo_add_32le( p_bo, 1000 );/* scale */
+ bo_add_32le( p_bo, (uint32_t)( 1000 * p_stream->f_fps ));
+ bo_add_32le( p_bo, 0 ); /* start */
+ bo_add_32le( p_bo, p_stream->i_frames );
+ bo_add_32le( p_bo, 1024 * 1024 );
+ bo_add_32le( p_bo, -1 ); /* quality */
+ bo_add_32le( p_bo, 0 ); /* samplesize */
+ bo_add_16le( p_bo, 0 ); /* ??? */
+ bo_add_16le( p_bo, 0 ); /* ??? */
+ bo_add_16le( p_bo, p_stream->p_bih->biWidth );
+ bo_add_16le( p_bo, p_stream->p_bih->biHeight );
}
break;
case AUDIO_ES:
if( i_samplesize > 1 )
{
i_scale = i_samplesize;
- i_rate = i_scale * p_stream->i_bitrate / 8;
+ i_rate = /*i_scale **/ p_stream->i_bitrate / 8;
}
else
{
i_scale = 1000;
i_rate = 1000 * p_stream->i_bitrate / 8;
}
- bo_AddFCC( p_bo, "auds" );
- bo_AddDWordLE( p_bo, 0 ); /* tag */
- bo_AddDWordLE( p_bo, 0 ); /* flags */
- bo_AddWordLE( p_bo, 0 ); /* priority */
- bo_AddWordLE( p_bo, 0 ); /* langage */
- bo_AddDWordLE( p_bo, 0 ); /* initial frame */
- bo_AddDWordLE( p_bo, i_scale );/* scale */
- bo_AddDWordLE( p_bo, i_rate );
- bo_AddDWordLE( p_bo, 0 ); /* start */
- bo_AddDWordLE( p_bo, p_stream->i_frames );
- bo_AddDWordLE( p_bo, 10 * 1024 );
- bo_AddDWordLE( p_bo, -1 ); /* quality */
- bo_AddDWordLE( p_bo, i_samplesize );
- bo_AddWordLE( p_bo, 0 ); /* ??? */
- bo_AddWordLE( p_bo, 0 ); /* ??? */
- bo_AddWordLE( p_bo, 0 );
- bo_AddWordLE( p_bo, 0 );
+ bo_add_fourcc( p_bo, "auds" );
+ bo_add_32le( p_bo, 0 ); /* tag */
+ bo_add_32le( p_bo, 0 ); /* flags */
+ bo_add_16le( p_bo, 0 ); /* priority */
+ bo_add_16le( p_bo, 0 ); /* langage */
+ bo_add_32le( p_bo, 0 ); /* initial frame */
+ bo_add_32le( p_bo, i_scale );/* scale */
+ bo_add_32le( p_bo, i_rate );
+ bo_add_32le( p_bo, 0 ); /* start */
+ bo_add_32le( p_bo, p_stream->i_frames );
+ bo_add_32le( p_bo, 10 * 1024 );
+ bo_add_32le( p_bo, -1 ); /* quality */
+ bo_add_32le( p_bo, i_samplesize );
+ bo_add_16le( p_bo, 0 ); /* ??? */
+ bo_add_16le( p_bo, 0 ); /* ??? */
+ bo_add_16le( p_bo, 0 );
+ bo_add_16le( p_bo, 0 );
}
break;
}
AVI_BOX_EXIT( 0 );
}
-static int avi_HeaderAdd_strf( sout_instance_t *p_sout,
- buffer_out_t *p_bo,
- avi_stream_t *p_stream )
+static int avi_HeaderAdd_strf( bo_t *p_bo, avi_stream_t *p_stream )
{
-// sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
AVI_BOX_ENTER( "strf" );
switch( p_stream->i_cat )
{
case AUDIO_ES:
- bo_AddWordLE( p_bo, p_stream->p_wf->wFormatTag );
- bo_AddWordLE( p_bo, p_stream->p_wf->nChannels );
- bo_AddDWordLE( p_bo, p_stream->p_wf->nSamplesPerSec );
- bo_AddDWordLE( p_bo, p_stream->p_wf->nAvgBytesPerSec );
- bo_AddWordLE( p_bo, p_stream->p_wf->nBlockAlign );
- bo_AddWordLE( p_bo, p_stream->p_wf->wBitsPerSample );
- bo_AddWordLE( p_bo, p_stream->p_wf->cbSize );
- bo_AddMem( p_bo, p_stream->p_wf->cbSize, (uint8_t*)&p_stream->p_wf[1] );
+ bo_add_16le( p_bo, p_stream->p_wf->wFormatTag );
+ bo_add_16le( p_bo, p_stream->p_wf->nChannels );
+ bo_add_32le( p_bo, p_stream->p_wf->nSamplesPerSec );
+ bo_add_32le( p_bo, p_stream->p_wf->nAvgBytesPerSec );
+ bo_add_16le( p_bo, p_stream->p_wf->nBlockAlign );
+ bo_add_16le( p_bo, p_stream->p_wf->wBitsPerSample );
+ bo_add_16le( p_bo, p_stream->p_wf->cbSize );
+ bo_add_mem( p_bo, p_stream->p_wf->cbSize, (uint8_t*)&p_stream->p_wf[1] );
break;
case VIDEO_ES:
- bo_AddDWordLE( p_bo, p_stream->p_bih->biSize );
- bo_AddDWordLE( p_bo, p_stream->p_bih->biWidth );
- bo_AddDWordLE( p_bo, p_stream->p_bih->biHeight );
- bo_AddWordLE( p_bo, p_stream->p_bih->biPlanes );
- bo_AddWordLE( p_bo, p_stream->p_bih->biBitCount );
+ bo_add_32le( p_bo, p_stream->p_bih->biSize );
+ bo_add_32le( p_bo, p_stream->p_bih->biWidth );
+ bo_add_32le( p_bo, p_stream->p_bih->biHeight );
+ bo_add_16le( p_bo, p_stream->p_bih->biPlanes );
+ bo_add_16le( p_bo, p_stream->p_bih->biBitCount );
if( VLC_FOURCC( 0, 0, 0, 1 ) == 0x00000001 )
{
- bo_AddDWordBE( p_bo, p_stream->p_bih->biCompression );
+ bo_add_32be( p_bo, p_stream->p_bih->biCompression );
}
else
{
- bo_AddDWordLE( p_bo, p_stream->p_bih->biCompression );
+ bo_add_32le( p_bo, p_stream->p_bih->biCompression );
}
- bo_AddDWordLE( p_bo, p_stream->p_bih->biSizeImage );
- bo_AddDWordLE( p_bo, p_stream->p_bih->biXPelsPerMeter );
- bo_AddDWordLE( p_bo, p_stream->p_bih->biYPelsPerMeter );
- bo_AddDWordLE( p_bo, p_stream->p_bih->biClrUsed );
- bo_AddDWordLE( p_bo, p_stream->p_bih->biClrImportant );
- bo_AddMem( p_bo,
- p_stream->p_bih->biSize - sizeof( BITMAPINFOHEADER ),
- (uint8_t*)&p_stream->p_bih[1] );
+ bo_add_32le( p_bo, p_stream->p_bih->biSizeImage );
+ bo_add_32le( p_bo, p_stream->p_bih->biXPelsPerMeter );
+ bo_add_32le( p_bo, p_stream->p_bih->biYPelsPerMeter );
+ bo_add_32le( p_bo, p_stream->p_bih->biClrUsed );
+ bo_add_32le( p_bo, p_stream->p_bih->biClrImportant );
+ bo_add_mem( p_bo,
+ p_stream->p_bih->biSize - sizeof( VLC_BITMAPINFOHEADER ),
+ (uint8_t*)&p_stream->p_bih[1] );
break;
}
AVI_BOX_EXIT( 0 );
}
-static int avi_HeaderAdd_strl( sout_instance_t *p_sout,
- buffer_out_t *p_bo,
- avi_stream_t *p_stream )
+static int avi_HeaderAdd_strl( bo_t *p_bo, avi_stream_t *p_stream )
{
-// sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
AVI_BOX_ENTER_LIST( "strl" );
- avi_HeaderAdd_strh( p_sout, p_bo, p_stream );
- avi_HeaderAdd_strf( p_sout, p_bo, p_stream );
+ avi_HeaderAdd_strh( p_bo, p_stream );
+ avi_HeaderAdd_strf( p_bo, p_stream );
AVI_BOX_EXIT( 0 );
}
-static sout_buffer_t *avi_HeaderCreateRIFF( sout_instance_t *p_sout )
+static int avi_HeaderAdd_meta( bo_t *p_bo, const char psz_meta[4],
+ const char *psz_data )
{
- sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
- sout_buffer_t *p_hdr;
- int i_stream;
- int i_maxbytespersec;
- int i_junk;
- buffer_out_t bo;
+ if ( psz_data == NULL ) return 1;
+ const char *psz = psz_data;
+ AVI_BOX_ENTER( psz_meta );
+ while (*psz) bo_add_8( p_bo, *psz++ );
+ bo_add_8( p_bo, 0 );
+ AVI_BOX_EXIT( 0 );
+}
+
+static int avi_HeaderAdd_INFO( sout_mux_t *p_mux, bo_t *p_bo )
+{
+ char *psz;
+
+#define APPLY_META(var, fourcc) \
+ psz = var_InheritString( p_mux, SOUT_CFG_PREFIX var );\
+ if ( psz )\
+ {\
+ avi_HeaderAdd_meta( p_bo, fourcc, psz );\
+ free( psz );\
+ }
+
+ AVI_BOX_ENTER_LIST( "INFO" );
+
+ APPLY_META( "artist", "IART")
+ APPLY_META( "comment", "ICMT")
+ APPLY_META( "copyright","ICOP")
+ APPLY_META( "date", "ICRD")
+ APPLY_META( "genre", "IGNR")
+ APPLY_META( "name", "INAM")
+ APPLY_META( "keywords", "IKEY")
+ APPLY_META( "subject", "ISBJ")
+ APPLY_META( "encoder", "ISFT")
+ /* Some are missing, but are they really useful ?? */
- p_hdr = sout_BufferNew( p_sout, HDR_SIZE );
- memset( p_hdr->p_buffer, 0, HDR_SIZE );
+#undef APPLY_META
- bo_Init( &bo, HDR_SIZE, p_hdr->p_buffer );
+ AVI_BOX_EXIT( 0 );
+}
- bo_AddFCC( &bo, "RIFF" );
- bo_AddDWordLE( &bo, p_mux->i_movi_size + HDR_SIZE - 8 + p_mux->i_idx1_size );
- bo_AddFCC( &bo, "AVI " );
+static block_t *avi_HeaderCreateRIFF( sout_mux_t *p_mux )
+{
+ sout_mux_sys_t *p_sys = p_mux->p_sys;
+ int i_stream;
+ int i_junk;
+ bo_t bo;
- bo_AddFCC( &bo, "LIST" );
- bo_AddDWordLE( &bo, HDR_SIZE - 8);
- bo_AddFCC( &bo, "hdrl" );
+ struct
+ {
+ int i_riffsize;
+ int i_hdrllistsize;
+ int i_hdrldatastart;
+ } offsets;
+
+ if (! bo_init( &bo, HDR_BASE_SIZE ) )
+ return NULL;
+
+ bo_add_fourcc( &bo, "RIFF" );
+ offsets.i_riffsize = bo.b->i_buffer;
+ bo_add_32le( &bo, 0xEFBEADDE );
+ bo_add_fourcc( &bo, "AVI " );
+
+ bo_add_fourcc( &bo, "LIST" );
+ /* HDRL List size should exclude following data in HDR buffer
+ * -12 (RIFF, RIFF size, 'AVI ' tag),
+ * - 8 (hdr1 LIST tag and its size)
+ * - 12 (movi LIST tag, size, 'movi' listType )
+ */
+ offsets.i_hdrllistsize = bo.b->i_buffer;
+ bo_add_32le( &bo, 0xEFBEADDE );
+ bo_add_fourcc( &bo, "hdrl" );
+ offsets.i_hdrldatastart = bo.b->i_buffer;
+
+ avi_HeaderAdd_avih( p_mux, &bo );
+ for( i_stream = 0; i_stream < p_sys->i_streams; i_stream++ )
+ {
+ avi_HeaderAdd_strl( &bo, &p_sys->stream[i_stream] );
+ }
- avi_HeaderAdd_avih( p_sout, &bo );
- for( i_stream = 0,i_maxbytespersec = 0; i_stream < p_mux->i_streams; i_stream++ )
+ /* align on 16 bytes */
+ int i_align = ( ( bo.b->i_buffer + 12 + 0xE ) & ~ 0xF );
+ i_junk = i_align - bo.b->i_buffer;
+ bo_add_fourcc( &bo, "JUNK" );
+ bo_add_32le( &bo, i_junk );
+ for( int i=0; i< i_junk; i++ )
{
- avi_HeaderAdd_strl( p_sout, &bo, &p_mux->stream[i_stream] );
+ bo_add_8( &bo, 0 );
}
- i_junk = HDR_SIZE - bo.i_buffer - 8 - 12;
- bo_AddFCC( &bo, "JUNK" );
- bo_AddDWordLE( &bo, i_junk );
+ /* Now set hdrl size */
+ bo_set_32le( &bo, offsets.i_hdrllistsize,
+ bo.b->i_buffer - offsets.i_hdrldatastart );
+
+ avi_HeaderAdd_INFO( p_mux, &bo );
+
+ bo_add_fourcc( &bo, "LIST" );
+ bo_add_32le( &bo, p_sys->i_movi_size + 4 );
+ bo_add_fourcc( &bo, "movi" );
- bo.i_buffer += i_junk;
- bo_AddFCC( &bo, "LIST" );
- bo_AddDWordLE( &bo, p_mux->i_movi_size + 4 );
- bo_AddFCC( &bo, "movi" );
+ /* Now set RIFF size */
+ bo_set_32le( &bo, offsets.i_riffsize, bo.b->i_buffer - 8
+ + p_sys->i_movi_size + p_sys->i_idx1_size );
- return( p_hdr );
+ return( bo.b );
}
-static sout_buffer_t * avi_HeaderCreateidx1( sout_instance_t *p_sout )
+static block_t * avi_HeaderCreateidx1( sout_mux_t *p_mux )
{
- sout_mux_t *p_mux = (sout_mux_t*)p_sout->p_mux_data;
- sout_buffer_t *p_idx1;
+ sout_mux_sys_t *p_sys = p_mux->p_sys;
uint32_t i_idx1_size;
- unsigned int i;
- buffer_out_t bo;
+ bo_t bo;
- i_idx1_size = 16 * p_mux->idx1.i_entry_count;
+ i_idx1_size = 16 * p_sys->idx1.i_entry_count + 8;
- p_idx1 = sout_BufferNew( p_sout, i_idx1_size + 8 );
- memset( p_idx1->p_buffer, 0, i_idx1_size );
+ if (!i_idx1_size || !bo_init( &bo, i_idx1_size ) )
+ return NULL;
+ memset( bo.b->p_buffer, 0, i_idx1_size);
- bo_Init( &bo, i_idx1_size, p_idx1->p_buffer );
- bo_AddFCC( &bo, "idx1" );
- bo_AddDWordLE( &bo, i_idx1_size );
+ bo_add_fourcc( &bo, "idx1" );
+ bo_add_32le( &bo, i_idx1_size - 8);
- for( i = 0; i < p_mux->idx1.i_entry_count; i++ )
+ for( unsigned i = 0; i < p_sys->idx1.i_entry_count; i++ )
{
- bo_AddFCC( &bo, p_mux->idx1.entry[i].fcc );
- bo_AddDWordLE( &bo, p_mux->idx1.entry[i].i_flags );
- bo_AddDWordLE( &bo, p_mux->idx1.entry[i].i_pos );
- bo_AddDWordLE( &bo, p_mux->idx1.entry[i].i_length );
+ bo_add_fourcc( &bo, p_sys->idx1.entry[i].fcc );
+ bo_add_32le( &bo, p_sys->idx1.entry[i].i_flags );
+ bo_add_32le( &bo, p_sys->idx1.entry[i].i_pos );
+ bo_add_32le( &bo, p_sys->idx1.entry[i].i_length );
}
- return( p_idx1 );
+ return( bo.b );
}
-
-
projects / vlc / blobdiff