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

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

midi

开发平台：

Unix_Linux

asf.c：源码内容
  1. /*****************************************************************************
  2.  * asf.c: asf muxer module for vlc
  3.  *****************************************************************************
  4.  * Copyright (C) 2003-2004, 2006 the VideoLAN team
  5.  * $Id: 5c9c4bffc22e9a4685594d486b9d1af3258754ff $
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  8.  *          Gildas Bazin <gbazin@videolan.org>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23.  *****************************************************************************/
  25. /*****************************************************************************
  26.  * Preamble
  27.  *****************************************************************************/
  29. #ifdef HAVE_CONFIG_H
  30. # include "config.h"
  31. #endif
  33. #include <vlc_common.h>
  34. #include <vlc_plugin.h>
  35. #include <vlc_sout.h>
  36. #include <vlc_block.h>
  37. #include <vlc_codecs.h>
  39. typedef GUID guid_t;
  41. #define MAX_ASF_TRACKS 128
  42. #define ASF_DATA_PACKET_SIZE 4096  // deprecated -- added sout-asf-packet-size
  44. /*****************************************************************************
  45.  * Module descriptor
  46.  *****************************************************************************/
  47. static int  Open   ( vlc_object_t * );
  48. static void Close  ( vlc_object_t * );
  50. #define SOUT_CFG_PREFIX "sout-asf-"
  52. #define TITLE_TEXT N_("Title")
  53. #define TITLE_LONGTEXT N_("Title to put in ASF comments." )
  54. #define AUTHOR_TEXT N_("Author")
  55. #define AUTHOR_LONGTEXT N_("Author to put in ASF comments." )
  56. #define COPYRIGHT_TEXT N_("Copyright")
  57. #define COPYRIGHT_LONGTEXT N_("Copyright string to put in ASF comments." )
  58. #define COMMENT_TEXT N_("Comment")
  59. #define COMMENT_LONGTEXT N_("Comment to put in ASF comments." )
  60. #define RATING_TEXT N_("Rating")
  61. #define RATING_LONGTEXT N_(""Rating" to put in ASF comments." )
  62. #define PACKETSIZE_TEXT N_("Packet Size")
  63. #define PACKETSIZE_LONGTEXT N_("ASF packet size -- default is 4096 bytes")
  64. #define BITRATE_TEXT N_("Bitrate override")
  65. #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")
  68. vlc_module_begin ()
  69.     set_description( N_("ASF muxer") )
  70.     set_category( CAT_SOUT )
  71.     set_subcategory( SUBCAT_SOUT_MUX )
  72.     set_shortname( "ASF" )
  74.     set_capability( "sout mux", 5 )
  75.     add_shortcut( "asf" )
  76.     add_shortcut( "asfh" )
  77.     set_callbacks( Open, Close )
  79.     add_string( SOUT_CFG_PREFIX "title", "", NULL, TITLE_TEXT, TITLE_LONGTEXT,
  80.                                  true )
  81.     add_string( SOUT_CFG_PREFIX "author",   "", NULL, AUTHOR_TEXT,
  82.                                  AUTHOR_LONGTEXT, true )
  83.     add_string( SOUT_CFG_PREFIX "copyright","", NULL, COPYRIGHT_TEXT,
  84.                                  COPYRIGHT_LONGTEXT, true )
  85.     add_string( SOUT_CFG_PREFIX "comment",  "", NULL, COMMENT_TEXT,
  86.                                  COMMENT_LONGTEXT, true )
  87.     add_string( SOUT_CFG_PREFIX "rating",  "", NULL, RATING_TEXT,
  88.                                  RATING_LONGTEXT, true )
  89.     add_integer( SOUT_CFG_PREFIX "packet-size", 4096, NULL, PACKETSIZE_TEXT,
  90.                                  PACKETSIZE_LONGTEXT, true )
  91.     add_integer( SOUT_CFG_PREFIX "bitrate-override", 0, NULL, BITRATE_TEXT,
  92.                                  BITRATE_LONGTEXT, true )
  94. vlc_module_end ()
  96. /*****************************************************************************
  97.  * Locales prototypes
  98.  *****************************************************************************/
  99. static const char *const ppsz_sout_options[] = {
  100.     "title", "author", "copyright", "comment", "rating", NULL
  101. };
  103. static int Control  ( sout_mux_t *, int, va_list );
  104. static int AddStream( sout_mux_t *, sout_input_t * );
  105. static int DelStream( sout_mux_t *, sout_input_t * );
  106. static int Mux      ( sout_mux_t * );
  108. typedef struct
  109. {
  110.     int          i_id;
  111.     int          i_cat;
  113.     /* codec information */
  114.     uint16_t     i_tag;     /* for audio */
  115.     vlc_fourcc_t i_fourcc;  /* for video */
  116.     const char         *psz_name; /* codec name */
  117.     int          i_blockalign; /* for audio only */
  118.     bool   b_audio_correction;
  120.     int          i_sequence;
  122.     int          i_extra;
  123.     uint8_t      *p_extra;
  124.     bool         b_extended;
  126.     es_format_t  fmt;
  128. } asf_track_t;
  130. struct sout_mux_sys_t
  131. {
  132.     guid_t          fid;    /* file id */
  133.     int             i_packet_size;
  134.     int64_t         i_packet_count;
  135.     mtime_t         i_dts_first;
  136.     mtime_t         i_dts_last;
  137.     mtime_t         i_preroll_time;
  138.     int64_t         i_bitrate;
  139.     int64_t         i_bitrate_override;
  141.     int             i_track;
  142.     asf_track_t     track[MAX_ASF_TRACKS];
  144.     bool      b_write_header;
  146.     block_t         *pk;
  147.     int             i_pk_used;
  148.     int             i_pk_frame;
  149.     mtime_t         i_pk_dts;
  151.     bool      b_asf_http;
  152.     int             i_seq;
  154.     /* meta data */
  155.     char            *psz_title;
  156.     char            *psz_author;
  157.     char            *psz_copyright;
  158.     char            *psz_comment;
  159.     char            *psz_rating;
  160. };
  162. static int MuxGetStream( sout_mux_t *, int *pi_stream, mtime_t *pi_dts );
  164. static block_t *asf_header_create( sout_mux_t *, bool );
  165. static block_t *asf_packet_create( sout_mux_t *, asf_track_t *, block_t * );
  166. static block_t *asf_stream_end_create( sout_mux_t *);
  167. static block_t *asf_packet_flush( sout_mux_t * );
  169. typedef struct
  170. {
  171.     int      i_buffer_size;
  172.     int      i_buffer;
  173.     uint8_t  *p_buffer;
  175. } bo_t;
  177. static void bo_init     ( bo_t *, uint8_t *, int  );
  178. static void bo_add_u8   ( bo_t *, uint8_t  );
  179. static void bo_addle_u16( bo_t *, uint16_t );
  180. static void bo_addle_u32( bo_t *, uint32_t );
  181. static void bo_addle_u64( bo_t *, uint64_t );
  182. static void bo_add_mem  ( bo_t *, uint8_t *, int );
  184. static void bo_addle_str16( bo_t *, const char * );
  186. /*****************************************************************************
  187.  * Open:
  188.  *****************************************************************************/
  189. static int Open( vlc_object_t *p_this )
  190. {
  191.     sout_mux_t     *p_mux = (sout_mux_t*)p_this;
  192.     sout_mux_sys_t *p_sys;
  193.     vlc_value_t    val;
  194.     int i;
  196.     msg_Dbg( p_mux, "asf muxer opened" );
  197.     config_ChainParse( p_mux, SOUT_CFG_PREFIX, ppsz_sout_options, p_mux->p_cfg );
  199.     p_mux->pf_control   = Control;
  200.     p_mux->pf_addstream = AddStream;
  201.     p_mux->pf_delstream = DelStream;
  202.     p_mux->pf_mux       = Mux;
  204.     p_mux->p_sys = p_sys = malloc( sizeof( sout_mux_sys_t ) );
  205.     if( !p_sys )
  206.         return VLC_ENOMEM;
  207.     p_sys->b_asf_http = p_mux->psz_mux && !strcmp( p_mux->psz_mux, "asfh" );
  208.     if( p_sys->b_asf_http )
  209.     {
  210.         msg_Dbg( p_mux, "creating asf stream to be used with mmsh" );
  211.     }
  212.     p_sys->pk = NULL;
  213.     p_sys->i_pk_used    = 0;
  214.     p_sys->i_pk_frame   = 0;
  215.     p_sys->i_dts_first  = -1;
  216.     p_sys->i_dts_last   = 0;
  217.     p_sys->i_preroll_time = 2000;
  218.     p_sys->i_bitrate    = 0;
  219.     p_sys->i_bitrate_override = 0;
  220.     p_sys->i_seq        = 0;
  222.     p_sys->b_write_header = true;
  223.     p_sys->i_track = 0;
  224.     p_sys->i_packet_size = config_GetInt( p_mux, "sout-asf-packet-size" );
  225.     p_sys->i_bitrate_override = config_GetInt( p_mux, "sout-asf-bitrate-override" );
  226.     msg_Dbg( p_mux, "Packet size %d", p_sys->i_packet_size);
  227.     if (p_sys->i_bitrate_override)
  228.         msg_Dbg( p_mux, "Bitrate override %"PRId64, p_sys->i_bitrate_override);
  229.     p_sys->i_packet_count= 0;
  231.     /* Generate a random fid */
  232.     srand( mdate() & 0xffffffff );
  233.     p_sys->fid.Data1 = 0xbabac001;
  234.     p_sys->fid.Data2 = ( (uint64_t)rand() << 16 ) / RAND_MAX;
  235.     p_sys->fid.Data3 = ( (uint64_t)rand() << 16 ) / RAND_MAX;
  236.     for( i = 0; i < 8; i++ )
  237.     {
  238.         p_sys->fid.Data4[i] = ( (uint64_t)rand() << 8 ) / RAND_MAX;
  239.     }
  241.     /* Meta data */
  242.     var_Get( p_mux, SOUT_CFG_PREFIX "title", &val );
  243.     p_sys->psz_title = val.psz_string;
  245.     var_Get( p_mux, SOUT_CFG_PREFIX "author", &val );
  246.     p_sys->psz_author = val.psz_string;
  248.     var_Get( p_mux, SOUT_CFG_PREFIX "copyright", &val );
  249.     p_sys->psz_copyright = val.psz_string;
  251.     var_Get( p_mux, SOUT_CFG_PREFIX "comment", &val );
  252.     p_sys->psz_comment = val.psz_string;
  254.     var_Get( p_mux, SOUT_CFG_PREFIX "rating", &val );
  255.     p_sys->psz_rating = val.psz_string;
  257.     msg_Dbg( p_mux, "meta data: title='%s', author='%s', copyright='%s', "
  258.              "comment='%s', rating='%s'",
  259.              p_sys->psz_title, p_sys->psz_author, p_sys->psz_copyright,
  260.              p_sys->psz_comment, p_sys->psz_rating );
  262.     return VLC_SUCCESS;
  263. }
  265. /*****************************************************************************
  266.  * Close:
  267.  *****************************************************************************/
  268. static void Close( vlc_object_t * p_this )
  269. {
  270.     sout_mux_t     *p_mux = (sout_mux_t*)p_this;
  271.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  272.     block_t  *out;
  273.     int i;
  275.     msg_Dbg( p_mux, "Asf muxer closed" );
  277.     /* Flush last packet if any */
  278.     if( (out = asf_packet_flush( p_mux ) ) )
  279.     {
  280.         sout_AccessOutWrite( p_mux->p_access, out );
  281.     }
  283.     if( ( out = asf_stream_end_create( p_mux ) ) )
  284.     {
  285.         sout_AccessOutWrite( p_mux->p_access, out );
  286.     }
  288.     /* rewrite header */
  289.     if( sout_AccessOutSeek( p_mux->p_access, 0 ) == VLC_SUCCESS )
  290.     {
  291.         out = asf_header_create( p_mux, false );
  292.         sout_AccessOutWrite( p_mux->p_access, out );
  293.     }
  295.     for( i = 0; i < p_sys->i_track; i++ )
  296.     {
  297.         free( p_sys->track[i].p_extra );
  298.         es_format_Clean( &p_sys->track[i].fmt );
  299.     }
  301.     free( p_sys->psz_title );
  302.     free( p_sys->psz_author );
  303.     free( p_sys->psz_copyright );
  304.     free( p_sys->psz_comment );
  305.     free( p_sys->psz_rating );
  306.     free( p_sys );
  307. }
  309. /*****************************************************************************
  310.  * Capability:
  311.  *****************************************************************************/
  312. static int Control( sout_mux_t *p_mux, int i_query, va_list args )
  313. {
  314.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  315.     bool *pb_bool;
  316.     char **ppsz;
  318.     switch( i_query )
  319.     {
  320.        case MUX_CAN_ADD_STREAM_WHILE_MUXING:
  321.            pb_bool = (bool*)va_arg( args, bool * );
  322.            if( p_sys->b_asf_http ) *pb_bool = true;
  323.            else *pb_bool = false;
  324.            return VLC_SUCCESS;
  326.        case MUX_GET_ADD_STREAM_WAIT:
  327.            pb_bool = (bool*)va_arg( args, bool * );
  328.            *pb_bool = true;
  329.            return VLC_SUCCESS;
  331.        case MUX_GET_MIME:
  332.            ppsz = (char**)va_arg( args, char ** );
  333.            if( p_sys->b_asf_http )
  334.                *ppsz = strdup( "video/x-ms-asf-stream" );
  335.            else
  336.                *ppsz = strdup( "video/x-ms-asf" );
  337.            return VLC_SUCCESS;
  339.         default:
  340.             return VLC_EGENERIC;
  341.     }
  342. }
  344. /*****************************************************************************
  345.  * AddStream:
  346.  *****************************************************************************/
  347. static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input )
  348. {
  349.     sout_mux_sys_t   *p_sys = p_mux->p_sys;
  350.     asf_track_t      *tk;
  351.     bo_t             bo;
  353.     msg_Dbg( p_mux, "adding input" );
  354.     if( p_sys->i_track >= MAX_ASF_TRACKS )
  355.     {
  356.         msg_Dbg( p_mux, "cannot add this track (too much tracks)" );
  357.         return VLC_EGENERIC;
  358.     }
  360.     tk = p_input->p_sys = &p_sys->track[p_sys->i_track];
  361.     tk->i_id  = p_sys->i_track + 1;
  362.     tk->i_cat = p_input->p_fmt->i_cat;
  363.     tk->i_sequence = 0;
  364.     tk->b_audio_correction = 0;
  365.     tk->b_extended = false;
  367.     switch( tk->i_cat )
  368.     {
  369.         case AUDIO_ES:
  370.         {
  371.             int i_blockalign = p_input->p_fmt->audio.i_blockalign;
  372.             int i_bitspersample = p_input->p_fmt->audio.i_bitspersample;
  373.             int i_extra = 0;
  375.             switch( p_input->p_fmt->i_codec )
  376.             {
  377.                 case VLC_FOURCC( 'a', '5', '2', ' ' ):
  378.                     tk->i_tag = WAVE_FORMAT_A52;
  379.                     tk->psz_name = "A/52";
  380.                     i_bitspersample = 0;
  381.                     break;
  382.                 case VLC_FOURCC( 'm', 'p', '4', 'a' ):
  383.                     tk->i_tag = WAVE_FORMAT_AAC;
  384.                     tk->psz_name = "MPEG-4 Audio";
  385.                     i_bitspersample = 0;
  386.                     break;
  387.                 case VLC_FOURCC( 'm', 'p', 'g', 'a' ):
  388.                 case VLC_FOURCC( 'm', 'p', '3', ' ' ):
  389. #if 1
  390.                     tk->psz_name = "MPEG Audio Layer 3";
  391.                     tk->i_tag = WAVE_FORMAT_MPEGLAYER3;
  392.                     i_bitspersample = 0;
  393.                     i_blockalign = 1;
  394.                     i_extra = 12;
  395.                     break;
  396. #else
  397.                     tk->psz_name = "MPEG Audio Layer 1/2";
  398.                     tk->i_tag = WAVE_FORMAT_MPEG;
  399.                     i_bitspersample = 0;
  400.                     i_blockalign = 1;
  401.                     i_extra = 22;
  402.                     break;
  403. #endif
  404.                 case VLC_FOURCC( 'w', 'm', 'a', '1' ):
  405.                     tk->psz_name = "Windows Media Audio v1";
  406.                     tk->i_tag = WAVE_FORMAT_WMA1;
  407.                     tk->b_audio_correction = true;
  408.                     break;
  409.                 case VLC_FOURCC( 'w', 'm', 'a', ' ' ):
  410.                 case VLC_FOURCC( 'w', 'm', 'a', '2' ):
  411.                     tk->psz_name= "Windows Media Audio (v2) 7, 8 and 9 Series";
  412.                     tk->i_tag = WAVE_FORMAT_WMA2;
  413.                     tk->b_audio_correction = true;
  414.                     break;
  415.                 case VLC_FOURCC( 'w', 'm', 'a', 'p' ):
  416.                     tk->psz_name = "Windows Media Audio 9 Professional";
  417.                     tk->i_tag = WAVE_FORMAT_WMAP;
  418.                     tk->b_audio_correction = true;
  419.                     break;
  420.                 case VLC_FOURCC( 'w', 'm', 'a', 'l' ):
  421.                     tk->psz_name = "Windows Media Audio 9 Lossless";
  422.                     tk->i_tag = WAVE_FORMAT_WMAL;
  423.                     tk->b_audio_correction = true;
  424.                     break;
  425.                     /* raw codec */
  426.                 case VLC_FOURCC( 'u', '8', ' ', ' ' ):
  427.                     tk->psz_name = "Raw audio 8bits";
  428.                     tk->i_tag = WAVE_FORMAT_PCM;
  429.                     i_blockalign= p_input->p_fmt->audio.i_channels;
  430.                     i_bitspersample = 8;
  431.                     break;
  432.                 case VLC_FOURCC( 's', '1', '6', 'l' ):
  433.                     tk->psz_name = "Raw audio 16bits";
  434.                     tk->i_tag = WAVE_FORMAT_PCM;
  435.                     i_blockalign= 2 * p_input->p_fmt->audio.i_channels;
  436.                     i_bitspersample = 16;
  437.                     break;
  438.                 case VLC_FOURCC( 's', '2', '4', 'l' ):
  439.                     tk->psz_name = "Raw audio 24bits";
  440.                     tk->i_tag = WAVE_FORMAT_PCM;
  441.                     i_blockalign= 3 * p_input->p_fmt->audio.i_channels;
  442.                     i_bitspersample = 24;
  443.                     break;
  444.                 case VLC_FOURCC( 's', '3', '2', 'l' ):
  445.                     tk->psz_name = "Raw audio 32bits";
  446.                     tk->i_tag = WAVE_FORMAT_PCM;
  447.                     i_blockalign= 4 * p_input->p_fmt->audio.i_channels;
  448.                     i_bitspersample = 32;
  449.                     break;
  450.                 default:
  451.                     return VLC_EGENERIC;
  452.             }
  454.             tk->i_extra = sizeof( WAVEFORMATEX ) +
  455.                           p_input->p_fmt->i_extra + i_extra;
  456.             tk->p_extra = malloc( tk->i_extra );
  457.             if( !tk->p_extra )
  458.                 return VLC_ENOMEM;
  459.             bo_init( &bo, tk->p_extra, tk->i_extra );
  460.             bo_addle_u16( &bo, tk->i_tag );
  461.             bo_addle_u16( &bo, p_input->p_fmt->audio.i_channels );
  462.             bo_addle_u32( &bo, p_input->p_fmt->audio.i_rate );
  463.             bo_addle_u32( &bo, p_input->p_fmt->i_bitrate / 8 );
  464.             bo_addle_u16( &bo, i_blockalign );
  465.             tk->i_blockalign = i_blockalign;
  466.             bo_addle_u16( &bo, i_bitspersample );
  467.             if( p_input->p_fmt->i_extra > 0 )
  468.             {
  469.                 bo_addle_u16( &bo, p_input->p_fmt->i_extra );
  470.                 bo_add_mem  ( &bo, p_input->p_fmt->p_extra,
  471.                               p_input->p_fmt->i_extra );
  472.             }
  473.             else
  474.             {
  475.                 bo_addle_u16( &bo, i_extra );
  476.                 if( tk->i_tag == WAVE_FORMAT_MPEGLAYER3 )
  477.                 {
  478.                     msg_Dbg( p_mux, "adding mp3 header" );
  479.                     bo_addle_u16( &bo, 1 );     /* wId */
  480.                     bo_addle_u32( &bo, 2 );     /* fdwFlags */
  481.                     bo_addle_u16( &bo, 1152 );  /* nBlockSize */
  482.                     bo_addle_u16( &bo, 1 );     /* nFramesPerBlock */
  483.                     bo_addle_u16( &bo, 1393 );  /* nCodecDelay */
  484.                 }
  485.                 else if( tk->i_tag == WAVE_FORMAT_MPEG )
  486.                 {
  487.                     msg_Dbg( p_mux, "adding mp2 header" );
  488.                     bo_addle_u16( &bo, 2 );     /* fwHeadLayer */
  489.                     bo_addle_u32( &bo, p_input->p_fmt->i_bitrate );
  490.                     bo_addle_u16( &bo, p_input->p_fmt->audio.i_channels == 2 ?1:8 );
  491.                     bo_addle_u16( &bo, 0 );     /* fwHeadModeExt */
  492.                     bo_addle_u16( &bo, 1 );     /* wHeadEmphasis */
  493.                     bo_addle_u16( &bo, 16 );    /* fwHeadFlags */
  494.                     bo_addle_u32( &bo, 0 );     /* dwPTSLow */
  495.                     bo_addle_u32( &bo, 0 );     /* dwPTSHigh */
  496.                 }
  497.             }
  499.             if( p_input->p_fmt->i_bitrate > 24000 )
  500.             {
  501.                 p_sys->i_bitrate += p_input->p_fmt->i_bitrate;
  502.             }
  503.             else
  504.             {
  505.                 p_sys->i_bitrate += 128000;
  506.             }
  507.             if (p_sys->i_bitrate_override)
  508.                 p_sys->i_bitrate = p_sys->i_bitrate_override;
  509.             break;
  510.         }
  511.         case VIDEO_ES:
  512.         {
  513.             const es_format_t *p_fmt = p_input->p_fmt;
  514.             uint8_t *p_codec_extra = NULL;
  515.             int     i_codec_extra = 0;
  517.             if( p_input->p_fmt->i_codec == VLC_FOURCC('m','p','4','v') )
  518.             {
  519.                 tk->psz_name = "MPEG-4 Video";
  520.                 tk->i_fourcc = VLC_FOURCC( 'M', 'P', '4', 'S' );
  521.             }
  522.             else if( p_input->p_fmt->i_codec == VLC_FOURCC('D','I','V','3') )
  523.             {
  524.                 tk->psz_name = "MSMPEG-4 V3 Video";
  525.                 tk->i_fourcc = VLC_FOURCC( 'M', 'P', '4', '3' );
  526.             }
  527.             else if( p_input->p_fmt->i_codec == VLC_FOURCC('D','I','V','2') )
  528.             {
  529.                 tk->psz_name = "MSMPEG-4 V2 Video";
  530.                 tk->i_fourcc = VLC_FOURCC( 'M', 'P', '4', '2' );
  531.             }
  532.             else if( p_input->p_fmt->i_codec == VLC_FOURCC('D','I','V','1') )
  533.             {
  534.                 tk->psz_name = "MSMPEG-4 V1 Video";
  535.                 tk->i_fourcc = VLC_FOURCC( 'M', 'P', 'G', '4' );
  536.             }
  537.             else if( p_input->p_fmt->i_codec == VLC_FOURCC('W','M','V','1') )
  538.             {
  539.                 tk->psz_name = "Windows Media Video 7";
  540.                 tk->i_fourcc = VLC_FOURCC( 'W', 'M', 'V', '1' );
  541.             }
  542.             else if( p_input->p_fmt->i_codec == VLC_FOURCC('W','M','V','2') )
  543.             {
  544.                 tk->psz_name = "Windows Media Video 8";
  545.                 tk->i_fourcc = VLC_FOURCC( 'W', 'M', 'V', '2' );
  546.             }
  547.             else if( p_input->p_fmt->i_codec == VLC_FOURCC('W','M','V','3') )
  548.             {
  549.                 tk->psz_name = "Windows Media Video 9";
  550.                 tk->i_fourcc = VLC_FOURCC( 'W', 'M', 'V', '3' );
  551.             }
  552.             else if( p_input->p_fmt->i_codec == VLC_FOURCC('W','V','C','1') )
  553.             {
  554.                 tk->psz_name = "Windows Media Video 9 Advanced Profile";
  555.                 tk->i_fourcc = VLC_FOURCC( 'W', 'V', 'C', '1' );
  556.                 tk->b_extended = true;
  558.                 if( p_fmt->i_extra > 0 )
  559.                 {
  560.                     p_codec_extra = malloc( 1 + p_fmt->i_extra );
  561.                     if( p_codec_extra )
  562.                     {
  563.                         i_codec_extra = 1 + p_fmt->i_extra;
  564.                         p_codec_extra[0] = 0x01;
  565.                         memcpy( &p_codec_extra[1], p_fmt->p_extra, p_fmt->i_extra );
  566.                     }
  567.                 }
  568.             }
  569.             else if( p_input->p_fmt->i_codec == VLC_FOURCC('h','2','6','4') )
  570.             {
  571.                 tk->psz_name = "H.264/MPEG-4 AVC";
  572.                 tk->i_fourcc = VLC_FOURCC('h','2','6','4');
  573.             }
  574.             else
  575.             {
  576.                 tk->psz_name = _("Unknown Video");
  577.                 tk->i_fourcc = p_input->p_fmt->i_codec;
  578.             }
  579.             if( !i_codec_extra && p_fmt->i_extra > 0 )
  580.             {
  581.                 p_codec_extra = malloc( p_fmt->i_extra );
  582.                 if( p_codec_extra )
  583.                 {
  584.                     i_codec_extra = p_fmt->i_extra;
  585.                     memcpy( p_codec_extra, p_fmt->p_extra, p_fmt->i_extra );
  586.                 }
  587.             }
  589.             tk->i_extra = 11 + sizeof( BITMAPINFOHEADER ) + i_codec_extra;
  590.             tk->p_extra = malloc( tk->i_extra );
  591.             if( !tk->p_extra )
  592.             {
  593.                 free( p_codec_extra );
  594.                 return VLC_ENOMEM;
  595.             }
  596.             bo_init( &bo, tk->p_extra, tk->i_extra );
  597.             bo_addle_u32( &bo, p_input->p_fmt->video.i_width );
  598.             bo_addle_u32( &bo, p_input->p_fmt->video.i_height );
  599.             bo_add_u8   ( &bo, 0x02 );  /* flags */
  600.             bo_addle_u16( &bo, sizeof( BITMAPINFOHEADER ) + i_codec_extra );
  601.             bo_addle_u32( &bo, sizeof( BITMAPINFOHEADER ) + i_codec_extra );
  602.             bo_addle_u32( &bo, p_input->p_fmt->video.i_width );
  603.             bo_addle_u32( &bo, p_input->p_fmt->video.i_height );
  604.             bo_addle_u16( &bo, 1 );
  605.             bo_addle_u16( &bo, 24 );
  606.             bo_add_mem( &bo, (uint8_t*)&tk->i_fourcc, 4 );
  607.             bo_addle_u32( &bo, 0 );
  608.             bo_addle_u32( &bo, 0 );
  609.             bo_addle_u32( &bo, 0 );
  610.             bo_addle_u32( &bo, 0 );
  611.             bo_addle_u32( &bo, 0 );
  612.             if( i_codec_extra > 0 )
  613.             {
  614.                 bo_add_mem( &bo, p_codec_extra, i_codec_extra );
  615.                 free( p_codec_extra );
  616.             }
  618.             if( p_input->p_fmt->i_bitrate > 50000 )
  619.             {
  620.                 p_sys->i_bitrate += p_input->p_fmt->i_bitrate;
  621.             }
  622.             else
  623.             {
  624.                 p_sys->i_bitrate += 512000;
  625.             }
  626.             if( p_sys->i_bitrate_override )
  627.                 p_sys->i_bitrate = p_sys->i_bitrate_override;
  628.             break;
  629.         }
  630.         default:
  631.             msg_Err(p_mux, "unhandled track type" );
  632.             return VLC_EGENERIC;
  633.     }
  635.     es_format_Copy( &tk->fmt, p_input->p_fmt );
  637.     p_sys->i_track++;
  638.     return VLC_SUCCESS;
  639. }
  641. /*****************************************************************************
  642.  * DelStream:
  643.  *****************************************************************************/
  644. static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input )
  645. {
  646.     /* if bitrate ain't defined in commanline, reduce it when tracks are deleted
  647.      */
  648.     sout_mux_sys_t   *p_sys = p_mux->p_sys;
  649.     asf_track_t      *tk = p_input->p_sys;
  650.     if(!p_sys->i_bitrate_override)
  651.     {
  652.         if( tk->i_cat == AUDIO_ES )
  653.         {
  654.              if( p_input->p_fmt->i_bitrate > 24000 )
  655.                  p_sys->i_bitrate -= p_input->p_fmt->i_bitrate;
  656.              else
  657.                  p_sys->i_bitrate -= 128000;
  658.         }
  659.         else if(tk->i_cat == VIDEO_ES )
  660.         {
  661.              if( p_input->p_fmt->i_bitrate > 50000 )
  662.                  p_sys->i_bitrate -= p_input->p_fmt->i_bitrate;
  663.              else
  664.                  p_sys->i_bitrate -= 512000;
  665.         }
  666.     }
  667.     msg_Dbg( p_mux, "removing input" );
  668.     return VLC_SUCCESS;
  669. }
  671. /*****************************************************************************
  672.  * Mux:
  673.  *****************************************************************************/
  674. static int Mux( sout_mux_t *p_mux )
  675. {
  676.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  678.     if( p_sys->b_write_header )
  679.     {
  680.         block_t *out = asf_header_create( p_mux, true );
  682.         out->i_flags |= BLOCK_FLAG_HEADER;
  683.         sout_AccessOutWrite( p_mux->p_access, out );
  685.         p_sys->b_write_header = false;
  686.     }
  688.     for( ;; )
  689.     {
  690.         sout_input_t  *p_input;
  691.         asf_track_t   *tk;
  692.         int           i_stream;
  693.         mtime_t       i_dts;
  694.         block_t *data;
  695.         block_t *pk;
  697.         if( MuxGetStream( p_mux, &i_stream, &i_dts ) )
  698.         {
  699.             /* not enough data */
  700.             return VLC_SUCCESS;
  701.         }
  703.         if( p_sys->i_dts_first < 0 )
  704.         {
  705.             p_sys->i_dts_first = i_dts;
  706.         }
  707.         if( p_sys->i_dts_last < i_dts )
  708.         {
  709.             p_sys->i_dts_last = i_dts;
  710.         }
  712.         p_input = p_mux->pp_inputs[i_stream];
  713.         tk      = (asf_track_t*)p_input->p_sys;
  715.         data = block_FifoGet( p_input->p_fifo );
  717.         /* Convert VC1 to ASF special format */
  718.         if( tk->i_fourcc == VLC_FOURCC( 'W', 'V', 'C', '1' ) )
  719.         {
  720.             while( data->i_buffer >= 4 &&
  721.                    ( data->p_buffer[0] != 0x00 || data->p_buffer[1] != 0x00 ||
  722.                      data->p_buffer[2] != 0x01 ||
  723.                      ( data->p_buffer[3] != 0x0D && data->p_buffer[3] != 0x0C ) ) )
  724.             {
  725.                 data->i_buffer--;
  726.                 data->p_buffer++;
  727.             }
  728.             if( data->i_buffer >= 4 )
  729.             {
  730.                 data->i_buffer -= 4;
  731.                 data->p_buffer += 4;
  732.             }
  733.         }
  735.         if( ( pk = asf_packet_create( p_mux, tk, data ) ) )
  736.         {
  737.             sout_AccessOutWrite( p_mux->p_access, pk );
  738.         }
  739.     }
  741.     return VLC_SUCCESS;
  742. }
  744. static int MuxGetStream( sout_mux_t *p_mux, int *pi_stream, mtime_t *pi_dts )
  745. {
  746.     mtime_t i_dts;
  747.     int     i_stream;
  748.     int     i;
  750.     for( i = 0, i_dts = 0, i_stream = -1; i < p_mux->i_nb_inputs; i++ )
  751.     {
  752.         sout_input_t  *p_input = p_mux->pp_inputs[i];
  753.         block_t *p_data;
  755.         if( block_FifoCount( p_input->p_fifo ) <= 0 )
  756.         {
  757.             if( p_input->p_fmt->i_cat == AUDIO_ES ||
  758.                 p_input->p_fmt->i_cat == VIDEO_ES )
  759.             {
  760.                 /* We need that audio+video fifo contain at least 1 packet */
  761.                 return VLC_EGENERIC;
  762.             }
  763.             /* SPU */
  764.             continue;
  765.         }
  767.         p_data = block_FifoShow( p_input->p_fifo );
  768.         if( i_stream == -1 || p_data->i_dts < i_dts )
  769.         {
  770.             i_stream = i;
  771.             i_dts    = p_data->i_dts;
  772.         }
  773.     }
  775.     *pi_stream = i_stream;
  776.     *pi_dts = i_dts;
  778.     return VLC_SUCCESS;
  779. }
  781. /****************************************************************************
  782.  * Asf header construction
  783.  ****************************************************************************/
  785. /****************************************************************************
  786.  * Buffer out
  787.  ****************************************************************************/
  788. static void bo_init( bo_t *p_bo, uint8_t *p_buffer, int i_size )
  789. {
  790.     p_bo->i_buffer_size = i_size;
  791.     p_bo->i_buffer = 0;
  792.     p_bo->p_buffer = p_buffer;
  793. }
  794. static void bo_add_u8( bo_t *p_bo, uint8_t i )
  795. {
  796.     if( p_bo->i_buffer < p_bo->i_buffer_size )
  797.     {
  798.         p_bo->p_buffer[p_bo->i_buffer] = i;
  799.     }
  800.     p_bo->i_buffer++;
  801. }
  802. static void bo_addle_u16( bo_t *p_bo, uint16_t i )
  803. {
  804.     bo_add_u8( p_bo, i &0xff );
  805.     bo_add_u8( p_bo, ( ( i >> 8) &0xff ) );
  806. }
  807. static void bo_addle_u32( bo_t *p_bo, uint32_t i )
  808. {
  809.     bo_addle_u16( p_bo, i &0xffff );
  810.     bo_addle_u16( p_bo, ( ( i >> 16) &0xffff ) );
  811. }
  812. static void bo_addle_u64( bo_t *p_bo, uint64_t i )
  813. {
  814.     bo_addle_u32( p_bo, i &0xffffffff );
  815.     bo_addle_u32( p_bo, ( ( i >> 32) &0xffffffff ) );
  816. }
  818. static void bo_add_mem( bo_t *p_bo, uint8_t *p_mem, int i_size )
  819. {
  820.     int i_copy = __MIN( i_size, p_bo->i_buffer_size - p_bo->i_buffer );
  822.     if( i_copy > 0 )
  823.     {
  824.         memcpy( &p_bo->p_buffer[p_bo->i_buffer], p_mem, i_copy );
  825.     }
  826.     p_bo->i_buffer += i_size;
  827. }
  829. static void bo_addle_str16( bo_t *bo, const char *str )
  830. {
  831.     bo_addle_u16( bo, strlen( str ) + 1 );
  832.     for( ;; )
  833.     {
  834.         uint16_t c = (uint8_t)*str++;
  835.         bo_addle_u16( bo, c );
  836.         if( c == '' ) break;
  837.     }
  838. }
  840. static void bo_addle_str16_nosize( bo_t *bo, const char *str )
  841. {
  842.     for( ;; )
  843.     {
  844.         uint16_t c = (uint8_t)*str++;
  845.         bo_addle_u16( bo, c );
  846.         if( c == '' ) break;
  847.     }
  848. }
  850. /****************************************************************************
  851.  * GUID definitions
  852.  ****************************************************************************/
  853. static void bo_add_guid( bo_t *p_bo, const guid_t *id )
  854. {
  855.     int i;
  856.     bo_addle_u32( p_bo, id->Data1 );
  857.     bo_addle_u16( p_bo, id->Data2 );
  858.     bo_addle_u16( p_bo, id->Data3 );
  859.     for( i = 0; i < 8; i++ )
  860.     {
  861.         bo_add_u8( p_bo, id->Data4[i] );
  862.     }
  863. }
  865. static const guid_t asf_object_header_guid =
  866. {0x75B22630, 0x668E, 0x11CF, {0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C}};
  867. static const guid_t asf_object_data_guid =
  868. {0x75B22636, 0x668E, 0x11CF, {0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C}};
  869. static const guid_t asf_object_file_properties_guid =
  870. {0x8cabdca1, 0xa947, 0x11cf, {0x8e, 0xe4, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65}};
  871. static const guid_t asf_object_stream_properties_guid =
  872. {0xB7DC0791, 0xA9B7, 0x11CF, {0x8E, 0xE6, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65}};
  873. static const guid_t asf_object_header_extension_guid =
  874. {0x5FBF03B5, 0xA92E, 0x11CF, {0x8E, 0xE3, 0x00, 0xC0, 0x0C, 0x20, 0x53, 0x65}};
  875. static const guid_t asf_object_stream_type_audio =
  876. {0xF8699E40, 0x5B4D, 0x11CF, {0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B}};
  877. static const guid_t asf_object_stream_type_video =
  878. {0xbc19efc0, 0x5B4D, 0x11CF, {0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B}};
  879. static const guid_t asf_guid_audio_conceal_none =
  880. {0x20FB5700, 0x5B55, 0x11CF, {0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B}};
  881. static const guid_t asf_guid_audio_conceal_spread =
  882. {0xBFC3CD50, 0x618F, 0x11CF, {0x8B, 0xB2, 0x00, 0xAA, 0x00, 0xB4, 0xE2, 0x20}};
  883. static const guid_t asf_guid_video_conceal_none =
  884. {0x20FB5700, 0x5B55, 0x11CF, {0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B}};
  885. static const guid_t asf_guid_reserved_1 =
  886. {0xABD3D211, 0xA9BA, 0x11cf, {0x8E, 0xE6, 0x00, 0xC0, 0x0C ,0x20, 0x53, 0x65}};
  887. static const guid_t asf_object_codec_list_guid =
  888. {0x86D15240, 0x311D, 0x11D0, {0xA3, 0xA4, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6}};
  889. static const guid_t asf_object_codec_list_reserved_guid =
  890. {0x86D15241, 0x311D, 0x11D0, {0xA3, 0xA4, 0x00, 0xA0, 0xC9, 0x03, 0x48, 0xF6}};
  891. static const guid_t asf_object_content_description_guid =
  892. {0x75B22633, 0x668E, 0x11CF, {0xa6, 0xd9, 0x00, 0xaa, 0x00, 0x62, 0xce, 0x6c}};
  893. static const guid_t asf_object_index_guid =
  894. {0x33000890, 0xE5B1, 0x11CF, {0x89, 0xF4, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xCB}};
  895. static const guid_t asf_object_metadata_guid =
  896. {0xC5F8CBEA, 0x5BAF, 0x4877, {0x84, 0x67, 0xAA, 0x8C, 0x44, 0xFA, 0x4C, 0xCA}};
  897. static const guid_t asf_object_extended_stream_properties_guid =
  898. {0x14E6A5CB, 0xC672, 0x4332, {0x83, 0x99, 0xA9, 0x69, 0x52, 0x06, 0x5B, 0x5A}};
  900. /****************************************************************************
  901.  * Misc
  902.  ****************************************************************************/
  903. static void asf_chunk_add( bo_t *bo,
  904.                            int i_type, int i_len, int i_flags, int i_seq )
  905. {
  906.     bo_addle_u16( bo, i_type );
  907.     bo_addle_u16( bo, i_len + 8 );
  908.     bo_addle_u32( bo, i_seq );
  909.     bo_addle_u16( bo, i_flags );
  910.     bo_addle_u16( bo, i_len + 8 );
  911. }
  913. static block_t *asf_header_create( sout_mux_t *p_mux, bool b_broadcast )
  914. {
  915.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  916.     asf_track_t    *tk;
  917.     mtime_t i_duration = 0;
  918.     int i_size, i_header_ext_size, i;
  919.     int i_ci_size, i_cm_size = 0, i_cd_size = 0;
  920.     block_t *out;
  921.     bo_t bo;
  923.     msg_Dbg( p_mux, "Asf muxer creating header" );
  925.     if( p_sys->i_dts_first > 0 )
  926.     {
  927.         i_duration = p_sys->i_dts_last - p_sys->i_dts_first;
  928.         if( i_duration < 0 ) i_duration = 0;
  929.     }
  931.     /* calculate header size */
  932.     i_size = 30 + 104;
  933.     i_ci_size = 44;
  934.     for( i = 0; i < p_sys->i_track; i++ )
  935.     {
  936.         i_size += 78 + p_sys->track[i].i_extra;
  937.         i_ci_size += 8 + 2 * strlen( p_sys->track[i].psz_name );
  938.         if( p_sys->track[i].i_cat == AUDIO_ES ) i_ci_size += 4;
  939.         else if( p_sys->track[i].i_cat == VIDEO_ES ) i_ci_size += 6;
  941.         /* Error correction data field */
  942.         if( p_sys->track[i].b_audio_correction ) i_size += 8;
  943.     }
  945.     /* size of the content description object */
  946.     if( *p_sys->psz_title || *p_sys->psz_author || *p_sys->psz_copyright ||
  947.         *p_sys->psz_comment || *p_sys->psz_rating )
  948.     {
  949.         i_cd_size = 34 + 2 * ( strlen( p_sys->psz_title ) + 1 +
  950.                              strlen( p_sys->psz_author ) + 1 +
  951.                              strlen( p_sys->psz_copyright ) + 1 +
  952.                              strlen( p_sys->psz_comment ) + 1 +
  953.                              strlen( p_sys->psz_rating ) + 1 );
  954.     }
  956.     i_header_ext_size = 46;
  958.     /* size of the metadata object */
  959.     for( i = 0; i < p_sys->i_track; i++ )
  960.     {
  961.         const asf_track_t *p_track = &p_sys->track[i];
  962.         if( p_track->i_cat == VIDEO_ES && p_track->fmt.video.i_aspect != 0 )
  963.         {
  964.             i_cm_size = 26 + 2 * (16 + 2 * sizeof("AspectRatio?"));
  965.             break;
  966.         }
  967.         if( p_track->b_extended )
  968.             i_header_ext_size += 88;
  970.     }
  972.     i_header_ext_size += i_cm_size;
  974.     i_size += i_ci_size + i_cd_size + i_header_ext_size ;
  976.     if( p_sys->b_asf_http )
  977.     {
  978.         out = block_New( p_mux, i_size + 50 + 12 );
  979.         bo_init( &bo, out->p_buffer, i_size + 50 + 12 );
  980.         asf_chunk_add( &bo, 0x4824, i_size + 50, 0xc00, p_sys->i_seq++ );
  981.     }
  982.     else
  983.     {
  984.         out = block_New( p_mux, i_size + 50 );
  985.         bo_init( &bo, out->p_buffer, i_size + 50 );
  986.     }
  988.     /* header object */
  989.     bo_add_guid ( &bo, &asf_object_header_guid );
  990.     bo_addle_u64( &bo, i_size );
  991.     bo_addle_u32( &bo, 2 + p_sys->i_track +
  992.                   (i_cd_size ? 1 : 0) + (i_cm_size ? 1 : 0) );
  993.     bo_add_u8   ( &bo, 1 );
  994.     bo_add_u8   ( &bo, 2 );
  996.     /* sub object */
  998.     /* file properties */
  999.     bo_add_guid ( &bo, &asf_object_file_properties_guid );
  1000.     bo_addle_u64( &bo, 104 );
  1001.     bo_add_guid ( &bo, &p_sys->fid );
  1002.     bo_addle_u64( &bo, i_size + 50 + p_sys->i_packet_count *
  1003.                                 p_sys->i_packet_size ); /* file size */
  1004.     bo_addle_u64( &bo, 0 );                 /* creation date */
  1005.     bo_addle_u64( &bo, b_broadcast ? 0xffffffffLL : p_sys->i_packet_count );
  1006.     bo_addle_u64( &bo, i_duration * 10 );   /* play duration (100ns) */
  1007.     bo_addle_u64( &bo, i_duration * 10 );   /* send duration (100ns) */
  1008.     bo_addle_u64( &bo, p_sys->i_preroll_time ); /* preroll duration (ms) */
  1009.     bo_addle_u32( &bo, b_broadcast ? 0x01 : 0x02 /* seekable */ ); /* flags */
  1010.     bo_addle_u32( &bo, p_sys->i_packet_size );  /* packet size min */
  1011.     bo_addle_u32( &bo, p_sys->i_packet_size );  /* packet size max */
  1012.     bo_addle_u32( &bo, p_sys->i_bitrate );      /* maxbitrate */
  1014.     /* header extension */
  1015.     bo_add_guid ( &bo, &asf_object_header_extension_guid );
  1016.     bo_addle_u64( &bo, i_header_ext_size );
  1017.     bo_add_guid ( &bo, &asf_guid_reserved_1 );
  1018.     bo_addle_u16( &bo, 6 );
  1019.     bo_addle_u32( &bo, i_header_ext_size - 46 );
  1021.     /* extended stream properties */
  1022.     for( i = 0; i < p_sys->i_track; i++ )
  1023.     {
  1024.         const asf_track_t *p_track = &p_sys->track[i];
  1025.         const es_format_t *p_fmt = &p_track->fmt;
  1027.         if( !p_track->b_extended )
  1028.             continue;
  1030.         uint64_t i_avg_duration = 0;
  1031.         if( p_fmt->i_cat == VIDEO_ES &&
  1032.             p_fmt->video.i_frame_rate > 0 && p_fmt->video.i_frame_rate_base > 0 )
  1033.             i_avg_duration = ( INT64_C(10000000) * p_fmt->video.i_frame_rate_base +
  1034.                                p_fmt->video.i_frame_rate/2 ) / p_fmt->video.i_frame_rate;
  1036.         bo_add_guid ( &bo, &asf_object_extended_stream_properties_guid );
  1037.         bo_addle_u64( &bo, 88 );
  1038.         bo_addle_u64( &bo, 0 );
  1039.         bo_addle_u64( &bo, 0 );
  1040.         bo_addle_u32( &bo, p_fmt->i_bitrate );  /* Bitrate */
  1041.         bo_addle_u32( &bo, 0 );                 /* Buffer size */
  1042.         bo_addle_u32( &bo, 0 );                 /* Initial buffer fullness */
  1043.         bo_addle_u32( &bo, p_fmt->i_bitrate );  /* Alternate Bitrate */
  1044.         bo_addle_u32( &bo, 0 );                 /* Alternate Buffer size */
  1045.         bo_addle_u32( &bo, 0 );                 /* Alternate Initial buffer fullness */
  1046.         bo_addle_u32( &bo, 0 );                 /* Maximum object size (0 = unkown) */
  1047.         bo_addle_u32( &bo, 0x02 );              /* Flags (seekable) */
  1048.         bo_addle_u16( &bo, i+1 ); /* Stream number */
  1049.         bo_addle_u16( &bo, 0 ); /* Stream language index */
  1050.         bo_addle_u64( &bo, i_avg_duration );    /* Average time per frame */
  1051.         bo_addle_u16( &bo, 0 ); /* Stream name count */
  1052.         bo_addle_u16( &bo, 0 ); /* Payload extension system count */
  1053.     }
  1055.     /* metadata object (part of header extension) */
  1056.     if( i_cm_size )
  1057.     {
  1058.         int64_t i_num, i_den;
  1059.         unsigned int i_dst_num, i_dst_den;
  1061.         for( i = 0; i < p_sys->i_track; i++ )
  1062.             if( p_sys->track[i].i_cat == VIDEO_ES ) break;
  1064.         i_num = p_sys->track[i].fmt.video.i_aspect *
  1065.             (int64_t)p_sys->track[i].fmt.video.i_height;
  1066.         i_den = VOUT_ASPECT_FACTOR * p_sys->track[i].fmt.video.i_width;
  1067.         vlc_ureduce( &i_dst_num, &i_dst_den, i_num, i_den, 0 );
  1069.         msg_Dbg( p_mux, "pixel aspect-ratio: %i/%i", i_dst_num, i_dst_den );
  1071.         bo_add_guid ( &bo, &asf_object_metadata_guid );
  1072.         bo_addle_u64( &bo, i_cm_size );
  1073.         bo_addle_u16( &bo, 2 ); /* description records count */
  1074.         /* 1st description record */
  1075.         bo_addle_u16( &bo, 0 ); /* reserved */
  1076.         bo_addle_u16( &bo, i + 1 ); /* stream number (0 for the whole file) */
  1077.         bo_addle_u16( &bo, 2 * sizeof("AspectRatioX") ); /* name length */
  1078.         bo_addle_u16( &bo, 0x3 /* DWORD */ ); /* data type */
  1079.         bo_addle_u32( &bo, 4 ); /* data length */
  1080.         bo_addle_str16_nosize( &bo, "AspectRatioX" );
  1081.         bo_addle_u32( &bo, i_dst_num ); /* data */
  1082.         /* 2nd description record */
  1083.         bo_addle_u16( &bo, 0 ); /* reserved */
  1084.         bo_addle_u16( &bo, i + 1 ); /* stream number (0 for the whole file) */
  1085.         bo_addle_u16( &bo, 2 * sizeof("AspectRatioY") ); /* name length */
  1086.         bo_addle_u16( &bo, 0x3 /* DWORD */ ); /* data type */
  1087.         bo_addle_u32( &bo, 4 ); /* data length */
  1088.         bo_addle_str16_nosize( &bo, "AspectRatioY" );
  1089.         bo_addle_u32( &bo, i_dst_den ); /* data */
  1090.     }
  1092.     /* content description header */
  1093.     if( i_cd_size > 0 )
  1094.     {
  1095.         bo_add_guid ( &bo, &asf_object_content_description_guid );
  1096.         bo_addle_u64( &bo, i_cd_size );
  1097.         bo_addle_u16( &bo, 2 * strlen( p_sys->psz_title ) + 2 );
  1098.         bo_addle_u16( &bo, 2 * strlen( p_sys->psz_author ) + 2 );
  1099.         bo_addle_u16( &bo, 2 * strlen( p_sys->psz_copyright ) + 2 );
  1100.         bo_addle_u16( &bo, 2 * strlen( p_sys->psz_comment ) + 2 );
  1101.         bo_addle_u16( &bo, 2 * strlen( p_sys->psz_rating ) + 2 );
  1103.         bo_addle_str16_nosize( &bo, p_sys->psz_title );
  1104.         bo_addle_str16_nosize( &bo, p_sys->psz_author );
  1105.         bo_addle_str16_nosize( &bo, p_sys->psz_copyright );
  1106.         bo_addle_str16_nosize( &bo, p_sys->psz_comment );
  1107.         bo_addle_str16_nosize( &bo, p_sys->psz_rating );
  1108.     }
  1110.     /* stream properties */
  1111.     for( i = 0; i < p_sys->i_track; i++ )
  1112.     {
  1113.         tk = &p_sys->track[i];
  1115.         bo_add_guid ( &bo, &asf_object_stream_properties_guid );
  1116.         bo_addle_u64( &bo, 78 + tk->i_extra + (tk->b_audio_correction ? 8:0) );
  1118.         if( tk->i_cat == AUDIO_ES )
  1119.         {
  1120.             bo_add_guid( &bo, &asf_object_stream_type_audio );
  1121.             if( tk->b_audio_correction )
  1122.                 bo_add_guid( &bo, &asf_guid_audio_conceal_spread );
  1123.             else
  1124.                 bo_add_guid( &bo, &asf_guid_audio_conceal_none );
  1125.         }
  1126.         else if( tk->i_cat == VIDEO_ES )
  1127.         {
  1128.             bo_add_guid( &bo, &asf_object_stream_type_video );
  1129.             bo_add_guid( &bo, &asf_guid_video_conceal_none );
  1130.         }
  1131.         bo_addle_u64( &bo, 0 );         /* time offset */
  1132.         bo_addle_u32( &bo, tk->i_extra );
  1133.         /* correction data length */
  1134.         bo_addle_u32( &bo, tk->b_audio_correction ? 8 : 0 );
  1135.         bo_addle_u16( &bo, tk->i_id );  /* stream number */
  1136.         bo_addle_u32( &bo, 0 );
  1137.         bo_add_mem  ( &bo, tk->p_extra, tk->i_extra );
  1139.         /* Error correction data field */
  1140.         if( tk->b_audio_correction )
  1141.         {
  1142.             bo_add_u8( &bo, 0x1 ); /* span */
  1143.             bo_addle_u16( &bo, tk->i_blockalign );  /* virtual packet length */
  1144.             bo_addle_u16( &bo, tk->i_blockalign );  /* virtual chunck length */
  1145.             bo_addle_u16( &bo, 1 );  /* silence length */
  1146.             bo_add_u8( &bo, 0x0 ); /* data */
  1147.         }
  1148.     }
  1150.     /* Codec Infos */
  1151.     bo_add_guid ( &bo, &asf_object_codec_list_guid );
  1152.     bo_addle_u64( &bo, i_ci_size );
  1153.     bo_add_guid ( &bo, &asf_object_codec_list_reserved_guid );
  1154.     bo_addle_u32( &bo, p_sys->i_track );
  1155.     for( i = 0; i < p_sys->i_track; i++ )
  1156.     {
  1157.         tk = &p_sys->track[i];
  1159.         if( tk->i_cat == VIDEO_ES ) bo_addle_u16( &bo, 1 /* video */ );
  1160.         else if( tk->i_cat == AUDIO_ES ) bo_addle_u16( &bo, 2 /* audio */ );
  1161.         else bo_addle_u16( &bo, 0xFFFF /* unknown */ );
  1163.         bo_addle_str16( &bo, tk->psz_name );
  1164.         bo_addle_u16( &bo, 0 );
  1165.         if( tk->i_cat == AUDIO_ES )
  1166.         {
  1167.             bo_addle_u16( &bo, 2 );
  1168.             bo_addle_u16( &bo, tk->i_tag );
  1169.         }
  1170.         else if( tk->i_cat == VIDEO_ES )
  1171.         {
  1172.             bo_addle_u16( &bo, 4 );
  1173.             bo_add_mem  ( &bo, (uint8_t*)&tk->i_fourcc, 4 );
  1174.         }
  1175.     }
  1177.     /* data object */
  1178.     bo_add_guid ( &bo, &asf_object_data_guid );
  1179.     bo_addle_u64( &bo, 50 + p_sys->i_packet_count * p_sys->i_packet_size );
  1180.     bo_add_guid ( &bo, &p_sys->fid );
  1181.     bo_addle_u64( &bo, p_sys->i_packet_count );
  1182.     bo_addle_u16( &bo, 0x101 );
  1184.     return out;
  1185. }
  1187. /****************************************************************************
  1188.  *
  1189.  ****************************************************************************/
  1190. static block_t *asf_packet_flush( sout_mux_t *p_mux )
  1191. {
  1192.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  1193.     int i_pad, i_preheader = p_sys->b_asf_http ? 12 : 0;
  1194.     block_t *pk;
  1195.     bo_t bo;
  1197.     if( !p_sys->pk ) return 0;
  1199.     i_pad = p_sys->i_packet_size - p_sys->i_pk_used;
  1200.     memset( p_sys->pk->p_buffer + p_sys->i_pk_used, 0, i_pad );
  1202.     bo_init( &bo, p_sys->pk->p_buffer, 14 + i_preheader );
  1204.     if( p_sys->b_asf_http )
  1205.         asf_chunk_add( &bo, 0x4424, p_sys->i_packet_size, 0x0, p_sys->i_seq++);
  1207.     bo_add_u8   ( &bo, 0x82 );
  1208.     bo_addle_u16( &bo, 0 );
  1209.     bo_add_u8( &bo, 0x11 );
  1210.     bo_add_u8( &bo, 0x5d );
  1211.     bo_addle_u16( &bo, i_pad );
  1212.     bo_addle_u32( &bo, (p_sys->i_pk_dts - p_sys->i_dts_first) / 1000 +
  1213.                   p_sys->i_preroll_time );
  1214.     bo_addle_u16( &bo, 0 /* data->i_length */ );
  1215.     bo_add_u8( &bo, 0x80 | p_sys->i_pk_frame );
  1217.     pk = p_sys->pk;
  1218.     p_sys->pk = NULL;
  1220.     p_sys->i_packet_count++;
  1222.     return pk;
  1223. }
  1225. static block_t *asf_packet_create( sout_mux_t *p_mux,
  1226.                                    asf_track_t *tk, block_t *data )
  1227. {
  1228.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  1230.     int     i_data = data->i_buffer;
  1231.     int     i_pos  = 0;
  1232.     uint8_t *p_data= data->p_buffer;
  1233.     block_t *first = NULL, **last = &first;
  1234.     int     i_preheader = p_sys->b_asf_http ? 12 : 0;
  1236.     while( i_pos < i_data )
  1237.     {
  1238.         bo_t bo;
  1239.         int i_payload;
  1241.         if( p_sys->pk == NULL )
  1242.         {
  1243.             p_sys->pk = block_New( p_mux, p_sys->i_packet_size + i_preheader );
  1244.             /* reserve 14 bytes for the packet header */
  1245.             p_sys->i_pk_used = 14 + i_preheader;
  1246.             p_sys->i_pk_frame = 0;
  1247.             p_sys->i_pk_dts = data->i_dts;
  1248.         }
  1250.         bo_init( &bo, &p_sys->pk->p_buffer[p_sys->i_pk_used],
  1251.                  p_sys->i_packet_size - p_sys->i_pk_used );
  1253.         /* add payload (header size = 17) */
  1254.         i_payload = __MIN( i_data - i_pos,
  1255.                            p_sys->i_packet_size - p_sys->i_pk_used - 17 );
  1257.         if( tk->b_audio_correction && p_sys->i_pk_frame && i_payload < i_data )
  1258.         {
  1259.             /* Don't know why yet but WMP doesn't like splitted WMA packets */
  1260.             *last = asf_packet_flush( p_mux );
  1261.             last  = &(*last)->p_next;
  1262.             continue;
  1263.         }
  1265.         bo_add_u8   ( &bo, !(data->i_flags & BLOCK_FLAG_TYPE_P ||
  1266.                       data->i_flags & BLOCK_FLAG_TYPE_B) ?
  1267.                       0x80 | tk->i_id : tk->i_id );
  1268.         bo_add_u8   ( &bo, tk->i_sequence );
  1269.         bo_addle_u32( &bo, i_pos );
  1270.         bo_add_u8   ( &bo, 0x08 );  /* flags */
  1271.         bo_addle_u32( &bo, i_data );
  1272.         bo_addle_u32( &bo, (data->i_dts - p_sys->i_dts_first) / 1000 +
  1273.                       p_sys->i_preroll_time );
  1274.         bo_addle_u16( &bo, i_payload );
  1275.         bo_add_mem  ( &bo, &p_data[i_pos], i_payload );
  1276.         i_pos += i_payload;
  1277.         p_sys->i_pk_used += 17 + i_payload;
  1279.         p_sys->i_pk_frame++;
  1281.         if( p_sys->i_pk_used + 17 >= p_sys->i_packet_size )
  1282.         {
  1283.             /* Not enough data for another payload, flush the packet */
  1284.             *last = asf_packet_flush( p_mux );
  1285.             last  = &(*last)->p_next;
  1286.         }
  1287.     }
  1289.     tk->i_sequence++;
  1290.     block_Release( data );
  1292.     return first;
  1293. }
  1295. static block_t *asf_stream_end_create( sout_mux_t *p_mux )
  1296. {
  1297.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  1299.     block_t *out = NULL;
  1300.     bo_t bo;
  1302.     if( p_sys->b_asf_http )
  1303.     {
  1304.         out = block_New( p_mux, 12 );
  1305.         bo_init( &bo, out->p_buffer, 12 );
  1306.         asf_chunk_add( &bo, 0x4524, 0, 0x00, p_sys->i_seq++ );
  1307.     }
  1308.     else
  1309.     {
  1310.         /* Create index */
  1311.         out = block_New( p_mux, 56 );
  1312.         bo_init( &bo, out->p_buffer, 56 );
  1313.         bo_add_guid ( &bo, &asf_object_index_guid );
  1314.         bo_addle_u64( &bo, 56 );
  1315.         bo_add_guid ( &bo, &p_sys->fid );
  1316.         bo_addle_u64( &bo, 10000000 );
  1317.         bo_addle_u32( &bo, 5 );
  1318.         bo_addle_u32( &bo, 0 );
  1319.     }
  1321.     return out;
  1322. }