X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fmux%2Fasf.c;h=86adb0f669ef43e3cb1372b88376faaa61796250;hb=a04ff28bae43b4cb37c60789de568a55c4a7be5b;hp=71f790856113d35e6d40e971b95f05a7a2fdf14c;hpb=e5fe2b341fad70233788ceb83533c8d1a5a91d87;p=vlc diff --git a/modules/mux/asf.c b/modules/mux/asf.c index 71f7908561..86adb0f669 100644 --- a/modules/mux/asf.c +++ b/modules/mux/asf.c @@ -1,10 +1,11 @@ /***************************************************************************** - * asf.c + * asf.c: asf muxer module for vlc ***************************************************************************** - * Copyright (C) 2003 VideoLAN - * $Id: asf.c,v 1.6 2003/08/29 01:11:43 fenrir Exp $ + * Copyright (C) 2003-2004, 2006 the VideoLAN team + * $Id$ * * Authors: Laurent Aimar + * Gildas Bazin * * 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 @@ -18,19 +19,28 @@ * * 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. + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA. *****************************************************************************/ /***************************************************************************** * Preamble *****************************************************************************/ -#include -#include -#include -#include +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif + +#include +#include +#include +#include +#include +#include -#include "codecs.h" +typedef GUID guid_t; + +#define MAX_ASF_TRACKS 128 +#define ASF_DATA_PACKET_SIZE 4096 // deprecated -- added sout-asf-packet-size /***************************************************************************** * Module descriptor @@ -38,44 +48,84 @@ static int Open ( vlc_object_t * ); static void Close ( vlc_object_t * ); -vlc_module_begin(); - set_description( _("Asf muxer") ); - set_capability( "sout mux", 5 ); - add_shortcut( "asf" ); - add_shortcut( "asfh" ); - set_callbacks( Open, Close ); -vlc_module_end(); +#define SOUT_CFG_PREFIX "sout-asf-" + +#define TITLE_TEXT N_("Title") +#define TITLE_LONGTEXT N_("Title to put in ASF comments." ) +#define AUTHOR_TEXT N_("Author") +#define AUTHOR_LONGTEXT N_("Author to put in ASF comments." ) +#define COPYRIGHT_TEXT N_("Copyright") +#define COPYRIGHT_LONGTEXT N_("Copyright string to put in ASF comments." ) +#define COMMENT_TEXT N_("Comment") +#define COMMENT_LONGTEXT N_("Comment to put in ASF comments." ) +#define RATING_TEXT N_("Rating") +#define RATING_LONGTEXT N_("\"Rating\" to put in ASF comments." ) +#define PACKETSIZE_TEXT N_("Packet Size") +#define PACKETSIZE_LONGTEXT N_("ASF packet size -- default is 4096 bytes") +#define BITRATE_TEXT N_("Bitrate override") +#define BITRATE_LONGTEXT N_("Do not try to guess ASF bitrate. Setting this, allows you to control how Windows Media Player will cache streamed content. Set to audio+video bitrate in bytes") + + +vlc_module_begin () + set_description( N_("ASF muxer") ) + set_category( CAT_SOUT ) + set_subcategory( SUBCAT_SOUT_MUX ) + set_shortname( "ASF" ) + + set_capability( "sout mux", 5 ) + add_shortcut( "asf" ) + add_shortcut( "asfh" ) + set_callbacks( Open, Close ) + + add_string( SOUT_CFG_PREFIX "title", "", NULL, TITLE_TEXT, TITLE_LONGTEXT, + true ) + add_string( SOUT_CFG_PREFIX "author", "", NULL, AUTHOR_TEXT, + AUTHOR_LONGTEXT, true ) + add_string( SOUT_CFG_PREFIX "copyright","", NULL, COPYRIGHT_TEXT, + COPYRIGHT_LONGTEXT, true ) + add_string( SOUT_CFG_PREFIX "comment", "", NULL, COMMENT_TEXT, + COMMENT_LONGTEXT, true ) + add_string( SOUT_CFG_PREFIX "rating", "", NULL, RATING_TEXT, + RATING_LONGTEXT, true ) + add_integer( SOUT_CFG_PREFIX "packet-size", 4096, NULL, PACKETSIZE_TEXT, + PACKETSIZE_LONGTEXT, true ) + add_integer( SOUT_CFG_PREFIX "bitrate-override", 0, NULL, BITRATE_TEXT, + BITRATE_LONGTEXT, true ) + +vlc_module_end () /***************************************************************************** * Locales prototypes *****************************************************************************/ -static int Capability(sout_mux_t *, int, void *, void * ); -static int AddStream( sout_mux_t *, sout_input_t * ); -static int DelStream( sout_mux_t *, sout_input_t * ); -static int Mux ( sout_mux_t * ); +static const char *const ppsz_sout_options[] = { + "title", "author", "copyright", "comment", "rating", NULL +}; -typedef struct -{ - uint32_t v1; /* le */ - uint16_t v2; /* le */ - uint16_t v3; /* le */ - uint8_t v4[8]; -} guid_t; +static int Control ( sout_mux_t *, int, va_list ); +static int AddStream( sout_mux_t *, sout_input_t * ); +static int DelStream( sout_mux_t *, sout_input_t * ); +static int Mux ( sout_mux_t * ); typedef struct { int i_id; int i_cat; - /* codec informations */ + /* codec information */ uint16_t i_tag; /* for audio */ vlc_fourcc_t i_fourcc; /* for video */ - char *psz_name; /* codec name */ + const char *psz_name; /* codec name */ + int i_blockalign; /* for audio only */ + bool b_audio_correction; int i_sequence; int i_extra; - uint8_t *p_extra; + uint8_t *p_extra; + bool b_extended; + + es_format_t fmt; + } asf_track_t; struct sout_mux_sys_t @@ -85,34 +135,43 @@ struct sout_mux_sys_t int64_t i_packet_count; mtime_t i_dts_first; mtime_t i_dts_last; + mtime_t i_preroll_time; int64_t i_bitrate; + int64_t i_bitrate_override; - int i_track; - asf_track_t track[128]; + vlc_array_t *p_tracks; - vlc_bool_t b_write_header; + bool b_write_header; - sout_buffer_t *pk; + block_t *pk; int i_pk_used; int i_pk_frame; mtime_t i_pk_dts; - vlc_bool_t b_asf_http; + bool b_asf_http; int i_seq; + + /* meta data */ + char *psz_title; + char *psz_author; + char *psz_copyright; + char *psz_comment; + char *psz_rating; }; static int MuxGetStream( sout_mux_t *, int *pi_stream, mtime_t *pi_dts ); -static sout_buffer_t *asf_header_create( sout_mux_t *, vlc_bool_t b_broadcast ); -static sout_buffer_t *asf_packet_create( sout_mux_t *, - asf_track_t *, sout_buffer_t * ); -static sout_buffer_t *asf_stream_end_create( sout_mux_t *); +static block_t *asf_header_create( sout_mux_t *, bool ); +static block_t *asf_packet_create( sout_mux_t *, asf_track_t *, block_t * ); +static block_t *asf_stream_end_create( sout_mux_t *); +static block_t *asf_packet_flush( sout_mux_t * ); typedef struct { int i_buffer_size; int i_buffer; uint8_t *p_buffer; + } bo_t; static void bo_init ( bo_t *, uint8_t *, int ); @@ -122,7 +181,7 @@ static void bo_addle_u32( bo_t *, uint32_t ); static void bo_addle_u64( bo_t *, uint64_t ); static void bo_add_mem ( bo_t *, uint8_t *, int ); -static void bo_addle_str16( bo_t *, char * ); +static void bo_addle_str16( bo_t *, const char * ); /***************************************************************************** * Open: @@ -131,16 +190,20 @@ static int Open( vlc_object_t *p_this ) { sout_mux_t *p_mux = (sout_mux_t*)p_this; sout_mux_sys_t *p_sys; + vlc_value_t val; int i; - msg_Dbg( p_mux, "Asf muxer opened" ); + msg_Dbg( p_mux, "asf muxer opened" ); + config_ChainParse( p_mux, SOUT_CFG_PREFIX, ppsz_sout_options, p_mux->p_cfg ); - p_mux->pf_capacity = Capability; + 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 = malloc( sizeof( sout_mux_sys_t ) ); + if( !p_sys ) + return VLC_ENOMEM; p_sys->b_asf_http = p_mux->psz_mux && !strcmp( p_mux->psz_mux, "asfh" ); if( p_sys->b_asf_http ) { @@ -151,23 +214,50 @@ static int Open( vlc_object_t *p_this ) p_sys->i_pk_frame = 0; p_sys->i_dts_first = -1; p_sys->i_dts_last = 0; + p_sys->i_preroll_time = 2000; p_sys->i_bitrate = 0; + p_sys->i_bitrate_override = 0; p_sys->i_seq = 0; - - p_sys->b_write_header = VLC_TRUE; - p_sys->i_track = 1; - p_sys->i_packet_size = 4096; + p_sys->p_tracks = vlc_array_new(); + + p_sys->b_write_header = true; + p_sys->i_packet_size = config_GetInt( p_mux, "sout-asf-packet-size" ); + p_sys->i_bitrate_override = config_GetInt( p_mux, "sout-asf-bitrate-override" ); + msg_Dbg( p_mux, "Packet size %d", p_sys->i_packet_size); + if (p_sys->i_bitrate_override) + msg_Dbg( p_mux, "Bitrate override %"PRId64, p_sys->i_bitrate_override); p_sys->i_packet_count= 0; - /* generate a random fid */ + + /* Generate a random fid */ srand( mdate() & 0xffffffff ); - p_sys->fid.v1 = 0xbabac001; - p_sys->fid.v2 = ( (uint64_t)rand() << 16 ) / RAND_MAX; - p_sys->fid.v3 = ( (uint64_t)rand() << 16 ) / RAND_MAX; + p_sys->fid.Data1 = 0xbabac001; + p_sys->fid.Data2 = ( (uint64_t)rand() << 16 ) / RAND_MAX; + p_sys->fid.Data3 = ( (uint64_t)rand() << 16 ) / RAND_MAX; for( i = 0; i < 8; i++ ) { - p_sys->fid.v4[i] = ( (uint64_t)rand() << 8 ) / RAND_MAX; + p_sys->fid.Data4[i] = ( (uint64_t)rand() << 8 ) / RAND_MAX; } + /* Meta data */ + var_Get( p_mux, SOUT_CFG_PREFIX "title", &val ); + p_sys->psz_title = val.psz_string; + + var_Get( p_mux, SOUT_CFG_PREFIX "author", &val ); + p_sys->psz_author = val.psz_string; + + var_Get( p_mux, SOUT_CFG_PREFIX "copyright", &val ); + p_sys->psz_copyright = val.psz_string; + + var_Get( p_mux, SOUT_CFG_PREFIX "comment", &val ); + p_sys->psz_comment = val.psz_string; + + var_Get( p_mux, SOUT_CFG_PREFIX "rating", &val ); + p_sys->psz_rating = val.psz_string; + + msg_Dbg( p_mux, "meta data: title='%s', author='%s', copyright='%s', " + "comment='%s', rating='%s'", + p_sys->psz_title, p_sys->psz_author, p_sys->psz_copyright, + p_sys->psz_comment, p_sys->psz_rating ); return VLC_SUCCESS; } @@ -179,44 +269,82 @@ static void Close( vlc_object_t * p_this ) { sout_mux_t *p_mux = (sout_mux_t*)p_this; sout_mux_sys_t *p_sys = p_mux->p_sys; - sout_buffer_t *out; + block_t *out; int i; msg_Dbg( p_mux, "Asf muxer closed" ); + /* Flush last packet if any */ + if( (out = asf_packet_flush( p_mux ) ) ) + { + sout_AccessOutWrite( p_mux->p_access, out ); + } + if( ( out = asf_stream_end_create( p_mux ) ) ) { sout_AccessOutWrite( p_mux->p_access, out ); } /* rewrite header */ - if( !sout_AccessOutSeek( p_mux->p_access, 0 ) ) + if( sout_AccessOutSeek( p_mux->p_access, 0 ) == VLC_SUCCESS ) { - out = asf_header_create( p_mux, VLC_FALSE ); + out = asf_header_create( p_mux, false ); sout_AccessOutWrite( p_mux->p_access, out ); } - for( i = 1; i < p_sys->i_track; i++ ) + + for( i = 0; i < vlc_array_count( p_sys->p_tracks ); i++ ) { - free( p_sys->track[i].p_extra ); + asf_track_t *track = (asf_track_t *)vlc_array_item_at_index( p_sys->p_tracks, i ); + free( track->p_extra ); + es_format_Clean( &track->fmt ); } + + vlc_array_clear( p_sys->p_tracks ); + + vlc_array_destroy( p_sys->p_tracks ); + + free( p_sys->psz_title ); + free( p_sys->psz_author ); + free( p_sys->psz_copyright ); + free( p_sys->psz_comment ); + free( p_sys->psz_rating ); free( p_sys ); } /***************************************************************************** * Capability: *****************************************************************************/ -static int Capability( sout_mux_t *p_mux, int i_query, - void *p_args, void *p_answer ) +static int Control( sout_mux_t *p_mux, int i_query, va_list args ) { - switch( i_query ) - { - case SOUT_MUX_CAP_GET_ADD_STREAM_ANY_TIME: - *(vlc_bool_t*)p_answer = VLC_FALSE; - return( SOUT_MUX_CAP_ERR_OK ); + sout_mux_sys_t *p_sys = p_mux->p_sys; + bool *pb_bool; + char **ppsz; + + switch( i_query ) + { + case MUX_CAN_ADD_STREAM_WHILE_MUXING: + pb_bool = (bool*)va_arg( args, bool * ); + if( p_sys->b_asf_http ) *pb_bool = true; + else *pb_bool = true; + 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 ** ); + if( p_sys->b_asf_http ) + *ppsz = strdup( "video/x-ms-asf-stream" ); + else + *ppsz = strdup( "video/x-ms-asf" ); + return VLC_SUCCESS; + default: - return( SOUT_MUX_CAP_ERR_UNIMPLEMENTED ); - } + return VLC_EGENERIC; + } } /***************************************************************************** @@ -229,102 +357,122 @@ static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input ) bo_t bo; msg_Dbg( p_mux, "adding input" ); - if( p_sys->i_track > 127 ) + if( vlc_array_count( p_sys->p_tracks ) >= MAX_ASF_TRACKS ) { - msg_Dbg( p_mux, "cannot add this track (too much track)" ); + msg_Dbg( p_mux, "cannot add this track (too much tracks)" ); return VLC_EGENERIC; } - tk = p_input->p_sys = &p_sys->track[p_sys->i_track]; - tk->i_id = p_sys->i_track; + tk = p_input->p_sys = malloc( sizeof( asf_track_t ) ); + memset( tk, 0, sizeof( *tk ) ); tk->i_cat = p_input->p_fmt->i_cat; tk->i_sequence = 0; + tk->b_audio_correction = 0; + tk->b_extended = false; switch( tk->i_cat ) { case AUDIO_ES: { - int i_blockalign = p_input->p_fmt->i_block_align; - int i_bitspersample = 0; - int i_extra = 0; + int i_blockalign = p_input->p_fmt->audio.i_blockalign; + int i_bitspersample = p_input->p_fmt->audio.i_bitspersample; + int i_extra = 0; - switch( p_input->p_fmt->i_fourcc ) + switch( p_input->p_fmt->i_codec ) { - case VLC_FOURCC( 'a', '5', '2', ' ' ): + case VLC_CODEC_A52: tk->i_tag = WAVE_FORMAT_A52; tk->psz_name = "A/52"; + i_bitspersample = 0; break; - case VLC_FOURCC( 'm', 'p', 'g', 'a' ): + case VLC_CODEC_MP4A: + tk->i_tag = WAVE_FORMAT_AAC; + tk->psz_name = "MPEG-4 Audio"; + i_bitspersample = 0; + break; + case VLC_CODEC_MPGA: #if 1 tk->psz_name = "MPEG Audio Layer 3"; tk->i_tag = WAVE_FORMAT_MPEGLAYER3; + i_bitspersample = 0; i_blockalign = 1; i_extra = 12; break; #else tk->psz_name = "MPEG Audio Layer 1/2"; tk->i_tag = WAVE_FORMAT_MPEG; + i_bitspersample = 0; i_blockalign = 1; i_extra = 22; break; #endif - case VLC_FOURCC( 'w', 'm', 'a', '1' ): - tk->psz_name = "Windows Media Audio 1"; + case VLC_CODEC_WMA1: + tk->psz_name = "Windows Media Audio v1"; tk->i_tag = WAVE_FORMAT_WMA1; + tk->b_audio_correction = true; break; - case VLC_FOURCC( 'w', 'm', 'a', '2' ): - tk->psz_name = "Windows Media Audio 2"; + case VLC_CODEC_WMA2: + tk->psz_name= "Windows Media Audio (v2) 7, 8 and 9 Series"; tk->i_tag = WAVE_FORMAT_WMA2; + tk->b_audio_correction = true; + break; + case VLC_CODEC_WMAP: + tk->psz_name = "Windows Media Audio 9 Professional"; + tk->i_tag = WAVE_FORMAT_WMAP; + tk->b_audio_correction = true; break; - case VLC_FOURCC( 'w', 'm', 'a', '3' ): - tk->psz_name = "Windows Media Audio 3"; - tk->i_tag = WAVE_FORMAT_WMA3; + case VLC_CODEC_WMAL: + tk->psz_name = "Windows Media Audio 9 Lossless"; + tk->i_tag = WAVE_FORMAT_WMAL; + tk->b_audio_correction = true; break; /* raw codec */ - case VLC_FOURCC( 'u', '8', ' ', ' ' ): + case VLC_CODEC_U8: tk->psz_name = "Raw audio 8bits"; tk->i_tag = WAVE_FORMAT_PCM; - i_blockalign= p_input->p_fmt->i_channels; + i_blockalign= p_input->p_fmt->audio.i_channels; i_bitspersample = 8; break; - case VLC_FOURCC( 's', '1', '6', 'l' ): + case VLC_CODEC_S16L: tk->psz_name = "Raw audio 16bits"; tk->i_tag = WAVE_FORMAT_PCM; - i_blockalign= 2 * p_input->p_fmt->i_channels; + i_blockalign= 2 * p_input->p_fmt->audio.i_channels; i_bitspersample = 16; break; - case VLC_FOURCC( 's', '2', '4', 'l' ): + case VLC_CODEC_S24L: tk->psz_name = "Raw audio 24bits"; tk->i_tag = WAVE_FORMAT_PCM; - i_blockalign= 3 * p_input->p_fmt->i_channels; + i_blockalign= 3 * p_input->p_fmt->audio.i_channels; i_bitspersample = 24; break; - case VLC_FOURCC( 's', '3', '2', 'l' ): + case VLC_CODEC_S32L: tk->psz_name = "Raw audio 32bits"; tk->i_tag = WAVE_FORMAT_PCM; - i_blockalign= 4 * p_input->p_fmt->i_channels; + i_blockalign= 4 * p_input->p_fmt->audio.i_channels; i_bitspersample = 32; break; default: return VLC_EGENERIC; } - tk->i_extra = sizeof( WAVEFORMATEX ) + - p_input->p_fmt->i_extra_data + i_extra; + p_input->p_fmt->i_extra + i_extra; tk->p_extra = malloc( tk->i_extra ); + if( !tk->p_extra ) + return VLC_ENOMEM; bo_init( &bo, tk->p_extra, tk->i_extra ); bo_addle_u16( &bo, tk->i_tag ); - bo_addle_u16( &bo, p_input->p_fmt->i_channels ); - bo_addle_u32( &bo, p_input->p_fmt->i_sample_rate ); + bo_addle_u16( &bo, p_input->p_fmt->audio.i_channels ); + bo_addle_u32( &bo, p_input->p_fmt->audio.i_rate ); bo_addle_u32( &bo, p_input->p_fmt->i_bitrate / 8 ); bo_addle_u16( &bo, i_blockalign ); + tk->i_blockalign = i_blockalign; bo_addle_u16( &bo, i_bitspersample ); - if( p_input->p_fmt->i_extra_data > 0 ) + if( p_input->p_fmt->i_extra > 0 ) { - bo_addle_u16( &bo, p_input->p_fmt->i_extra_data ); - bo_add_mem ( &bo, p_input->p_fmt->p_extra_data, - p_input->p_fmt->i_extra_data ); + bo_addle_u16( &bo, p_input->p_fmt->i_extra ); + bo_add_mem ( &bo, p_input->p_fmt->p_extra, + p_input->p_fmt->i_extra ); } else { @@ -343,7 +491,7 @@ static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input ) msg_Dbg( p_mux, "adding mp2 header" ); bo_addle_u16( &bo, 2 ); /* fwHeadLayer */ bo_addle_u32( &bo, p_input->p_fmt->i_bitrate ); - bo_addle_u16( &bo, p_input->p_fmt->i_channels == 2 ?1:8 ); + bo_addle_u16( &bo, p_input->p_fmt->audio.i_channels == 2 ?1:8 ); bo_addle_u16( &bo, 0 ); /* fwHeadModeExt */ bo_addle_u16( &bo, 1 ); /* wHeadEmphasis */ bo_addle_u16( &bo, 16 ); /* fwHeadFlags */ @@ -358,72 +506,117 @@ static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input ) } else { - p_sys->i_bitrate += 512000; + p_sys->i_bitrate += 128000; } + if (p_sys->i_bitrate_override) + p_sys->i_bitrate = p_sys->i_bitrate_override; break; } case VIDEO_ES: { - tk->i_extra = 11 + sizeof( BITMAPINFOHEADER ) + - p_input->p_fmt->i_extra_data; - tk->p_extra = malloc( tk->i_extra ); - bo_init( &bo, tk->p_extra, tk->i_extra ); - bo_addle_u32( &bo, p_input->p_fmt->i_width ); - bo_addle_u32( &bo, p_input->p_fmt->i_height ); - bo_add_u8 ( &bo, 0x02 ); /* flags */ - bo_addle_u16( &bo, sizeof( BITMAPINFOHEADER ) + - p_input->p_fmt->i_extra_data ); - bo_addle_u32( &bo, sizeof( BITMAPINFOHEADER ) + - p_input->p_fmt->i_extra_data ); - bo_addle_u32( &bo, p_input->p_fmt->i_width ); - bo_addle_u32( &bo, p_input->p_fmt->i_height ); - bo_addle_u16( &bo, 1 ); - bo_addle_u16( &bo, 24 ); - if( p_input->p_fmt->i_fourcc == VLC_FOURCC('m','p','4','v') ) + const es_format_t *p_fmt = p_input->p_fmt; + uint8_t *p_codec_extra = NULL; + int i_codec_extra = 0; + + if( p_input->p_fmt->i_codec == VLC_CODEC_MP4V ) { tk->psz_name = "MPEG-4 Video"; tk->i_fourcc = VLC_FOURCC( 'M', 'P', '4', 'S' ); } - else if( p_input->p_fmt->i_fourcc == VLC_FOURCC('D','I','V','3') ) + else if( p_input->p_fmt->i_codec == VLC_CODEC_DIV3 ) { tk->psz_name = "MSMPEG-4 V3 Video"; tk->i_fourcc = VLC_FOURCC( 'M', 'P', '4', '3' ); } - else if( p_input->p_fmt->i_fourcc == VLC_FOURCC('D','I','V','2') ) + else if( p_input->p_fmt->i_codec == VLC_CODEC_DIV2 ) { tk->psz_name = "MSMPEG-4 V2 Video"; tk->i_fourcc = VLC_FOURCC( 'M', 'P', '4', '2' ); } - else if( p_input->p_fmt->i_fourcc == VLC_FOURCC('D','I','V','1') ) + else if( p_input->p_fmt->i_codec == VLC_CODEC_DIV2 ) { tk->psz_name = "MSMPEG-4 V1 Video"; tk->i_fourcc = VLC_FOURCC( 'M', 'P', 'G', '4' ); } - else if( p_input->p_fmt->i_fourcc == VLC_FOURCC('W','M','V','1') ) + else if( p_input->p_fmt->i_codec == VLC_CODEC_WMV1 ) { - tk->psz_name = "Windows Media Video 1"; + tk->psz_name = "Windows Media Video 7"; tk->i_fourcc = VLC_FOURCC( 'W', 'M', 'V', '1' ); } - else if( p_input->p_fmt->i_fourcc == VLC_FOURCC('W','M','V','2') ) + else if( p_input->p_fmt->i_codec == VLC_CODEC_WMV2 ) { - tk->psz_name = "Windows Media Video 2"; + tk->psz_name = "Windows Media Video 8"; tk->i_fourcc = VLC_FOURCC( 'W', 'M', 'V', '2' ); } + else if( p_input->p_fmt->i_codec == VLC_CODEC_WMV3 ) + { + tk->psz_name = "Windows Media Video 9"; + tk->i_fourcc = VLC_FOURCC( 'W', 'M', 'V', '3' ); + } + else if( p_input->p_fmt->i_codec == VLC_CODEC_VC1 ) + { + tk->psz_name = "Windows Media Video 9 Advanced Profile"; + tk->i_fourcc = VLC_FOURCC( 'W', 'V', 'C', '1' ); + tk->b_extended = true; + + if( p_fmt->i_extra > 0 ) + { + p_codec_extra = malloc( 1 + p_fmt->i_extra ); + if( p_codec_extra ) + { + i_codec_extra = 1 + p_fmt->i_extra; + p_codec_extra[0] = 0x01; + memcpy( &p_codec_extra[1], p_fmt->p_extra, p_fmt->i_extra ); + } + } + } + else if( p_input->p_fmt->i_codec == VLC_CODEC_H264 ) + { + tk->psz_name = "H.264/MPEG-4 AVC"; + tk->i_fourcc = VLC_FOURCC('h','2','6','4'); + } else { - tk->psz_name = "Unknow Video"; - tk->i_fourcc = p_input->p_fmt->i_fourcc; + tk->psz_name = _("Unknown Video"); + tk->i_fourcc = p_input->p_fmt->i_original_fourcc ?: p_input->p_fmt->i_codec; + } + if( !i_codec_extra && p_fmt->i_extra > 0 ) + { + p_codec_extra = malloc( p_fmt->i_extra ); + if( p_codec_extra ) + { + i_codec_extra = p_fmt->i_extra; + memcpy( p_codec_extra, p_fmt->p_extra, p_fmt->i_extra ); + } + } + + tk->i_extra = 11 + sizeof( BITMAPINFOHEADER ) + i_codec_extra; + tk->p_extra = malloc( tk->i_extra ); + if( !tk->p_extra ) + { + free( p_codec_extra ); + return VLC_ENOMEM; } + bo_init( &bo, tk->p_extra, tk->i_extra ); + bo_addle_u32( &bo, p_input->p_fmt->video.i_width ); + bo_addle_u32( &bo, p_input->p_fmt->video.i_height ); + bo_add_u8 ( &bo, 0x02 ); /* flags */ + bo_addle_u16( &bo, sizeof( BITMAPINFOHEADER ) + i_codec_extra ); + bo_addle_u32( &bo, sizeof( BITMAPINFOHEADER ) + i_codec_extra ); + bo_addle_u32( &bo, p_input->p_fmt->video.i_width ); + bo_addle_u32( &bo, p_input->p_fmt->video.i_height ); + bo_addle_u16( &bo, 1 ); + bo_addle_u16( &bo, 24 ); bo_add_mem( &bo, (uint8_t*)&tk->i_fourcc, 4 ); bo_addle_u32( &bo, 0 ); bo_addle_u32( &bo, 0 ); bo_addle_u32( &bo, 0 ); bo_addle_u32( &bo, 0 ); bo_addle_u32( &bo, 0 ); - if( p_input->p_fmt->i_extra_data > 0 ) + if( i_codec_extra > 0 ) { - bo_add_mem ( &bo, p_input->p_fmt->p_extra_data, - p_input->p_fmt->i_extra_data ); + bo_add_mem( &bo, p_codec_extra, i_codec_extra ); + free( p_codec_extra ); } if( p_input->p_fmt->i_bitrate > 50000 ) @@ -432,8 +625,10 @@ static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input ) } else { - p_sys->i_bitrate += 1000000; + p_sys->i_bitrate += 512000; } + if( p_sys->i_bitrate_override ) + p_sys->i_bitrate = p_sys->i_bitrate_override; break; } default: @@ -441,7 +636,14 @@ static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input ) return VLC_EGENERIC; } - p_sys->i_track++; + es_format_Copy( &tk->fmt, p_input->p_fmt ); + + vlc_array_append( p_sys->p_tracks, (void *)tk); + tk->i_id = vlc_array_index_of_item( p_sys->p_tracks, tk ) + 1; + + + p_sys->b_write_header = true; + return VLC_SUCCESS; } @@ -450,25 +652,51 @@ static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input ) *****************************************************************************/ static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input ) { + /* if bitrate ain't defined in commanline, reduce it when tracks are deleted + */ + sout_mux_sys_t *p_sys = p_mux->p_sys; + asf_track_t *tk = p_input->p_sys; msg_Dbg( p_mux, "removing input" ); + if(!p_sys->i_bitrate_override) + { + if( tk->i_cat == AUDIO_ES ) + { + if( p_input->p_fmt->i_bitrate > 24000 ) + p_sys->i_bitrate -= p_input->p_fmt->i_bitrate; + else + p_sys->i_bitrate -= 128000; + } + else if(tk->i_cat == VIDEO_ES ) + { + if( p_input->p_fmt->i_bitrate > 50000 ) + p_sys->i_bitrate -= p_input->p_fmt->i_bitrate; + else + p_sys->i_bitrate -= 512000; + } + } + + vlc_array_remove( p_sys->p_tracks, vlc_array_index_of_item( p_sys->p_tracks, (void *)tk ) ); + + + p_sys->b_write_header = true; return VLC_SUCCESS; } /***************************************************************************** * Mux: *****************************************************************************/ -static int Mux ( sout_mux_t *p_mux ) +static int Mux( sout_mux_t *p_mux ) { sout_mux_sys_t *p_sys = p_mux->p_sys; if( p_sys->b_write_header ) { - sout_buffer_t *out = asf_header_create( p_mux, VLC_TRUE ); + block_t *out = asf_header_create( p_mux, true ); - out->i_flags |= SOUT_BUFFER_FLAGS_HEADER; + out->i_flags |= BLOCK_FLAG_HEADER; sout_AccessOutWrite( p_mux->p_access, out ); - p_sys->b_write_header = VLC_FALSE; + p_sys->b_write_header = false; } for( ;; ) @@ -477,8 +705,8 @@ static int Mux ( sout_mux_t *p_mux ) asf_track_t *tk; int i_stream; mtime_t i_dts; - sout_buffer_t *data; - sout_buffer_t *pk; + block_t *data; + block_t *pk; if( MuxGetStream( p_mux, &i_stream, &i_dts ) ) { @@ -498,7 +726,25 @@ static int Mux ( sout_mux_t *p_mux ) p_input = p_mux->pp_inputs[i_stream]; tk = (asf_track_t*)p_input->p_sys; - data = sout_FifoGet( p_input->p_fifo ); + data = block_FifoGet( p_input->p_fifo ); + + /* Convert VC1 to ASF special format */ + if( tk->i_fourcc == VLC_FOURCC( 'W', 'V', 'C', '1' ) ) + { + while( data->i_buffer >= 4 && + ( data->p_buffer[0] != 0x00 || data->p_buffer[1] != 0x00 || + data->p_buffer[2] != 0x01 || + ( data->p_buffer[3] != 0x0D && data->p_buffer[3] != 0x0C ) ) ) + { + data->i_buffer--; + data->p_buffer++; + } + if( data->i_buffer >= 4 ) + { + data->i_buffer -= 4; + data->p_buffer += 4; + } + } if( ( pk = asf_packet_create( p_mux, tk, data ) ) ) { @@ -509,10 +755,7 @@ static int Mux ( sout_mux_t *p_mux ) return VLC_SUCCESS; } - -static int MuxGetStream( sout_mux_t *p_mux, - int *pi_stream, - mtime_t *pi_dts ) +static int MuxGetStream( sout_mux_t *p_mux, int *pi_stream, mtime_t *pi_dts ) { mtime_t i_dts; int i_stream; @@ -521,9 +764,9 @@ static int MuxGetStream( sout_mux_t *p_mux, for( i = 0, i_dts = 0, i_stream = -1; i < p_mux->i_nb_inputs; i++ ) { sout_input_t *p_input = p_mux->pp_inputs[i]; - sout_buffer_t *p_data; + block_t *p_data; - if( p_input->p_fifo->i_depth <= 0 ) + if( block_FifoCount( p_input->p_fifo ) <= 0 ) { if( p_input->p_fmt->i_cat == AUDIO_ES || p_input->p_fmt->i_cat == VIDEO_ES ) @@ -535,9 +778,8 @@ static int MuxGetStream( sout_mux_t *p_mux, continue; } - p_data = sout_FifoShow( p_input->p_fifo ); - if( i_stream == -1 || - p_data->i_dts < i_dts ) + p_data = block_FifoShow( p_input->p_fifo ); + if( i_stream == -1 || p_data->i_dts < i_dts ) { i_stream = i; i_dts = p_data->i_dts; @@ -593,135 +835,85 @@ static void bo_add_mem( bo_t *p_bo, uint8_t *p_mem, int i_size ) if( i_copy > 0 ) { - memcpy( &p_bo->p_buffer[p_bo->i_buffer], - p_mem, - i_copy ); + memcpy( &p_bo->p_buffer[p_bo->i_buffer], p_mem, i_copy ); } p_bo->i_buffer += i_size; } -static void bo_addle_str16( bo_t *bo, char *str ) +static void bo_addle_str16( bo_t *bo, const char *str ) { bo_addle_u16( bo, strlen( str ) + 1 ); for( ;; ) { - uint16_t c; + uint16_t c = (uint8_t)*str++; + bo_addle_u16( bo, c ); + if( c == '\0' ) break; + } +} - c = (uint8_t)*str++; +static void bo_addle_str16_nosize( bo_t *bo, const char *str ) +{ + for( ;; ) + { + uint16_t c = (uint8_t)*str++; bo_addle_u16( bo, c ); - if( c == '\0' ) - { - break; - } + if( c == '\0' ) break; } } /**************************************************************************** - * guid + * GUID definitions ****************************************************************************/ static void bo_add_guid( bo_t *p_bo, const guid_t *id ) { int i; - bo_addle_u32( p_bo, id->v1 ); - bo_addle_u16( p_bo, id->v2 ); - bo_addle_u16( p_bo, id->v3 ); + bo_addle_u32( p_bo, id->Data1 ); + bo_addle_u16( p_bo, id->Data2 ); + bo_addle_u16( p_bo, id->Data3 ); for( i = 0; i < 8; i++ ) { - bo_add_u8( p_bo, id->v4[i] ); + bo_add_u8( p_bo, id->Data4[i] ); } } static const guid_t asf_object_header_guid = -{ - 0x75B22630, - 0x668E, - 0x11CF, - { 0xA6,0xD9, 0x00,0xAA,0x00,0x62,0xCE,0x6C } -}; +{0x75B22630, 0x668E, 0x11CF, {0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C}}; static const guid_t asf_object_data_guid = -{ - 0x75B22636, - 0x668E, - 0x11CF, - { 0xA6,0xD9, 0x00,0xAA,0x00,0x62,0xCE,0x6C } -}; - +{0x75B22636, 0x668E, 0x11CF, {0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C}}; static const guid_t asf_object_file_properties_guid = -{ - 0x8cabdca1, - 0xa947, - 0x11cf, - { 0x8e,0xe4, 0x00,0xC0,0x0C,0x20,0x53,0x65 } - -}; +{0x8cabdca1, 0xa947, 0x11cf, {0x8e, 0xe4, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65}}; static const guid_t asf_object_stream_properties_guid = -{ - 0xB7DC0791, - 0xA9B7, - 0x11CF, - { 0x8E,0xE6, 0x00,0xC0,0x0C,0x20,0x53,0x65 } - -}; -static const guid_t asf_object_header_extention_guid = -{ - 0x5FBF03B5, - 0xA92E, - 0x11CF, - { 0x8E,0xE3, 0x00,0xC0,0x0C,0x20,0x53,0x65 } -}; - +{0xB7DC0791, 0xA9B7, 0x11CF, {0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65}}; +static const guid_t asf_object_header_extension_guid = +{0x5FBF03B5, 0xA92E, 0x11CF, {0x8E, 0xE3, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65}}; static const guid_t asf_object_stream_type_audio = -{ - 0xF8699E40, - 0x5B4D, - 0x11CF, - { 0xA8,0xFD, 0x00,0x80,0x5F,0x5C,0x44,0x2B } -}; - +{0xF8699E40, 0x5B4D, 0x11CF, {0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B}}; static const guid_t asf_object_stream_type_video = -{ - 0xbc19efc0, - 0x5B4D, - 0x11CF, - { 0xA8,0xFD, 0x00,0x80,0x5F,0x5C,0x44,0x2B } -}; - +{0xbc19efc0, 0x5B4D, 0x11CF, {0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B}}; static const guid_t asf_guid_audio_conceal_none = -{ - 0x20FB5700, - 0x5B55, - 0x11CF, - { 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B } -}; +{0x20FB5700, 0x5B55, 0x11CF, {0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B}}; +static const guid_t asf_guid_audio_conceal_spread = +{0xBFC3CD50, 0x618F, 0x11CF, {0x8B, 0xB2, 0x00, 0xAA, 0x00, 0xB4, 0xE2, 0x20}}; static const guid_t asf_guid_video_conceal_none = -{ - 0x20FB5700, - 0x5B55, - 0x11CF, - { 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B } -}; +{0x20FB5700, 0x5B55, 0x11CF, {0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B}}; static const guid_t asf_guid_reserved_1 = -{ - 0xABD3D211, - 0xA9BA, - 0x11cf, - { 0x8E, 0xE6,0x00, 0xC0, 0x0C ,0x20, 0x53, 0x65 } -}; -static const guid_t asf_object_comment_guid = -{ - 0x86D15240, - 0x311D, - 0x11D0, - { 0xA3, 0xA4, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6 } -}; -static const guid_t asf_object_comment_reserved_guid = -{ - 0x86D15241, - 0x311D, - 0x11D0, - { 0xA3, 0xA4, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6 } -}; +{0xABD3D211, 0xA9BA, 0x11cf, {0x8E, 0xE6, 0x00, 0xC0, 0x0C ,0x20, 0x53, 0x65}}; +static const guid_t asf_object_codec_list_guid = +{0x86D15240, 0x311D, 0x11D0, {0xA3, 0xA4, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6}}; +static const guid_t asf_object_codec_list_reserved_guid = +{0x86D15241, 0x311D, 0x11D0, {0xA3, 0xA4, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6}}; +static const guid_t asf_object_content_description_guid = +{0x75B22633, 0x668E, 0x11CF, {0xa6, 0xd9, 0x00, 0xaa, 0x00, 0x62, 0xce, 0x6c}}; +static const guid_t asf_object_index_guid = +{0x33000890, 0xE5B1, 0x11CF, {0x89, 0xF4, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xCB}}; +static const guid_t asf_object_metadata_guid = +{0xC5F8CBEA, 0x5BAF, 0x4877, {0x84, 0x67, 0xAA, 0x8C, 0x44, 0xFA, 0x4C, 0xCA}}; +static const guid_t asf_object_extended_stream_properties_guid = +{0x14E6A5CB, 0xC672, 0x4332, {0x83, 0x99, 0xA9, 0x69, 0x52, 0x06, 0x5B, 0x5A}}; +/**************************************************************************** + * Misc + ****************************************************************************/ static void asf_chunk_add( bo_t *bo, int i_type, int i_len, int i_flags, int i_seq ) { @@ -732,62 +924,90 @@ static void asf_chunk_add( bo_t *bo, bo_addle_u16( bo, i_len + 8 ); } -static sout_buffer_t *asf_header_create( sout_mux_t *p_mux, - vlc_bool_t b_broadcast ) +static block_t *asf_header_create( sout_mux_t *p_mux, bool b_broadcast ) { sout_mux_sys_t *p_sys = p_mux->p_sys; asf_track_t *tk; + mtime_t i_duration = 0; + int i_size, i_header_ext_size, i; + int i_ci_size, i_cm_size = 0, i_cd_size = 0; + block_t *out; + bo_t bo; - mtime_t i_duration = 0; - int i_size; - int i_ci_size; - sout_buffer_t *out; - bo_t bo; - int i; + msg_Dbg( p_mux, "Asf muxer creating header" ); if( p_sys->i_dts_first > 0 ) { i_duration = p_sys->i_dts_last - p_sys->i_dts_first; - if( i_duration < 0 ) - { - i_duration = 0; - } + if( i_duration < 0 ) i_duration = 0; } /* calculate header size */ - i_size = 30 + 104 + 46; + i_size = 30 + 104; i_ci_size = 44; - for( i = 1; i < p_sys->i_track; i++ ) + for( i = 0; i < vlc_array_count( p_sys->p_tracks ); i++ ) { - i_size += 78 + p_sys->track[i].i_extra; - i_ci_size += 8 + 2 * strlen( p_sys->track[i].psz_name ); - if( p_sys->track[i].i_cat == AUDIO_ES ) - { - i_ci_size += 4; - } - else if( p_sys->track[i].i_cat == VIDEO_ES ) + tk = vlc_array_item_at_index( p_sys->p_tracks, i ); + /* update also track-id */ + tk->i_id = i + 1; + + i_size += 78 + tk->i_extra; + i_ci_size += 8 + 2 * strlen( tk->psz_name ); + if( tk->i_cat == AUDIO_ES ) i_ci_size += 4; + else if( tk->i_cat == VIDEO_ES ) i_ci_size += 6; + + /* Error correction data field */ + if( tk->b_audio_correction ) i_size += 8; + } + + /* size of the content description object */ + if( *p_sys->psz_title || *p_sys->psz_author || *p_sys->psz_copyright || + *p_sys->psz_comment || *p_sys->psz_rating ) + { + i_cd_size = 34 + 2 * ( strlen( p_sys->psz_title ) + 1 + + strlen( p_sys->psz_author ) + 1 + + strlen( p_sys->psz_copyright ) + 1 + + strlen( p_sys->psz_comment ) + 1 + + strlen( p_sys->psz_rating ) + 1 ); + } + + i_header_ext_size = 46; + + /* size of the metadata object */ + for( i = 0; i < vlc_array_count( p_sys->p_tracks ); i++ ) + { + const asf_track_t *p_track = vlc_array_item_at_index( p_sys->p_tracks, i ); + if( p_track->i_cat == VIDEO_ES && p_track->fmt.video.i_aspect != 0 ) { - i_ci_size += 6; + i_cm_size = 26 + 2 * (16 + 2 * sizeof("AspectRatio?")); + break; } + if( p_track->b_extended ) + i_header_ext_size += 88; + } - i_size += i_ci_size; + i_header_ext_size += i_cm_size; + + i_size += i_ci_size + i_cd_size + i_header_ext_size ; if( p_sys->b_asf_http ) { - out = sout_BufferNew( p_mux->p_sout, i_size + 50 + 12 ); + out = block_New( p_mux, i_size + 50 + 12 ); bo_init( &bo, out->p_buffer, i_size + 50 + 12 ); asf_chunk_add( &bo, 0x4824, i_size + 50, 0xc00, p_sys->i_seq++ ); } else { - out = sout_BufferNew( p_mux->p_sout, i_size + 50 ); + out = block_New( p_mux, i_size + 50 ); bo_init( &bo, out->p_buffer, i_size + 50 ); } + /* header object */ bo_add_guid ( &bo, &asf_object_header_guid ); bo_addle_u64( &bo, i_size ); - bo_addle_u32( &bo, 2 + p_sys->i_track - 1 ); + bo_addle_u32( &bo, 2 + vlc_array_count( p_sys->p_tracks ) + 1 + + (i_cd_size ? 1 : 0) + (i_cm_size ? 1 : 0) ); bo_add_u8 ( &bo, 1 ); bo_add_u8 ( &bo, 2 ); @@ -803,30 +1023,127 @@ static sout_buffer_t *asf_header_create( sout_mux_t *p_mux, bo_addle_u64( &bo, b_broadcast ? 0xffffffffLL : p_sys->i_packet_count ); bo_addle_u64( &bo, i_duration * 10 ); /* play duration (100ns) */ bo_addle_u64( &bo, i_duration * 10 ); /* send duration (100ns) */ - bo_addle_u64( &bo, 3000 ); /* preroll duration (ms) */ - bo_addle_u32( &bo, b_broadcast ? 0x01 : 0x00); /* flags */ + bo_addle_u64( &bo, p_sys->i_preroll_time ); /* preroll duration (ms) */ + bo_addle_u32( &bo, b_broadcast ? 0x01 : 0x02 /* seekable */ ); /* flags */ bo_addle_u32( &bo, p_sys->i_packet_size ); /* packet size min */ bo_addle_u32( &bo, p_sys->i_packet_size ); /* packet size max */ bo_addle_u32( &bo, p_sys->i_bitrate ); /* maxbitrate */ - /* header extention */ - bo_add_guid ( &bo, &asf_object_header_extention_guid ); - bo_addle_u64( &bo, 46 ); + /* header extension */ + bo_add_guid ( &bo, &asf_object_header_extension_guid ); + bo_addle_u64( &bo, i_header_ext_size ); bo_add_guid ( &bo, &asf_guid_reserved_1 ); bo_addle_u16( &bo, 6 ); - bo_addle_u32( &bo, 0 ); + bo_addle_u32( &bo, i_header_ext_size - 46 ); + + /* extended stream properties */ + for( i = 0; i < vlc_array_count( p_sys->p_tracks ); i++ ) + { + const asf_track_t *p_track = vlc_array_item_at_index( p_sys->p_tracks, i ); + const es_format_t *p_fmt = &p_track->fmt; + + if( !p_track->b_extended ) + continue; + + uint64_t i_avg_duration = 0; + if( p_fmt->i_cat == VIDEO_ES && + p_fmt->video.i_frame_rate > 0 && p_fmt->video.i_frame_rate_base > 0 ) + i_avg_duration = ( INT64_C(10000000) * p_fmt->video.i_frame_rate_base + + p_fmt->video.i_frame_rate/2 ) / p_fmt->video.i_frame_rate; + + bo_add_guid ( &bo, &asf_object_extended_stream_properties_guid ); + bo_addle_u64( &bo, 88 ); + bo_addle_u64( &bo, 0 ); + bo_addle_u64( &bo, 0 ); + bo_addle_u32( &bo, p_fmt->i_bitrate ); /* Bitrate */ + bo_addle_u32( &bo, 0 ); /* Buffer size */ + bo_addle_u32( &bo, 0 ); /* Initial buffer fullness */ + bo_addle_u32( &bo, p_fmt->i_bitrate ); /* Alternate Bitrate */ + bo_addle_u32( &bo, 0 ); /* Alternate Buffer size */ + bo_addle_u32( &bo, 0 ); /* Alternate Initial buffer fullness */ + bo_addle_u32( &bo, 0 ); /* Maximum object size (0 = unkown) */ + bo_addle_u32( &bo, 0x02 ); /* Flags (seekable) */ + bo_addle_u16( &bo, tk->i_id ); /* Stream number */ + bo_addle_u16( &bo, 0 ); /* Stream language index */ + bo_addle_u64( &bo, i_avg_duration ); /* Average time per frame */ + bo_addle_u16( &bo, 0 ); /* Stream name count */ + bo_addle_u16( &bo, 0 ); /* Payload extension system count */ + } + + /* metadata object (part of header extension) */ + if( i_cm_size ) + { + int64_t i_num, i_den; + unsigned int i_dst_num, i_dst_den; + asf_track_t *tk; + + for( i = 0; i < vlc_array_count( p_sys->p_tracks ); i++ ) + { + tk = vlc_array_item_at_index( p_sys->p_tracks, i ); + if( tk->i_cat == VIDEO_ES ) break; + } + + i_num = tk->fmt.video.i_aspect * + (int64_t)tk->fmt.video.i_height; + i_den = VOUT_ASPECT_FACTOR * tk->fmt.video.i_width; + vlc_ureduce( &i_dst_num, &i_dst_den, i_num, i_den, 0 ); + + msg_Dbg( p_mux, "pixel aspect-ratio: %i/%i", i_dst_num, i_dst_den ); + + bo_add_guid ( &bo, &asf_object_metadata_guid ); + bo_addle_u64( &bo, i_cm_size ); + bo_addle_u16( &bo, 2 ); /* description records count */ + /* 1st description record */ + bo_addle_u16( &bo, 0 ); /* reserved */ + bo_addle_u16( &bo, tk->i_id ); /* stream number (0 for the whole file) */ + bo_addle_u16( &bo, 2 * sizeof("AspectRatioX") ); /* name length */ + bo_addle_u16( &bo, 0x3 /* DWORD */ ); /* data type */ + bo_addle_u32( &bo, 4 ); /* data length */ + bo_addle_str16_nosize( &bo, "AspectRatioX" ); + bo_addle_u32( &bo, i_dst_num ); /* data */ + /* 2nd description record */ + bo_addle_u16( &bo, 0 ); /* reserved */ + bo_addle_u16( &bo, tk->i_id ); /* stream number (0 for the whole file) */ + bo_addle_u16( &bo, 2 * sizeof("AspectRatioY") ); /* name length */ + bo_addle_u16( &bo, 0x3 /* DWORD */ ); /* data type */ + bo_addle_u32( &bo, 4 ); /* data length */ + bo_addle_str16_nosize( &bo, "AspectRatioY" ); + bo_addle_u32( &bo, i_dst_den ); /* data */ + } + + /* content description header */ + if( i_cd_size > 0 ) + { + bo_add_guid ( &bo, &asf_object_content_description_guid ); + bo_addle_u64( &bo, i_cd_size ); + bo_addle_u16( &bo, 2 * strlen( p_sys->psz_title ) + 2 ); + bo_addle_u16( &bo, 2 * strlen( p_sys->psz_author ) + 2 ); + bo_addle_u16( &bo, 2 * strlen( p_sys->psz_copyright ) + 2 ); + bo_addle_u16( &bo, 2 * strlen( p_sys->psz_comment ) + 2 ); + bo_addle_u16( &bo, 2 * strlen( p_sys->psz_rating ) + 2 ); + + bo_addle_str16_nosize( &bo, p_sys->psz_title ); + bo_addle_str16_nosize( &bo, p_sys->psz_author ); + bo_addle_str16_nosize( &bo, p_sys->psz_copyright ); + bo_addle_str16_nosize( &bo, p_sys->psz_comment ); + bo_addle_str16_nosize( &bo, p_sys->psz_rating ); + } /* stream properties */ - for( i = 1; i < p_sys->i_track; i++ ) + for( i = 0; i < vlc_array_count( p_sys->p_tracks ); i++ ) { - tk = &p_sys->track[i]; + tk = vlc_array_item_at_index( p_sys->p_tracks, i); bo_add_guid ( &bo, &asf_object_stream_properties_guid ); - bo_addle_u64( &bo, 78 + tk->i_extra ); + bo_addle_u64( &bo, 78 + tk->i_extra + (tk->b_audio_correction ? 8:0) ); + if( tk->i_cat == AUDIO_ES ) { bo_add_guid( &bo, &asf_object_stream_type_audio ); - bo_add_guid( &bo, &asf_guid_audio_conceal_none ); + if( tk->b_audio_correction ) + bo_add_guid( &bo, &asf_guid_audio_conceal_spread ); + else + bo_add_guid( &bo, &asf_guid_audio_conceal_none ); } else if( tk->i_cat == VIDEO_ES ) { @@ -835,22 +1152,36 @@ static sout_buffer_t *asf_header_create( sout_mux_t *p_mux, } bo_addle_u64( &bo, 0 ); /* time offset */ bo_addle_u32( &bo, tk->i_extra ); - bo_addle_u32( &bo, 0 ); /* 0 */ + /* correction data length */ + bo_addle_u32( &bo, tk->b_audio_correction ? 8 : 0 ); bo_addle_u16( &bo, tk->i_id ); /* stream number */ bo_addle_u32( &bo, 0 ); bo_add_mem ( &bo, tk->p_extra, tk->i_extra ); + + /* Error correction data field */ + if( tk->b_audio_correction ) + { + bo_add_u8( &bo, 0x1 ); /* span */ + bo_addle_u16( &bo, tk->i_blockalign ); /* virtual packet length */ + bo_addle_u16( &bo, tk->i_blockalign ); /* virtual chunck length */ + bo_addle_u16( &bo, 1 ); /* silence length */ + bo_add_u8( &bo, 0x0 ); /* data */ + } } /* Codec Infos */ - bo_add_guid ( &bo, &asf_object_comment_guid ); + bo_add_guid ( &bo, &asf_object_codec_list_guid ); bo_addle_u64( &bo, i_ci_size ); - bo_add_guid ( &bo, &asf_object_comment_reserved_guid ); - bo_addle_u32( &bo, p_sys->i_track - 1 ); - for( i = 1; i < p_sys->i_track; i++ ) + bo_add_guid ( &bo, &asf_object_codec_list_reserved_guid ); + bo_addle_u32( &bo, vlc_array_count( p_sys->p_tracks ) ); + for( i = 0; i < vlc_array_count( p_sys->p_tracks ); i++ ) { - tk = &p_sys->track[i]; + tk = vlc_array_item_at_index( p_sys->p_tracks ,i); + + if( tk->i_cat == VIDEO_ES ) bo_addle_u16( &bo, 1 /* video */ ); + else if( tk->i_cat == AUDIO_ES ) bo_addle_u16( &bo, 2 /* audio */ ); + else bo_addle_u16( &bo, 0xFFFF /* unknown */ ); - bo_addle_u16( &bo, tk->i_id ); bo_addle_str16( &bo, tk->psz_name ); bo_addle_u16( &bo, 0 ); if( tk->i_cat == AUDIO_ES ) @@ -862,7 +1193,6 @@ static sout_buffer_t *asf_header_create( sout_mux_t *p_mux, { bo_addle_u16( &bo, 4 ); bo_add_mem ( &bo, (uint8_t*)&tk->i_fourcc, 4 ); - } } @@ -879,45 +1209,90 @@ static sout_buffer_t *asf_header_create( sout_mux_t *p_mux, /**************************************************************************** * ****************************************************************************/ -static sout_buffer_t *asf_packet_create( sout_mux_t *p_mux, - asf_track_t *tk, sout_buffer_t *data ) +static block_t *asf_packet_flush( sout_mux_t *p_mux ) +{ + sout_mux_sys_t *p_sys = p_mux->p_sys; + int i_pad, i_preheader = p_sys->b_asf_http ? 12 : 0; + block_t *pk; + bo_t bo; + + if( !p_sys->pk ) return 0; + + i_pad = p_sys->i_packet_size - p_sys->i_pk_used; + memset( p_sys->pk->p_buffer + p_sys->i_pk_used, 0, i_pad ); + + bo_init( &bo, p_sys->pk->p_buffer, 14 + i_preheader ); + + if( p_sys->b_asf_http ) + asf_chunk_add( &bo, 0x4424, p_sys->i_packet_size, 0x0, p_sys->i_seq++); + + bo_add_u8 ( &bo, 0x82 ); + bo_addle_u16( &bo, 0 ); + bo_add_u8( &bo, 0x11 ); + bo_add_u8( &bo, 0x5d ); + bo_addle_u16( &bo, i_pad ); + bo_addle_u32( &bo, (p_sys->i_pk_dts - p_sys->i_dts_first) / 1000 + + p_sys->i_preroll_time ); + bo_addle_u16( &bo, 0 /* data->i_length */ ); + bo_add_u8( &bo, 0x80 | p_sys->i_pk_frame ); + + pk = p_sys->pk; + p_sys->pk = NULL; + + p_sys->i_packet_count++; + + return pk; +} + +static block_t *asf_packet_create( sout_mux_t *p_mux, + asf_track_t *tk, block_t *data ) { sout_mux_sys_t *p_sys = p_mux->p_sys; - int i_data = data->i_size; + int i_data = data->i_buffer; int i_pos = 0; uint8_t *p_data= data->p_buffer; - sout_buffer_t *first = NULL, **last = &first; + block_t *first = NULL, **last = &first; int i_preheader = p_sys->b_asf_http ? 12 : 0; while( i_pos < i_data ) { - bo_t bo; - int i_payload; + bo_t bo; + int i_payload; if( p_sys->pk == NULL ) { - p_sys->pk = sout_BufferNew( p_mux->p_sout, - p_sys->i_packet_size + i_preheader); + p_sys->pk = block_New( p_mux, p_sys->i_packet_size + i_preheader ); /* reserve 14 bytes for the packet header */ p_sys->i_pk_used = 14 + i_preheader; p_sys->i_pk_frame = 0; p_sys->i_pk_dts = data->i_dts; } - bo_init( &bo, &p_sys->pk->p_buffer[p_sys->i_pk_used], - p_sys->i_packet_size - p_sys->i_pk_used ); + p_sys->i_packet_size - p_sys->i_pk_used ); /* add payload (header size = 17) */ i_payload = __MIN( i_data - i_pos, p_sys->i_packet_size - p_sys->i_pk_used - 17 ); - bo_add_u8 ( &bo, 0x80 | tk->i_id ); + + if( tk->b_audio_correction && p_sys->i_pk_frame && i_payload < i_data ) + { + /* Don't know why yet but WMP doesn't like splitted WMA packets */ + *last = asf_packet_flush( p_mux ); + last = &(*last)->p_next; + continue; + } + + bo_add_u8 ( &bo, !(data->i_flags & BLOCK_FLAG_TYPE_P || + data->i_flags & BLOCK_FLAG_TYPE_B) ? + 0x80 | tk->i_id : tk->i_id ); bo_add_u8 ( &bo, tk->i_sequence ); bo_addle_u32( &bo, i_pos ); bo_add_u8 ( &bo, 0x08 ); /* flags */ bo_addle_u32( &bo, i_data ); - bo_addle_u32( &bo, ( data->i_dts - p_sys->i_dts_first )/ 1000 ); + bo_addle_u32( &bo, (data->i_dts - p_sys->i_dts_first) / 1000 + + p_sys->i_preroll_time ); bo_addle_u16( &bo, i_payload ); bo_add_mem ( &bo, &p_data[i_pos], i_payload ); i_pos += i_payload; @@ -927,53 +1302,43 @@ static sout_buffer_t *asf_packet_create( sout_mux_t *p_mux, if( p_sys->i_pk_used + 17 >= p_sys->i_packet_size ) { - /* not enough data for another payload, flush the packet */ - int i_pad = p_sys->i_packet_size - p_sys->i_pk_used; - - bo_init( &bo, p_sys->pk->p_buffer, 14 + i_preheader ); - - if( p_sys->b_asf_http ) - { - asf_chunk_add( &bo, 0x4424, - p_sys->i_packet_size, 0x00, p_sys->i_seq++); - } - bo_add_u8 ( &bo, 0x82 ); - bo_addle_u16( &bo, 0 ); - bo_add_u8( &bo, 0x11 ); - bo_add_u8( &bo, 0x5d ); - bo_addle_u16( &bo, i_pad ); - bo_addle_u32( &bo, ( p_sys->i_pk_dts - p_sys->i_dts_first )/ 1000 ); - bo_addle_u16( &bo, 0 * data->i_length / 1000 ); - bo_add_u8( &bo, 0x80 | p_sys->i_pk_frame ); - - /* append the packet */ - *last = p_sys->pk; - last = &p_sys->pk->p_next; - - p_sys->pk = NULL; - - p_sys->i_packet_count++; + /* Not enough data for another payload, flush the packet */ + *last = asf_packet_flush( p_mux ); + last = &(*last)->p_next; } } tk->i_sequence++; - sout_BufferDelete( p_mux->p_sout, data ); + block_Release( data ); return first; } -static sout_buffer_t *asf_stream_end_create( sout_mux_t *p_mux ) +static block_t *asf_stream_end_create( sout_mux_t *p_mux ) { sout_mux_sys_t *p_sys = p_mux->p_sys; - sout_buffer_t *out = NULL; - bo_t bo; + block_t *out = NULL; + bo_t bo; if( p_sys->b_asf_http ) { - out = sout_BufferNew( p_mux->p_sout, 12 ); + out = block_New( p_mux, 12 ); bo_init( &bo, out->p_buffer, 12 ); asf_chunk_add( &bo, 0x4524, 0, 0x00, p_sys->i_seq++ ); } + else + { + /* Create index */ + out = block_New( p_mux, 56 ); + bo_init( &bo, out->p_buffer, 56 ); + bo_add_guid ( &bo, &asf_object_index_guid ); + bo_addle_u64( &bo, 56 ); + bo_add_guid ( &bo, &p_sys->fid ); + bo_addle_u64( &bo, 10000000 ); + bo_addle_u32( &bo, 5 ); + bo_addle_u32( &bo, 0 ); + } + return out; }