X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=modules%2Fmux%2Fmp4.c;h=a258adf4cd3bd326968e05ad3972a3c80f3966b4;hb=6ee1e193fd896ab9a4729fde14f009d9ce629815;hp=9fd9b24ed5a19616c16c5aecd3b9bb4429f1d93e;hpb=5c2cf083f90c34009b799ff65db74f27930a493d;p=vlc diff --git a/modules/mux/mp4.c b/modules/mux/mp4.c index 9fd9b24ed5..a258adf4cd 100644 --- a/modules/mux/mp4.c +++ b/modules/mux/mp4.c @@ -1,8 +1,8 @@ /***************************************************************************** * mp4.c: mp4/mov muxer ***************************************************************************** - * Copyright (C) 2001, 2002, 2003 VideoLAN - * $Id: mp4.c,v 1.10 2004/01/23 17:56:14 gbazin Exp $ + * Copyright (C) 2001, 2002, 2003, 2006 the VideoLAN team + * $Id$ * * Authors: Laurent Aimar * Gildas Bazin @@ -19,58 +19,67 @@ * * 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 -#include -#include +#include +#include +#include #ifdef HAVE_TIME_H #include #endif -#include "codecs.h" +#include "iso_lang.h" +#include "vlc_meta.h" /***************************************************************************** - * Exported prototypes + * Module descriptor *****************************************************************************/ +#define FASTSTART_TEXT N_("Create \"Fast Start\" files") +#define FASTSTART_LONGTEXT N_( \ + "Create \"Fast Start\" files. " \ + "\"Fast Start\" files are optimized for downloads and allow the user " \ + "to start previewing the file while it is downloading.") + static int Open ( vlc_object_t * ); static void Close ( vlc_object_t * ); -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 * ); - -/***************************************************************************** - * Module descriptor - *****************************************************************************/ -#define FASTSTART_TEXT N_("Create \"Fast start\" files") -#define FASTSTART_LONGTEXT N_( \ - "When this option is turned on, \"Fast start\" files will be created. " \ - "(\"Fast start\" files are optimized for download, allowing the user " \ - "to start previewing the file while it is downloading).") +#define SOUT_CFG_PREFIX "sout-mp4-" vlc_module_begin(); set_description( _("MP4/MOV muxer") ); + set_category( CAT_SOUT ); + set_subcategory( SUBCAT_SOUT_MUX ); + set_shortname( "MP4" ); - add_category_hint( "MP4/MOV muxer", NULL, VLC_TRUE ); - add_bool( "mp4-faststart", 1, NULL, FASTSTART_TEXT, FASTSTART_LONGTEXT, VLC_TRUE ); - + add_bool( SOUT_CFG_PREFIX "faststart", 1, NULL, + FASTSTART_TEXT, FASTSTART_LONGTEXT, + VLC_TRUE ); set_capability( "sout mux", 5 ); add_shortcut( "mp4" ); add_shortcut( "mov" ); + add_shortcut( "3gp" ); set_callbacks( Open, Close ); vlc_module_end(); +/***************************************************************************** + * Exported prototypes + *****************************************************************************/ +static const char *ppsz_sout_options[] = { + "faststart", NULL +}; + +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 * ); + /***************************************************************************** * Local prototypes *****************************************************************************/ @@ -79,41 +88,47 @@ typedef struct uint64_t i_pos; int i_size; - mtime_t i_pts; - mtime_t i_dts; + mtime_t i_pts_dts; mtime_t i_length; + unsigned int i_flags; } mp4_entry_t; typedef struct { - es_format_t *p_fmt; + es_format_t fmt; int i_track_id; /* index */ unsigned int i_entry_count; unsigned int i_entry_max; mp4_entry_t *entry; + int64_t i_length_neg; /* stats */ - mtime_t i_duration; + int64_t i_dts_start; + int64_t i_duration; /* for later stco fix-up (fast start files) */ uint64_t i_stco_pos; vlc_bool_t b_stco64; + /* for spu */ + int64_t i_last_dts; + } mp4_stream_t; struct sout_mux_sys_t { vlc_bool_t b_mov; + vlc_bool_t b_3gp; vlc_bool_t b_64_ext; vlc_bool_t b_fast_start; uint64_t i_mdat_pos; uint64_t i_pos; - mtime_t i_start_dts; + int64_t i_dts_start; int i_nb_streams; mp4_stream_t **pp_streams; @@ -135,24 +150,27 @@ static void bo_add_16be ( bo_t *, uint16_t ); static void bo_add_24be ( bo_t *, uint32_t ); static void bo_add_32be ( bo_t *, uint32_t ); static void bo_add_64be ( bo_t *, uint64_t ); -static void bo_add_fourcc(bo_t *, char * ); +static void bo_add_fourcc(bo_t *, const char * ); static void bo_add_bo ( bo_t *, bo_t * ); static void bo_add_mem ( bo_t *, int , uint8_t * ); static void bo_add_descr( bo_t *, uint8_t , uint32_t ); static void bo_fix_32be ( bo_t *, int , uint32_t ); -static bo_t *box_new ( char *fcc ); -static bo_t *box_full_new( char *fcc, uint8_t v, uint32_t f ); +static bo_t *box_new ( const char *fcc ); +static bo_t *box_full_new( const char *fcc, uint8_t v, uint32_t f ); static void box_fix ( bo_t *box ); static void box_free ( bo_t *box ); static void box_gather ( bo_t *box, bo_t *box2 ); static void box_send( sout_mux_t *p_mux, bo_t *box ); -static int64_t get_timestamp(); +static block_t *bo_to_sout( sout_instance_t *p_sout, bo_t *box ); + +static bo_t *GetMoovBox( sout_mux_t *p_mux ); -static sout_buffer_t *bo_to_sout( sout_instance_t *p_sout, bo_t *box ); +static block_t *ConvertSUBT( sout_mux_t *, mp4_stream_t *, block_t *); +static block_t *ConvertAVC1( sout_mux_t *, mp4_stream_t *, block_t * ); /***************************************************************************** * Open: @@ -163,29 +181,32 @@ static int Open( vlc_object_t *p_this ) sout_mux_sys_t *p_sys; bo_t *box; - p_sys = malloc( sizeof( sout_mux_sys_t ) ); + msg_Dbg( p_mux, "Mp4 muxer opend" ); + config_ChainParse( p_mux, SOUT_CFG_PREFIX, ppsz_sout_options, p_mux->p_cfg ); + + 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 ) ); p_sys->i_pos = 0; p_sys->i_nb_streams = 0; p_sys->pp_streams = NULL; p_sys->i_mdat_pos = 0; p_sys->b_mov = p_mux->psz_mux && !strcmp( p_mux->psz_mux, "mov" ); - p_sys->i_start_dts = 0; + p_sys->b_3gp = p_mux->psz_mux && !strcmp( p_mux->psz_mux, "3gp" ); + p_sys->i_dts_start = 0; - msg_Dbg( p_mux, "Open" ); - - p_mux->pf_capacity = Capability; - p_mux->pf_addstream = AddStream; - p_mux->pf_delstream = DelStream; - p_mux->pf_mux = Mux; - p_mux->p_sys = p_sys; if( !p_sys->b_mov ) { /* Now add ftyp header */ box = box_new( "ftyp" ); - bo_add_fourcc( box, "isom" ); + if( p_sys->b_3gp ) bo_add_fourcc( box, "3gp4" ); + else bo_add_fourcc( box, "isom" ); bo_add_32be ( box, 0 ); - bo_add_fourcc( box, "mp41" ); + if( p_sys->b_3gp ) bo_add_fourcc( box, "3gp4" ); + else bo_add_fourcc( box, "mp41" ); box_fix( box ); p_sys->i_pos += box->i_buffer; @@ -209,138 +230,774 @@ static int Open( vlc_object_t *p_this ) return VLC_SUCCESS; } -static int GetDescrLength( int i_size ) +/***************************************************************************** + * Close: + *****************************************************************************/ +static void Close( vlc_object_t * p_this ) { - if( i_size < 0x00000080 ) - return 2 + i_size; - else if( i_size < 0x00004000 ) - return 3 + i_size; - else if( i_size < 0x00200000 ) - return 4 + i_size; - else - return 5 + i_size; -} + sout_mux_t *p_mux = (sout_mux_t*)p_this; + sout_mux_sys_t *p_sys = p_mux->p_sys; + block_t *p_hdr; + bo_t bo, *moov; + vlc_value_t val; -static bo_t *GetESDS( mp4_stream_t *p_stream ) -{ - bo_t *esds; - int i_stream_type; - int i_object_type_indication; - int i_decoder_specific_info_size; + int i_trak; + uint64_t i_moov_pos; + + msg_Dbg( p_mux, "Close" ); - if( p_stream->p_fmt->i_extra > 0 ) + /* Update mdat size */ + bo_init( &bo, 0, NULL, VLC_TRUE ); + if( p_sys->i_pos - p_sys->i_mdat_pos >= (((uint64_t)1)<<32) ) { - i_decoder_specific_info_size = - GetDescrLength( p_stream->p_fmt->i_extra ); + /* Extended size */ + bo_add_32be ( &bo, 1 ); + bo_add_fourcc( &bo, "mdat" ); + bo_add_64be ( &bo, p_sys->i_pos - p_sys->i_mdat_pos ); } else { - i_decoder_specific_info_size = 0; + bo_add_32be ( &bo, 8 ); + bo_add_fourcc( &bo, "wide" ); + bo_add_32be ( &bo, p_sys->i_pos - p_sys->i_mdat_pos - 8 ); + bo_add_fourcc( &bo, "mdat" ); } + p_hdr = bo_to_sout( p_mux->p_sout, &bo ); + free( bo.p_buffer ); - esds = box_full_new( "esds", 0, 0 ); - - /* ES_Descr */ - bo_add_descr( esds, 0x03, 3 + - GetDescrLength( 13 + i_decoder_specific_info_size ) + - GetDescrLength( 1 ) ); - bo_add_16be( esds, p_stream->i_track_id ); - bo_add_8 ( esds, 0x1f ); // flags=0|streamPriority=0x1f + sout_AccessOutSeek( p_mux->p_access, p_sys->i_mdat_pos ); + sout_AccessOutWrite( p_mux->p_access, p_hdr ); - /* DecoderConfigDescr */ - bo_add_descr( esds, 0x04, 13 + i_decoder_specific_info_size ); + /* Create MOOV header */ + i_moov_pos = p_sys->i_pos; + moov = GetMoovBox( p_mux ); - switch( p_stream->p_fmt->i_codec ) + /* Check we need to create "fast start" files */ + var_Get( p_this, SOUT_CFG_PREFIX "faststart", &val ); + p_sys->b_fast_start = val.b_bool; + while( p_sys->b_fast_start ) { - case VLC_FOURCC( 'm', 'p', '4', 'v' ): - i_object_type_indication = 0x20; - break; - case VLC_FOURCC( 'm', 'p', 'g', 'v' ): - /* FIXME MPEG-I=0x6b, MPEG-II = 0x60 -> 0x65 */ - i_object_type_indication = 0x60; - break; - case VLC_FOURCC( 'm', 'p', '4', 'a' ): - /* FIXME for mpeg2-aac == 0x66->0x68 */ - i_object_type_indication = 0x40; - break; - case VLC_FOURCC( 'm', 'p', 'g', 'a' ): - i_object_type_indication = - p_stream->p_fmt->audio.i_rate < 32000 ? 0x69 : 0x6b; - break; - default: - i_object_type_indication = 0x00; - break; - } - i_stream_type = p_stream->p_fmt->i_cat == VIDEO_ES ? 0x04 : 0x05; - - bo_add_8 ( esds, i_object_type_indication ); - bo_add_8 ( esds, ( i_stream_type << 2 ) | 1 ); - bo_add_24be( esds, 1024 * 1024 ); // bufferSizeDB - bo_add_32be( esds, 0x7fffffff ); // maxBitrate - bo_add_32be( esds, 0 ); // avgBitrate + /* Move data to the end of the file so we can fit the moov header + * at the start */ + block_t *p_buf; + int64_t i_chunk, i_size = p_sys->i_pos - p_sys->i_mdat_pos; + int i_moov_size = moov->i_buffer; - if( p_stream->p_fmt->i_extra > 0 ) - { - int i; + while( i_size > 0 ) + { + i_chunk = __MIN( 32768, i_size ); + p_buf = block_New( p_mux, i_chunk ); + sout_AccessOutSeek( p_mux->p_access, + p_sys->i_mdat_pos + i_size - i_chunk ); + if( sout_AccessOutRead( p_mux->p_access, p_buf ) < i_chunk ) + { + msg_Warn( p_this, "read() not supported by access output, " + "won't create a fast start file" ); + p_sys->b_fast_start = VLC_FALSE; + block_Release( p_buf ); + break; + } + sout_AccessOutSeek( p_mux->p_access, p_sys->i_mdat_pos + i_size + + i_moov_size - i_chunk ); + sout_AccessOutWrite( p_mux->p_access, p_buf ); + i_size -= i_chunk; + } - /* DecoderSpecificInfo */ - bo_add_descr( esds, 0x05, p_stream->p_fmt->i_extra ); + if( !p_sys->b_fast_start ) break; - for( i = 0; i < p_stream->p_fmt->i_extra; i++ ) + /* Fix-up samples to chunks table in MOOV header */ + for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ ) { - bo_add_8( esds, ((uint8_t*)p_stream->p_fmt->p_extra)[i] ); + mp4_stream_t *p_stream = p_sys->pp_streams[i_trak]; + unsigned int i; + int i_chunk; + + moov->i_buffer = p_stream->i_stco_pos; + for( i_chunk = 0, i = 0; i < p_stream->i_entry_count; i_chunk++ ) + { + if( p_stream->b_stco64 ) + bo_add_64be( moov, p_stream->entry[i].i_pos + i_moov_size); + else + bo_add_32be( moov, p_stream->entry[i].i_pos + i_moov_size); + + while( i < p_stream->i_entry_count ) + { + if( i + 1 < p_stream->i_entry_count && + p_stream->entry[i].i_pos + p_stream->entry[i].i_size + != p_stream->entry[i + 1].i_pos ) + { + i++; + break; + } + + i++; + } + } } + + moov->i_buffer = i_moov_size; + i_moov_pos = p_sys->i_mdat_pos; + p_sys->b_fast_start = VLC_FALSE; } - /* SL_Descr mandatory */ - bo_add_descr( esds, 0x06, 1 ); - bo_add_8 ( esds, 0x02 ); // sl_predefined + /* Write MOOV header */ + sout_AccessOutSeek( p_mux->p_access, i_moov_pos ); + box_send( p_mux, moov ); - box_fix( esds ); + /* Clean-up */ + for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ ) + { + mp4_stream_t *p_stream = p_sys->pp_streams[i_trak]; - return esds; + es_format_Clean( &p_stream->fmt ); + free( p_stream->entry ); + free( p_stream ); + } + if( p_sys->i_nb_streams ) free( p_sys->pp_streams ); + free( p_sys ); } -static bo_t *GetWaveTag( mp4_stream_t *p_stream ) +/***************************************************************************** + * Control: + *****************************************************************************/ +static int Control( sout_mux_t *p_mux, int i_query, va_list args ) { - bo_t *wave; - bo_t *box; + vlc_bool_t *pb_bool; - wave = box_new( "wave" ); + switch( i_query ) + { + case MUX_CAN_ADD_STREAM_WHILE_MUXING: + pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t * ); + *pb_bool = VLC_FALSE; + return VLC_SUCCESS; - box = box_new( "frma" ); - bo_add_fourcc( box, "mp4a" ); - box_fix( box ); - box_gather( wave, box ); + case MUX_GET_ADD_STREAM_WAIT: + pb_bool = (vlc_bool_t*)va_arg( args, vlc_bool_t * ); + *pb_bool = VLC_TRUE; + return VLC_SUCCESS; - box = box_new( "mp4a" ); - bo_add_32be( box, 0 ); - box_fix( box ); - box_gather( wave, box ); + case MUX_GET_MIME: /* Not needed, as not streamable */ + default: + return VLC_EGENERIC; + } +} - box = GetESDS( p_stream ); - box_fix( box ); - box_gather( wave, box ); +/***************************************************************************** + * AddStream: + *****************************************************************************/ +static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input ) +{ + sout_mux_sys_t *p_sys = p_mux->p_sys; + mp4_stream_t *p_stream; - box = box_new( "srcq" ); - bo_add_32be( box, 0x40 ); - box_fix( box ); - box_gather( wave, box ); + switch( p_input->p_fmt->i_codec ) + { + case VLC_FOURCC( 'm', 'p', '4', 'a' ): + case VLC_FOURCC( 'm', 'p', '4', 'v' ): + case VLC_FOURCC( 'm', 'p', 'g', 'a' ): + case VLC_FOURCC( 'm', 'p', 'g', 'v' ): + case VLC_FOURCC( 'M', 'J', 'P', 'G' ): + case VLC_FOURCC( 'm', 'j', 'p', 'b' ): + case VLC_FOURCC( 'S', 'V', 'Q', '1' ): + case VLC_FOURCC( 'S', 'V', 'Q', '3' ): + case VLC_FOURCC( 'H', '2', '6', '3' ): + case VLC_FOURCC( 'h', '2', '6', '4' ): + case VLC_FOURCC( 's', 'a', 'm', 'r' ): + case VLC_FOURCC( 's', 'a', 'w', 'b' ): + case VLC_FOURCC( 'Y', 'V', '1', '2' ): + case VLC_FOURCC( 'Y', 'U', 'Y', '2' ): + break; + case VLC_FOURCC( 's', 'u', 'b', 't' ): + msg_Warn( p_mux, "subtitle track added like in .mov (even when creating .mp4)" ); + break; + default: + msg_Err( p_mux, "unsupported codec %4.4s in mp4", + (char*)&p_input->p_fmt->i_codec ); + return VLC_EGENERIC; + } - /* wazza ? */ - bo_add_32be( wave, 8 ); /* new empty box */ - bo_add_32be( wave, 0 ); /* box label */ + p_stream = malloc( sizeof( mp4_stream_t ) ); + es_format_Copy( &p_stream->fmt, p_input->p_fmt ); + p_stream->i_track_id = p_sys->i_nb_streams + 1; + p_stream->i_length_neg = 0; + p_stream->i_entry_count = 0; + p_stream->i_entry_max = 1000; + p_stream->entry = + calloc( p_stream->i_entry_max, sizeof( mp4_entry_t ) ); + p_stream->i_dts_start = 0; + p_stream->i_duration = 0; - box_fix( wave ); + p_input->p_sys = p_stream; - return wave; + msg_Dbg( p_mux, "adding input" ); + + TAB_APPEND( p_sys->i_nb_streams, p_sys->pp_streams, p_stream ); + return VLC_SUCCESS; } -/* TODO: No idea about these values */ -static bo_t *GetSVQ3Tag( mp4_stream_t *p_stream ) +/***************************************************************************** + * DelStream: + *****************************************************************************/ +static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input ) +{ + msg_Dbg( p_mux, "removing input" ); + return VLC_SUCCESS; +} + +static int MuxGetStream( sout_mux_t *p_mux, int *pi_stream, mtime_t *pi_dts ) +{ + mtime_t i_dts; + int i_stream; + int i; + + for( i = 0, i_dts = 0, i_stream = -1; i < p_mux->i_nb_inputs; i++ ) + { + block_fifo_t *p_fifo = p_mux->pp_inputs[i]->p_fifo; + block_t *p_buf; + + if( p_fifo->i_depth <= 1 ) + { + if( p_mux->pp_inputs[i]->p_fmt->i_cat != SPU_ES ) + { + return -1; // wait that all fifo have at least 2 packets + } + /* For SPU, we wait only 1 packet */ + continue; + } + + p_buf = block_FifoShow( p_fifo ); + if( i_stream < 0 || p_buf->i_dts < i_dts ) + { + i_dts = p_buf->i_dts; + i_stream = i; + } + } + if( pi_stream ) + { + *pi_stream = i_stream; + } + if( pi_dts ) + { + *pi_dts = i_dts; + } + return i_stream; +} + +/***************************************************************************** + * Mux: + *****************************************************************************/ +static int Mux( sout_mux_t *p_mux ) +{ + sout_mux_sys_t *p_sys = p_mux->p_sys; + + for( ;; ) + { + sout_input_t *p_input; + int i_stream; + mp4_stream_t *p_stream; + block_t *p_data; + mtime_t i_dts; + + if( MuxGetStream( p_mux, &i_stream, &i_dts) < 0 ) + { + return( VLC_SUCCESS ); + } + + p_input = p_mux->pp_inputs[i_stream]; + p_stream = (mp4_stream_t*)p_input->p_sys; + +again: + p_data = block_FifoGet( p_input->p_fifo ); + if( p_stream->fmt.i_codec == VLC_FOURCC( 'h', '2', '6', '4' ) ) + { + p_data = ConvertAVC1( p_mux, p_stream, p_data ); + } + else if( p_stream->fmt.i_codec == VLC_FOURCC( 's', 'u', 'b', 't' ) ) + { + p_data = ConvertSUBT( p_mux, p_stream, p_data ); + } + if( p_data == NULL ) goto again; + + if( p_stream->fmt.i_cat != SPU_ES ) + { + /* Fix length of the sample */ + if( p_input->p_fifo->i_depth > 0 ) + { + block_t *p_next = block_FifoShow( p_input->p_fifo ); + int64_t i_diff = p_next->i_dts - p_data->i_dts; + + if( i_diff < I64C(1000000 ) ) /* protection */ + { + p_data->i_length = i_diff; + } + } + if( p_data->i_length <= 0 ) + { + msg_Warn( p_mux, "i_length <= 0" ); + p_stream->i_length_neg += p_data->i_length - 1; + p_data->i_length = 1; + } + else if( p_stream->i_length_neg < 0 ) + { + int64_t i_recover = __MIN( p_data->i_length / 4, - p_stream->i_length_neg ); + + p_data->i_length -= i_recover; + p_stream->i_length_neg += i_recover; + } + } + + /* Save starting time */ + if( p_stream->i_entry_count == 0 ) + { + p_stream->i_dts_start = p_data->i_dts; + + /* Update global dts_start */ + if( p_sys->i_dts_start <= 0 || + p_stream->i_dts_start < p_sys->i_dts_start ) + { + p_sys->i_dts_start = p_stream->i_dts_start; + } + } + + if( p_stream->fmt.i_cat == SPU_ES && p_stream->i_entry_count > 0 ) + { + int64_t i_length = p_data->i_dts - p_stream->i_last_dts; + + if( i_length <= 0 ) + { + /* FIXME handle this broken case */ + i_length = 1; + } + + /* Fix last entry */ + if( p_stream->entry[p_stream->i_entry_count-1].i_length <= 0 ) + { + p_stream->entry[p_stream->i_entry_count-1].i_length = i_length; + } + } + + + /* add index entry */ + p_stream->entry[p_stream->i_entry_count].i_pos = p_sys->i_pos; + p_stream->entry[p_stream->i_entry_count].i_size = p_data->i_buffer; + p_stream->entry[p_stream->i_entry_count].i_pts_dts= + __MAX( p_data->i_pts - p_data->i_dts, 0 ); + p_stream->entry[p_stream->i_entry_count].i_length = p_data->i_length; + p_stream->entry[p_stream->i_entry_count].i_flags = p_data->i_flags; + + p_stream->i_entry_count++; + /* XXX: -1 to always have 2 entry for easy adding of empty SPU */ + if( p_stream->i_entry_count >= p_stream->i_entry_max - 1 ) + { + p_stream->i_entry_max += 1000; + p_stream->entry = + realloc( p_stream->entry, + p_stream->i_entry_max * sizeof( mp4_entry_t ) ); + } + + /* update */ + p_stream->i_duration += p_data->i_length; + p_sys->i_pos += p_data->i_buffer; + + /* Save the DTS */ + p_stream->i_last_dts = p_data->i_dts; + + /* write data */ + sout_AccessOutWrite( p_mux->p_access, p_data ); + + if( p_stream->fmt.i_cat == SPU_ES ) + { + int64_t i_length = p_stream->entry[p_stream->i_entry_count-1].i_length; + + if( i_length != 0 ) + { + /* TODO */ + msg_Dbg( p_mux, "writing an empty sub" ) ; + + /* Append a idx entry */ + p_stream->entry[p_stream->i_entry_count].i_pos = p_sys->i_pos; + p_stream->entry[p_stream->i_entry_count].i_size = 3; + p_stream->entry[p_stream->i_entry_count].i_pts_dts= 0; + p_stream->entry[p_stream->i_entry_count].i_length = 0; + p_stream->entry[p_stream->i_entry_count].i_flags = 0; + + /* XXX: No need to grow the entry here */ + p_stream->i_entry_count++; + + /* Fix last dts */ + p_stream->i_last_dts += i_length; + + /* Write a " " */ + p_data = block_New( p_mux, 3 ); + p_data->p_buffer[0] = 0; + p_data->p_buffer[1] = 1; + p_data->p_buffer[2] = ' '; + + p_sys->i_pos += p_data->i_buffer; + + sout_AccessOutWrite( p_mux->p_access, p_data ); + } + + /* Fix duration */ + p_stream->i_duration = p_stream->i_last_dts - p_stream->i_dts_start; + } + } + + return( VLC_SUCCESS ); +} + +/***************************************************************************** + * + *****************************************************************************/ +static block_t *ConvertSUBT( sout_mux_t *p_mux, mp4_stream_t *tk, block_t *p_block ) +{ + p_block = block_Realloc( p_block, 2, p_block->i_buffer ); + + /* No trailling '\0' */ + if( p_block->i_buffer > 2 && p_block->p_buffer[p_block->i_buffer-1] == '\0' ) + p_block->i_buffer--; + + p_block->p_buffer[0] = ( (p_block->i_buffer - 2) >> 8 )&0xff; + p_block->p_buffer[1] = ( (p_block->i_buffer - 2) )&0xff; + + return p_block; +} + +static block_t *ConvertAVC1( sout_mux_t *p_mux, mp4_stream_t *tk, block_t *p_block ) +{ + uint8_t *last = p_block->p_buffer; /* Assume it starts with 0x00000001 */ + uint8_t *dat = &p_block->p_buffer[4]; + uint8_t *end = &p_block->p_buffer[p_block->i_buffer]; + + + /* Replace the 4 bytes start code with 4 bytes size, + * FIXME are all startcodes 4 bytes ? (I don't think :( */ + while( dat < end ) + { + int i_size; + + while( dat < end - 4 ) + { + if( dat[0] == 0x00 && dat[1] == 0x00 && + dat[2] == 0x00 && dat[3] == 0x01 ) + { + break; + } + dat++; + } + if( dat >= end - 4 ) + { + dat = end; + } + + /* Fix size */ + i_size = dat - &last[4]; + last[0] = ( i_size >> 24 )&0xff; + last[1] = ( i_size >> 16 )&0xff; + last[2] = ( i_size >> 8 )&0xff; + last[3] = ( i_size )&0xff; + + /* Skip blocks with SPS/PPS */ + if( (last[4]&0x1f) == 7 || (last[4]&0x1f) == 8 ) + { + ; // FIXME Find a way to skip dat without frelling everything + } + last = dat; + dat += 4; + } + return p_block; +} + +static int GetDescrLength( int i_size ) +{ + if( i_size < 0x00000080 ) + return 2 + i_size; + else if( i_size < 0x00004000 ) + return 3 + i_size; + else if( i_size < 0x00200000 ) + return 4 + i_size; + else + return 5 + i_size; +} + +static bo_t *GetESDS( mp4_stream_t *p_stream ) +{ + bo_t *esds; + int i_stream_type; + int i_object_type_indication; + int i_decoder_specific_info_size; + unsigned int i; + int64_t i_bitrate_avg = 0; + int64_t i_bitrate_max = 0; + + /* Compute avg/max bitrate */ + for( i = 0; i < p_stream->i_entry_count; i++ ) + { + i_bitrate_avg += p_stream->entry[i].i_size; + if( p_stream->entry[i].i_length > 0) + { + int64_t i_bitrate = I64C(8000000) * p_stream->entry[i].i_size / p_stream->entry[i].i_length; + if( i_bitrate > i_bitrate_max ) + i_bitrate_max = i_bitrate; + } + } + + if( p_stream->i_duration > 0 ) + i_bitrate_avg = I64C(8000000) * i_bitrate_avg / p_stream->i_duration; + else + i_bitrate_avg = 0; + if( i_bitrate_max <= 1 ) + i_bitrate_max = 0x7fffffff; + + /* */ + if( p_stream->fmt.i_extra > 0 ) + { + i_decoder_specific_info_size = + GetDescrLength( p_stream->fmt.i_extra ); + } + else + { + i_decoder_specific_info_size = 0; + } + + esds = box_full_new( "esds", 0, 0 ); + + /* ES_Descr */ + bo_add_descr( esds, 0x03, 3 + + GetDescrLength( 13 + i_decoder_specific_info_size ) + + GetDescrLength( 1 ) ); + bo_add_16be( esds, p_stream->i_track_id ); + bo_add_8 ( esds, 0x1f ); // flags=0|streamPriority=0x1f + + /* DecoderConfigDescr */ + bo_add_descr( esds, 0x04, 13 + i_decoder_specific_info_size ); + + switch( p_stream->fmt.i_codec ) + { + case VLC_FOURCC( 'm', 'p', '4', 'v' ): + i_object_type_indication = 0x20; + break; + case VLC_FOURCC( 'm', 'p', 'g', 'v' ): + /* FIXME MPEG-I=0x6b, MPEG-II = 0x60 -> 0x65 */ + i_object_type_indication = 0x60; + break; + case VLC_FOURCC( 'm', 'p', '4', 'a' ): + /* FIXME for mpeg2-aac == 0x66->0x68 */ + i_object_type_indication = 0x40; + break; + case VLC_FOURCC( 'm', 'p', 'g', 'a' ): + i_object_type_indication = + p_stream->fmt.audio.i_rate < 32000 ? 0x69 : 0x6b; + break; + default: + i_object_type_indication = 0x00; + break; + } + i_stream_type = p_stream->fmt.i_cat == VIDEO_ES ? 0x04 : 0x05; + + bo_add_8 ( esds, i_object_type_indication ); + bo_add_8 ( esds, ( i_stream_type << 2 ) | 1 ); + bo_add_24be( esds, 1024 * 1024 ); // bufferSizeDB + bo_add_32be( esds, i_bitrate_max ); // maxBitrate + bo_add_32be( esds, i_bitrate_avg ); // avgBitrate + + if( p_stream->fmt.i_extra > 0 ) + { + int i; + + /* DecoderSpecificInfo */ + bo_add_descr( esds, 0x05, p_stream->fmt.i_extra ); + + for( i = 0; i < p_stream->fmt.i_extra; i++ ) + { + bo_add_8( esds, ((uint8_t*)p_stream->fmt.p_extra)[i] ); + } + } + + /* SL_Descr mandatory */ + bo_add_descr( esds, 0x06, 1 ); + bo_add_8 ( esds, 0x02 ); // sl_predefined + + box_fix( esds ); + + return esds; +} + +static bo_t *GetWaveTag( mp4_stream_t *p_stream ) +{ + bo_t *wave; + bo_t *box; + + wave = box_new( "wave" ); + + box = box_new( "frma" ); + bo_add_fourcc( box, "mp4a" ); + box_fix( box ); + box_gather( wave, box ); + + box = box_new( "mp4a" ); + bo_add_32be( box, 0 ); + box_fix( box ); + box_gather( wave, box ); + + box = GetESDS( p_stream ); + box_fix( box ); + box_gather( wave, box ); + + box = box_new( "srcq" ); + bo_add_32be( box, 0x40 ); + box_fix( box ); + box_gather( wave, box ); + + /* wazza ? */ + bo_add_32be( wave, 8 ); /* new empty box */ + bo_add_32be( wave, 0 ); /* box label */ + + box_fix( wave ); + + return wave; +} + +static bo_t *GetDamrTag( mp4_stream_t *p_stream ) +{ + bo_t *damr; + + damr = box_new( "damr" ); + + bo_add_fourcc( damr, "REFC" ); + bo_add_8( damr, 0 ); + + if( p_stream->fmt.i_codec == VLC_FOURCC( 's', 'a', 'm', 'r' ) ) + bo_add_16be( damr, 0x81ff ); /* Mode set (all modes for AMR_NB) */ + else + bo_add_16be( damr, 0x83ff ); /* Mode set (all modes for AMR_WB) */ + bo_add_16be( damr, 0x1 ); /* Mode change period (no restriction) */ + + box_fix( damr ); + + return damr; +} + +static bo_t *GetD263Tag( mp4_stream_t *p_stream ) +{ + bo_t *d263; + + d263 = box_new( "d263" ); + + bo_add_fourcc( d263, "VLC " ); + bo_add_16be( d263, 0xa ); + bo_add_8( d263, 0 ); + + box_fix( d263 ); + + return d263; +} + +static bo_t *GetAvcCTag( mp4_stream_t *p_stream ) +{ + bo_t *avcC = NULL; + uint8_t *p_sps = NULL; + uint8_t *p_pps = NULL; + int i_sps_size = 0; + int i_pps_size = 0; + + if( p_stream->fmt.i_extra > 0 ) + { + /* FIXME: take into account multiple sps/pps */ + uint8_t *p_buffer = p_stream->fmt.p_extra; + int i_buffer = p_stream->fmt.i_extra; + + while( i_buffer > 4 && + p_buffer[0] == 0 && p_buffer[1] == 0 && + p_buffer[2] == 0 && p_buffer[3] == 1 ) + { + const int i_nal_type = p_buffer[4]&0x1f; + int i_offset = 1; + int i_size = 0; + int i_startcode = 0; + + //msg_Dbg( p_stream, "we found a startcode for NAL with TYPE:%d", i_nal_type ); + + for( i_offset = 1; i_offset+3 < i_buffer ; i_offset++) + { + if( p_buffer[i_offset] == 0 && p_buffer[i_offset+1] == 0 && + p_buffer[i_offset+2] == 0 && p_buffer[i_offset+3] == 1 ) + { + /* we found another startcode */ + i_startcode = i_offset; + break; + } + } + i_size = i_startcode ? i_startcode : i_buffer; + if( i_nal_type == 7 ) + { + p_sps = &p_buffer[4]; + i_sps_size = i_size - 4; + } + if( i_nal_type == 8 ) + { + p_pps = &p_buffer[4]; + i_pps_size = i_size - 4; + } + i_buffer -= i_size; + p_buffer += i_size; + } + } + + /* FIXME use better value */ + avcC = box_new( "avcC" ); + bo_add_8( avcC, 1 ); /* configuration version */ + bo_add_8( avcC, i_sps_size ? p_sps[1] : 77 ); + bo_add_8( avcC, i_sps_size ? p_sps[2] : 64 ); + bo_add_8( avcC, i_sps_size ? p_sps[3] : 30 ); /* level, 5.1 */ + bo_add_8( avcC, 0xff ); /* 0b11111100 | lengthsize = 0x11 */ + + bo_add_8( avcC, 0xe0 | (i_sps_size > 0 ? 1 : 0) ); /* 0b11100000 | sps_count */ + if( i_sps_size > 0 ) + { + bo_add_16be( avcC, i_sps_size ); + bo_add_mem( avcC, i_sps_size, p_sps ); + } + + bo_add_8( avcC, (i_pps_size > 0 ? 1 : 0) ); /* pps_count */ + if( i_pps_size > 0 ) + { + bo_add_16be( avcC, i_pps_size ); + bo_add_mem( avcC, i_pps_size, p_pps ); + } + box_fix( avcC ); + + return avcC; +} + +/* TODO: No idea about these values */ +static bo_t *GetSVQ3Tag( mp4_stream_t *p_stream ) { bo_t *smi = box_new( "SMI " ); + if( p_stream->fmt.i_extra > 0x4e ) + { + uint8_t *p_end = &((uint8_t*)p_stream->fmt.p_extra)[p_stream->fmt.i_extra]; + uint8_t *p = &((uint8_t*)p_stream->fmt.p_extra)[0x46]; + + while( p + 8 < p_end ) + { + int i_size = GetDWBE( p ); + if( i_size <= 1 ) + { + /* FIXME handle 1 as long size */ + break; + } + if( !strncmp( (const char *)&p[4], "SMI ", 4 ) ) + { + bo_add_mem( smi, p_end - p - 8, &p[8] ); + return smi; + } + p += i_size; + } + } + + /* Create a dummy one in fallback */ bo_add_fourcc( smi, "SEQH" ); bo_add_32be( smi, 0x5 ); bo_add_32be( smi, 0xe2c0211d ); @@ -354,6 +1011,7 @@ static bo_t *GetUdtaTag( sout_mux_t *p_mux ) { sout_mux_sys_t *p_sys = p_mux->p_sys; bo_t *udta = box_new( "udta" ); + vlc_meta_t *p_meta = p_mux->p_sout->p_meta; int i_track; /* Requirements */ @@ -361,15 +1019,15 @@ static bo_t *GetUdtaTag( sout_mux_t *p_mux ) { mp4_stream_t *p_stream = p_sys->pp_streams[i_track]; - if( p_stream->p_fmt->i_codec == VLC_FOURCC('m','p','4','v') || - p_stream->p_fmt->i_codec == VLC_FOURCC('m','p','4','a') ) + if( p_stream->fmt.i_codec == VLC_FOURCC('m','p','4','v') || + p_stream->fmt.i_codec == VLC_FOURCC('m','p','4','a') ) { bo_t *box = box_new( "\251req" ); /* String length */ bo_add_16be( box, sizeof("QuickTime 6.0 or greater") - 1); bo_add_16be( box, 0 ); bo_add_mem( box, sizeof("QuickTime 6.0 or greater") - 1, - "QuickTime 6.0 or greater" ); + (uint8_t *)"QuickTime 6.0 or greater" ); box_fix( box ); box_gather( udta, box ); break; @@ -383,639 +1041,507 @@ static bo_t *GetUdtaTag( sout_mux_t *p_mux ) bo_add_16be( box, sizeof(PACKAGE_STRING " stream output") - 1); bo_add_16be( box, 0 ); bo_add_mem( box, sizeof(PACKAGE_STRING " stream output") - 1, - PACKAGE_STRING " stream output" ); + (uint8_t*)PACKAGE_STRING " stream output" ); box_fix( box ); box_gather( udta, box ); } + /* Misc atoms */ + if( p_meta ) + { +#define ADD_META_BOX( type, box_string ) { \ + bo_t *box = NULL; \ + if( vlc_meta_Get( p_meta, vlc_meta_##type ) ) box = box_new( "\251" box_string ); \ + if( box ) \ + { \ + bo_add_16be( box, strlen( vlc_meta_Get( p_meta, vlc_meta_##type ) )); \ + bo_add_16be( box, 0 ); \ + bo_add_mem( box, strlen( vlc_meta_Get( p_meta, vlc_meta_##type ) ), \ + (uint8_t*)(vlc_meta_Get( p_meta, vlc_meta_##type ) ) ); \ + box_fix( box ); \ + box_gather( udta, box ); \ + } } + + ADD_META_BOX( Title, "nam" ); + ADD_META_BOX( Artist, "ART" ); + ADD_META_BOX( Genre, "gen" ); + ADD_META_BOX( Copyright, "cpy" ); + ADD_META_BOX( Description, "des" ); + ADD_META_BOX( Date, "day" ); + ADD_META_BOX( URL, "url" ); +#undef ADD_META_BOX + } + box_fix( udta ); return udta; } -static uint32_t mvhd_matrix[9] = - { 0x10000, 0, 0, 0, 0x10000, 0, 0, 0, 0x40000000 }; - -static bo_t *GetMoovTag( sout_mux_t *p_mux ) +static bo_t *GetSounBox( sout_mux_t *p_mux, mp4_stream_t *p_stream ) { sout_mux_sys_t *p_sys = p_mux->p_sys; + vlc_bool_t b_descr = VLC_FALSE; + bo_t *soun; + char fcc[4] = " "; + int i; - bo_t *moov, *mvhd; - unsigned int i; - int i_trak, i_index; - - uint32_t i_movie_timescale = 90000; - int64_t i_movie_duration = 0; - - moov = box_new( "moov" ); - - /* *** add /moov/mvhd *** */ - if( !p_sys->b_64_ext ) - { - mvhd = box_full_new( "mvhd", 0, 0 ); - bo_add_32be( mvhd, get_timestamp() ); // creation time - bo_add_32be( mvhd, get_timestamp() ); // modification time - bo_add_32be( mvhd, i_movie_timescale); // timescale - bo_add_32be( mvhd, i_movie_duration ); // duration - } - else + switch( p_stream->fmt.i_codec ) { - mvhd = box_full_new( "mvhd", 1, 0 ); - bo_add_64be( mvhd, get_timestamp() ); // creation time - bo_add_64be( mvhd, get_timestamp() ); // modification time - bo_add_32be( mvhd, i_movie_timescale); // timescale - bo_add_64be( mvhd, i_movie_duration ); // duration + case VLC_FOURCC('m','p','4','a'): + memcpy( fcc, "mp4a", 4 ); + b_descr = VLC_TRUE; + break; + + case VLC_FOURCC('s','a','m','r'): + case VLC_FOURCC('s','a','w','b'): + memcpy( fcc, (char*)&p_stream->fmt.i_codec, 4 ); + b_descr = VLC_TRUE; + break; + + case VLC_FOURCC('m','p','g','a'): + if( p_sys->b_mov ) + memcpy( fcc, ".mp3", 4 ); + else + { + memcpy( fcc, "mp4a", 4 ); + b_descr = VLC_TRUE; + } + break; + + default: + memcpy( fcc, (char*)&p_stream->fmt.i_codec, 4 ); + break; } - bo_add_32be( mvhd, 0x10000 ); // rate - bo_add_16be( mvhd, 0x100 ); // volume - bo_add_16be( mvhd, 0 ); // reserved - for( i = 0; i < 2; i++ ) + + soun = box_new( fcc ); + for( i = 0; i < 6; i++ ) { - bo_add_32be( mvhd, 0 ); // reserved + bo_add_8( soun, 0 ); // reserved; } - for( i = 0; i < 9; i++ ) + bo_add_16be( soun, 1 ); // data-reference-index + + /* SoundDescription */ + if( p_sys->b_mov && + p_stream->fmt.i_codec == VLC_FOURCC('m','p','4','a') ) { - bo_add_32be( mvhd, mvhd_matrix[i] );// matrix + bo_add_16be( soun, 1 ); // version 1; } - for( i = 0; i < 6; i++ ) + else { - bo_add_32be( mvhd, 0 ); // pre-defined + bo_add_16be( soun, 0 ); // version 0; } - - /* Find the 1st track id */ - for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ ) + bo_add_16be( soun, 0 ); // revision level (0) + bo_add_32be( soun, 0 ); // vendor + // channel-count + bo_add_16be( soun, p_stream->fmt.audio.i_channels ); + // sample size + bo_add_16be( soun, p_stream->fmt.audio.i_bitspersample ? + p_stream->fmt.audio.i_bitspersample : 16 ); + bo_add_16be( soun, -2 ); // compression id + bo_add_16be( soun, 0 ); // packet size (0) + bo_add_16be( soun, p_stream->fmt.audio.i_rate ); // sampleratehi + bo_add_16be( soun, 0 ); // sampleratelo + + /* Extended data for SoundDescription V1 */ + if( p_sys->b_mov && + p_stream->fmt.i_codec == VLC_FOURCC('m','p','4','a') ) { - mp4_stream_t *p_stream = p_sys->pp_streams[i_trak]; - - if( p_stream->p_fmt->i_cat == AUDIO_ES || - p_stream->p_fmt->i_cat == VIDEO_ES ) - { - /* Found it */ - bo_add_32be( mvhd, p_stream->i_track_id ); // next-track-id - break; - } + /* samples per packet */ + bo_add_32be( soun, p_stream->fmt.audio.i_frame_length ); + bo_add_32be( soun, 1536 ); /* bytes per packet */ + bo_add_32be( soun, 2 ); /* bytes per frame */ + /* bytes per sample */ + bo_add_32be( soun, 2 /*p_stream->fmt.audio.i_bitspersample/8 */); } - if( i_trak == p_sys->i_nb_streams ) /* Just for sanity reasons */ - bo_add_32be( mvhd, 0xffffffff ); - - box_fix( mvhd ); - box_gather( moov, mvhd ); - for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ ) + /* Add an ES Descriptor */ + if( b_descr ) { - mp4_stream_t *p_stream; - uint32_t i_timescale; - uint32_t i_chunk_count; - unsigned int i_chunk; - - bo_t *trak; - bo_t *tkhd; - bo_t *mdia; - bo_t *mdhd, *hdlr; - bo_t *minf; - bo_t *dinf; - bo_t *dref; - bo_t *url; - bo_t *stbl; - bo_t *stsd; - bo_t *stts; - bo_t *stco; - bo_t *stsc; - bo_t *stsz; - - p_stream = p_sys->pp_streams[i_trak]; + bo_t *box; - if( p_stream->p_fmt->i_cat != AUDIO_ES && - p_stream->p_fmt->i_cat != VIDEO_ES ) + if( p_sys->b_mov && + p_stream->fmt.i_codec == VLC_FOURCC('m','p','4','a') ) { - msg_Err( p_mux, "FIXME ignoring trak (noaudio&&novideo)" ); - continue; + box = GetWaveTag( p_stream ); } - if( p_stream->p_fmt->i_cat == AUDIO_ES ) + else if( p_stream->fmt.i_codec == VLC_FOURCC('s','a','m','r') ) { - i_timescale = p_stream->p_fmt->audio.i_rate; + box = GetDamrTag( p_stream ); } else { - i_timescale = 1001; + box = GetESDS( p_stream ); } + box_fix( box ); + box_gather( soun, box ); + } - /* *** add /moov/trak *** */ - trak = box_new( "trak" ); - - /* *** add /moov/trak/tkhd *** */ - if( !p_sys->b_64_ext ) - { - if( p_sys->b_mov ) - tkhd = box_full_new( "tkhd", 0, 0x0f ); - else - tkhd = box_full_new( "tkhd", 0, 1 ); - - bo_add_32be( tkhd, get_timestamp() ); // creation time - bo_add_32be( tkhd, get_timestamp() ); // modification time - bo_add_32be( tkhd, p_stream->i_track_id ); - bo_add_32be( tkhd, 0 ); // reserved 0 - bo_add_32be( tkhd, p_stream->i_duration * - (int64_t)i_movie_timescale / - (mtime_t)1000000 ); // duration - } - else - { - if( p_sys->b_mov ) - tkhd = box_full_new( "tkhd", 1, 0x0f ); - else - tkhd = box_full_new( "tkhd", 1, 1 ); + box_fix( soun ); - bo_add_64be( tkhd, get_timestamp() ); // creation time - bo_add_64be( tkhd, get_timestamp() ); // modification time - bo_add_32be( tkhd, p_stream->i_track_id ); - bo_add_32be( tkhd, 0 ); // reserved 0 - bo_add_64be( tkhd, p_stream->i_duration * - (int64_t)i_movie_timescale / - (mtime_t)1000000 ); // duration - } + return soun; +} - for( i = 0; i < 2; i++ ) - { - bo_add_32be( tkhd, 0 ); // reserved - } - bo_add_16be( tkhd, 0 ); // layer - bo_add_16be( tkhd, 0 ); // pre-defined - bo_add_16be( tkhd, p_stream->p_fmt->i_cat == AUDIO_ES ? 0x100 : 0 ); // volume - bo_add_16be( tkhd, 0 ); // reserved - for( i = 0; i < 9; i++ ) - { - bo_add_32be( tkhd, mvhd_matrix[i] ); // matrix - } - if( p_stream->p_fmt->i_cat == AUDIO_ES ) - { - bo_add_32be( tkhd, 0 ); // width (presentation) - bo_add_32be( tkhd, 0 ); // height(presentation) - } - else - { - bo_add_32be( tkhd, p_stream->p_fmt->video.i_width << 16 ); // width (presentation) - bo_add_32be( tkhd, p_stream->p_fmt->video.i_height << 16 ); // height(presentation) - } - box_fix( tkhd ); - box_gather( trak, tkhd ); +static bo_t *GetVideBox( sout_mux_t *p_mux, mp4_stream_t *p_stream ) +{ - /* *** add /moov/trak/mdia *** */ - mdia = box_new( "mdia" ); + bo_t *vide; + char fcc[4] = " "; + int i; - /* media header */ - if( !p_sys->b_64_ext ) - { - mdhd = box_full_new( "mdhd", 0, 0 ); - bo_add_32be( mdhd, get_timestamp() ); // creation time - bo_add_32be( mdhd, get_timestamp() ); // modification time - bo_add_32be( mdhd, i_timescale); // timescale - bo_add_32be( mdhd, p_stream->i_duration * (int64_t)i_timescale / - (mtime_t)1000000 ); // duration - } - else - { - mdhd = box_full_new( "mdhd", 1, 0 ); - bo_add_64be( mdhd, get_timestamp() ); // creation time - bo_add_64be( mdhd, get_timestamp() ); // modification time - bo_add_32be( mdhd, i_timescale); // timescale - bo_add_64be( mdhd, p_stream->i_duration * (int64_t)i_timescale / - (mtime_t)1000000 ); // duration - } + switch( p_stream->fmt.i_codec ) + { + case VLC_FOURCC('m','p','4','v'): + case VLC_FOURCC('m','p','g','v'): + memcpy( fcc, "mp4v", 4 ); + break; + + case VLC_FOURCC('M','J','P','G'): + memcpy( fcc, "mjpa", 4 ); + break; + + case VLC_FOURCC('S','V','Q','1'): + memcpy( fcc, "SVQ1", 4 ); + break; + + case VLC_FOURCC('S','V','Q','3'): + memcpy( fcc, "SVQ3", 4 ); + break; + + case VLC_FOURCC('H','2','6','3'): + memcpy( fcc, "s263", 4 ); + break; + + case VLC_FOURCC('h','2','6','4'): + memcpy( fcc, "avc1", 4 ); + break; + + case VLC_FOURCC('Y','V','1','2'): + memcpy( fcc, "yv12", 4 ); + break; + + case VLC_FOURCC('Y','U','Y','2'): + memcpy( fcc, "yuy2", 4 ); + break; + + default: + memcpy( fcc, (char*)&p_stream->fmt.i_codec, 4 ); + break; + } - bo_add_16be( mdhd, 0 ); // language FIXME - bo_add_16be( mdhd, 0 ); // predefined - box_fix( mdhd ); - box_gather( mdia, mdhd ); + vide = box_new( fcc ); + for( i = 0; i < 6; i++ ) + { + bo_add_8( vide, 0 ); // reserved; + } + bo_add_16be( vide, 1 ); // data-reference-index - /* handler reference */ - hdlr = box_full_new( "hdlr", 0, 0 ); + bo_add_16be( vide, 0 ); // predefined; + bo_add_16be( vide, 0 ); // reserved; + for( i = 0; i < 3; i++ ) + { + bo_add_32be( vide, 0 ); // predefined; + } - bo_add_fourcc( hdlr, "mhlr" ); // media handler - if( p_stream->p_fmt->i_cat == AUDIO_ES ) - { - bo_add_fourcc( hdlr, "soun" ); - } - else - { - bo_add_fourcc( hdlr, "vide" ); - } + bo_add_16be( vide, p_stream->fmt.video.i_width ); // i_width + bo_add_16be( vide, p_stream->fmt.video.i_height ); // i_height - bo_add_32be( hdlr, 0 ); // reserved - bo_add_32be( hdlr, 0 ); // reserved - bo_add_32be( hdlr, 0 ); // reserved + bo_add_32be( vide, 0x00480000 ); // h 72dpi + bo_add_32be( vide, 0x00480000 ); // v 72dpi - if( p_stream->p_fmt->i_cat == AUDIO_ES ) - { - bo_add_8( hdlr, 13 ); - bo_add_mem( hdlr, 13, "SoundHandler" ); - } - else - { - bo_add_8( hdlr, 13 ); - bo_add_mem( hdlr, 13, "VideoHandler" ); - } + bo_add_32be( vide, 0 ); // data size, always 0 + bo_add_16be( vide, 1 ); // frames count per sample - box_fix( hdlr ); - box_gather( mdia, hdlr ); + // compressor name; + for( i = 0; i < 32; i++ ) + { + bo_add_8( vide, 0 ); + } - /* minf*/ - minf = box_new( "minf" ); + bo_add_16be( vide, 0x18 ); // depth + bo_add_16be( vide, 0xffff ); // predefined - /* add smhd|vmhd */ - if( p_stream->p_fmt->i_cat == AUDIO_ES ) + /* add an ES Descriptor */ + switch( p_stream->fmt.i_codec ) + { + case VLC_FOURCC('m','p','4','v'): + case VLC_FOURCC('m','p','g','v'): { - bo_t *smhd; - - smhd = box_full_new( "smhd", 0, 0 ); - bo_add_16be( smhd, 0 ); // balance - bo_add_16be( smhd, 0 ); // reserved - box_fix( smhd ); + bo_t *esds = GetESDS( p_stream ); - box_gather( minf, smhd ); + box_fix( esds ); + box_gather( vide, esds ); } - else if( p_stream->p_fmt->i_cat == VIDEO_ES ) - { - bo_t *vmhd; + break; - vmhd = box_full_new( "vmhd", 0, 1 ); - bo_add_16be( vmhd, 0 ); // graphicsmode - for( i = 0; i < 3; i++ ) - { - bo_add_16be( vmhd, 0 ); // opcolor - } - box_fix( vmhd ); + case VLC_FOURCC('H','2','6','3'): + { + bo_t *d263 = GetD263Tag( p_stream ); - box_gather( minf, vmhd ); + box_fix( d263 ); + box_gather( vide, d263 ); } + break; - /* dinf */ - dinf = box_new( "dinf" ); - dref = box_full_new( "dref", 0, 0 ); - bo_add_32be( dref, 1 ); - url = box_full_new( "url ", 0, 0x01 ); - box_fix( url ); - box_gather( dref, url ); - box_fix( dref ); - box_gather( dinf, dref ); - - /* append dinf to mdia */ - box_fix( dinf ); - box_gather( minf, dinf ); - - /* add stbl */ - stbl = box_new( "stbl" ); - stsd = box_full_new( "stsd", 0, 0 ); - bo_add_32be( stsd, 1 ); - - if( p_stream->p_fmt->i_cat == AUDIO_ES ) + case VLC_FOURCC('S','V','Q','3'): { - bo_t *soun; - char fcc[4] = " "; - int i; - vlc_bool_t b_mpeg4_hdr; - - switch( p_stream->p_fmt->i_codec ) - { - case VLC_FOURCC( 'm', 'p', '4', 'a' ): - memcpy( fcc, "mp4a", 4 ); - b_mpeg4_hdr = VLC_TRUE; - break; - - case VLC_FOURCC( 'm', 'p', 'g', 'a' ): - if( p_sys->b_mov ) - memcpy( fcc, ".mp3 ", 4 ); - else - memcpy( fcc, "mp4a", 4 ); - b_mpeg4_hdr = VLC_FALSE; - break; - - default: - memcpy( fcc, (char*)&p_stream->p_fmt->i_codec, 4 ); - b_mpeg4_hdr = VLC_FALSE; - break; - } - - soun = box_new( fcc ); - for( i = 0; i < 6; i++ ) - { - bo_add_8( soun, 0 ); // reserved; - } - bo_add_16be( soun, 1 ); // data-reference-index + bo_t *esds = GetSVQ3Tag( p_stream ); - /* SoundDescription */ - if( p_sys->b_mov && - p_stream->p_fmt->i_codec == VLC_FOURCC( 'm', 'p', '4', 'a' ) ) - { - bo_add_16be( soun, 1 ); // version 1; - } - else - { - bo_add_16be( soun, 0 ); // version 0; - } - bo_add_16be( soun, 0 ); // revision level (0) - bo_add_32be( soun, 0 ); // vendor - bo_add_16be( soun, p_stream->p_fmt->audio.i_channels ); // channel-count - // sample size - bo_add_16be( soun, p_stream->p_fmt->audio.i_bitspersample ? - p_stream->p_fmt->audio.i_bitspersample : 16 ); - bo_add_16be( soun, -2 ); // compression id - bo_add_16be( soun, 0 ); // packet size (0) - bo_add_16be( soun, p_stream->p_fmt->audio.i_rate ); // sampleratehi - bo_add_16be( soun, 0 ); // sampleratelo - - /* Extended data for SoundDescription V1 */ - if( p_sys->b_mov && - p_stream->p_fmt->i_codec == VLC_FOURCC( 'm', 'p', '4', 'a' ) ) - { - bo_add_32be( soun, p_stream->p_fmt->audio.i_frame_length ); /* samples per packet */ - bo_add_32be( soun, 1536 ); /* bytes per packet */ - bo_add_32be( soun, 2 ); /* bytes per frame */ - /* bytes per sample */ - bo_add_32be( soun, 2 /*p_stream->p_fmt->audio.i_bitspersample/8 */); - } - - /* add an ES Descriptor */ - if( b_mpeg4_hdr ) - { - bo_t *box; + box_fix( esds ); + box_gather( vide, esds ); + } + break; - if( p_sys->b_mov && - p_stream->p_fmt->i_codec == VLC_FOURCC('m','p','4','a') ) - { - box = GetWaveTag( p_stream ); - } - else - { - box = GetESDS( p_stream ); - } - box_fix( box ); - box_gather( soun, box ); - } + case VLC_FOURCC('h','2','6','4'): + box_gather( vide, GetAvcCTag( p_stream ) ); + break; - box_fix( soun ); - box_gather( stsd, soun ); - } - else if( p_stream->p_fmt->i_cat == VIDEO_ES ) - { - bo_t *vide; - char fcc[4] = " "; - int i; + default: + break; + } - switch( p_stream->p_fmt->i_codec ) - { - case VLC_FOURCC( 'm', 'p', '4', 'v' ): - case VLC_FOURCC( 'm', 'p', 'g', 'v' ): - memcpy( fcc, "mp4v", 4 ); - break; + box_fix( vide ); - case VLC_FOURCC( 'M', 'J', 'P', 'G' ): - memcpy( fcc, "mjpa", 4 ); - break; + return vide; +} - case VLC_FOURCC( 'S', 'V', 'Q', '3' ): - memcpy( fcc, "SVQ3", 4 ); - break; +static bo_t *GetTextBox( sout_mux_t *p_mux, mp4_stream_t *p_stream ) +{ - default: - memcpy( fcc, (char*)&p_stream->p_fmt->i_codec, 4 ); - break; - } + bo_t *text = box_new( "text" ); + int i; - vide = box_new( fcc ); - for( i = 0; i < 6; i++ ) - { - bo_add_8( vide, 0 ); // reserved; - } - bo_add_16be( vide, 1 ); // data-reference-index + for( i = 0; i < 6; i++ ) + { + bo_add_8( text, 0 ); // reserved; + } + bo_add_16be( text, 1 ); // data-reference-index - bo_add_16be( vide, 0 ); // predefined; - bo_add_16be( vide, 0 ); // reserved; - for( i = 0; i < 3; i++ ) - { - bo_add_32be( vide, 0 ); // predefined; - } + bo_add_32be( text, 0 ); // display flags + bo_add_32be( text, 0 ); // justification + for( i = 0; i < 3; i++ ) + { + bo_add_16be( text, 0 ); // back ground color + } - bo_add_16be( vide, p_stream->p_fmt->video.i_width ); // i_width - bo_add_16be( vide, p_stream->p_fmt->video.i_height ); // i_height + bo_add_16be( text, 0 ); // box text + bo_add_16be( text, 0 ); // box text + bo_add_16be( text, 0 ); // box text + bo_add_16be( text, 0 ); // box text - bo_add_32be( vide, 0x00480000 ); // h 72dpi - bo_add_32be( vide, 0x00480000 ); // v 72dpi + bo_add_64be( text, 0 ); // reserved + for( i = 0; i < 3; i++ ) + { + bo_add_16be( text, 0xff ); // foreground color + } - bo_add_32be( vide, 0 ); // data size, always 0 - bo_add_16be( vide, 1 ); // frames count per sample + bo_add_8 ( text, 9 ); + bo_add_mem( text, 9, (uint8_t*)"Helvetica" ); - // compressor name; - for( i = 0; i < 32; i++ ) - { - bo_add_8( vide, 0 ); - } + box_fix( text ); - bo_add_16be( vide, 0x18 ); // depth - bo_add_16be( vide, 0xffff ); // predefined + return text; +} - /* add an ES Descriptor */ - switch( p_stream->p_fmt->i_codec ) - { - case VLC_FOURCC( 'm', 'p', '4', 'v' ): - case VLC_FOURCC( 'm', 'p', 'g', 'v' ): - { - bo_t *esds = GetESDS( p_stream ); +static bo_t *GetStblBox( sout_mux_t *p_mux, mp4_stream_t *p_stream ) +{ + sout_mux_sys_t *p_sys = p_mux->p_sys; + unsigned int i_chunk, i_stsc_last_val, i_stsc_entries, i, i_index; + bo_t *stbl, *stsd, *stts, *stco, *stsc, *stsz, *stss; + uint32_t i_timescale; + int64_t i_dts, i_dts_q; - box_fix( esds ); - box_gather( vide, esds ); - } - break; + stbl = box_new( "stbl" ); - case VLC_FOURCC( 'S', 'V', 'Q', '3' ): - { - bo_t *esds = GetSVQ3Tag( p_stream ); + /* sample description */ + stsd = box_full_new( "stsd", 0, 0 ); + bo_add_32be( stsd, 1 ); + if( p_stream->fmt.i_cat == AUDIO_ES ) + { + bo_t *soun = GetSounBox( p_mux, p_stream ); + box_gather( stsd, soun ); + } + else if( p_stream->fmt.i_cat == VIDEO_ES ) + { + bo_t *vide = GetVideBox( p_mux, p_stream ); + box_gather( stsd, vide ); + } + else if( p_stream->fmt.i_cat == SPU_ES ) + { + box_gather( stsd, GetTextBox( p_mux, p_stream ) ); + } + box_fix( stsd ); - box_fix( esds ); - box_gather( vide, esds ); - } - break; + /* chunk offset table */ + if( p_sys->i_pos >= (((uint64_t)0x1) << 32) ) + { + /* 64 bits version */ + p_stream->b_stco64 = VLC_TRUE; + stco = box_full_new( "co64", 0, 0 ); + } + else + { + /* 32 bits version */ + p_stream->b_stco64 = VLC_FALSE; + stco = box_full_new( "stco", 0, 0 ); + } + bo_add_32be( stco, 0 ); // entry-count (fixed latter) - default: - break; - } + /* sample to chunk table */ + stsc = box_full_new( "stsc", 0, 0 ); + bo_add_32be( stsc, 0 ); // entry-count (fixed latter) - box_fix( vide ); - box_gather( stsd, vide ); - } + for( i_chunk = 0, i_stsc_last_val = 0, i_stsc_entries = 0, i = 0; + i < p_stream->i_entry_count; i_chunk++ ) + { + int i_first = i; - /* append stsd to stbl */ - box_fix( stsd ); - box_gather( stbl, stsd ); + if( p_stream->b_stco64 ) + bo_add_64be( stco, p_stream->entry[i].i_pos ); + else + bo_add_32be( stco, p_stream->entry[i].i_pos ); - /* we will create chunk table and stsc table - * FIXME optim stsc table FIXME */ - i_chunk_count = 0; - for( i = 0; i < p_stream->i_entry_count; ) + while( i < p_stream->i_entry_count ) { - while( i < p_stream->i_entry_count ) + if( i + 1 < p_stream->i_entry_count && + p_stream->entry[i].i_pos + p_stream->entry[i].i_size + != p_stream->entry[i + 1].i_pos ) { - if( i + 1 < p_stream->i_entry_count && - p_stream->entry[i].i_pos + - p_stream->entry[i].i_size != p_stream->entry[i + 1].i_pos ) - { - i++; - break; - } - i++; + break; } - i_chunk_count++; - } - /* chunk offset table */ - p_stream->i_stco_pos = stbl->i_buffer + 16; - if( p_sys->i_pos >= (((uint64_t)0x1) << 32) ) - { - /* 64 bits version */ - msg_Dbg( p_mux, "creating %d chunk (co64)", i_chunk_count ); - p_stream->b_stco64 = VLC_TRUE; - stco = box_full_new( "co64", 0, 0 ); - } - else - { - /* 32 bits version */ - msg_Dbg( p_mux, "creating %d chunk (stco)", i_chunk_count ); - p_stream->b_stco64 = VLC_FALSE; - stco = box_full_new( "stco", 0, 0 ); + i++; } - bo_add_32be( stco, i_chunk_count ); - - stsc = box_full_new( "stsc", 0, 0 ); - bo_add_32be( stsc, i_chunk_count ); // entry-count - for( i_chunk = 0, i = 0; i < p_stream->i_entry_count; i_chunk++ ) + /* Add entry to the stsc table */ + if( i_stsc_last_val != i - i_first ) { - int i_first; - - if( p_stream->b_stco64 ) - bo_add_64be( stco, p_stream->entry[i].i_pos ); - else - bo_add_32be( stco, p_stream->entry[i].i_pos ); - - i_first = i; - - while( i < p_stream->i_entry_count ) - { - if( i + 1 < p_stream->i_entry_count && - p_stream->entry[i].i_pos + p_stream->entry[i].i_size - != p_stream->entry[i + 1].i_pos ) - { - i++; - break; - } - - i++; - } bo_add_32be( stsc, 1 + i_chunk ); // first-chunk bo_add_32be( stsc, i - i_first ) ; // samples-per-chunk bo_add_32be( stsc, 1 ); // sample-descr-index + i_stsc_last_val = i - i_first; + i_stsc_entries++; } + } - /* append stco to stbl */ - box_fix( stco ); - box_gather( stbl, stco ); - - /* append stsc to stbl */ - box_fix( stsc ); - box_gather( stbl, stsc ); + /* Fix stco entry count */ + bo_fix_32be( stco, 12, i_chunk ); + msg_Dbg( p_mux, "created %d chunks (stco)", i_chunk ); + box_fix( stco ); - /* add stts */ - stts = box_full_new( "stts", 0, 0 ); - bo_add_32be( stts, 0 ); // fixed latter - for( i = 0, i_index = 0; i < p_stream->i_entry_count; i_index++) - { - int64_t i_delta; - int i_first; + /* Fix stsc entry count */ + bo_fix_32be( stsc, 12, i_stsc_entries ); + box_fix( stsc ); - i_first = i; - i_delta = p_stream->entry[i].i_length; + /* add stts */ + stts = box_full_new( "stts", 0, 0 ); + bo_add_32be( stts, 0 ); // entry-count (fixed latter) - while( i < p_stream->i_entry_count ) - { - if( i + 1 < p_stream->i_entry_count && - p_stream->entry[i + 1].i_length != i_delta ) - { - i++; - break; - } + if( p_stream->fmt.i_cat == AUDIO_ES ) + i_timescale = p_stream->fmt.audio.i_rate; + else + i_timescale = 1001; - i++; - } + /* first, create quantified length */ + for( i = 0, i_dts = 0, i_dts_q = 0; i < p_stream->i_entry_count; i++ ) + { + int64_t i_dts_deq = i_dts_q * I64C(1000000) / (int64_t)i_timescale; + int64_t i_delta = p_stream->entry[i].i_length + i_dts - i_dts_deq; - bo_add_32be( stts, i - i_first ); // sample-count - bo_add_32be( stts, i_delta * (int64_t)i_timescale / - (int64_t)1000000 ); // sample-delta - } - bo_fix_32be( stts, 12, i_index ); + i_dts += p_stream->entry[i].i_length; - /* append stts to stbl */ - box_fix( stts ); - box_gather( stbl, stts ); + p_stream->entry[i].i_length = + i_delta * (int64_t)i_timescale / I64C(1000000); - /* FIXME add ctts ?? FIXME */ + i_dts_q += p_stream->entry[i].i_length; + } + /* then write encoded table */ + for( i = 0, i_index = 0; i < p_stream->i_entry_count; i_index++) + { + int i_first = i; + int64_t i_delta = p_stream->entry[i].i_length; - stsz = box_full_new( "stsz", 0, 0 ); - bo_add_32be( stsz, 0 ); // sample-size - bo_add_32be( stsz, p_stream->i_entry_count ); // sample-count - for( i = 0; i < p_stream->i_entry_count; i++ ) + while( i < p_stream->i_entry_count ) { - bo_add_32be( stsz, p_stream->entry[i].i_size ); // sample-size + i++; + if( i >= p_stream->i_entry_count || + p_stream->entry[i].i_length != i_delta ) + { + break; + } } - /* append stsz to stbl */ - box_fix( stsz ); - box_gather( stbl, stsz ); - /* append stbl to minf */ - box_fix( stbl ); - p_stream->i_stco_pos += minf->i_buffer; - box_gather( minf, stbl ); + bo_add_32be( stts, i - i_first ); // sample-count + bo_add_32be( stts, i_delta ); // sample-delta + } + bo_fix_32be( stts, 12, i_index ); + box_fix( stts ); - /* append minf to mdia */ - box_fix( minf ); - p_stream->i_stco_pos += mdia->i_buffer; - box_gather( mdia, minf ); + /* FIXME add ctts ?? FIXME */ - /* append mdia to trak */ - box_fix( mdia ); - p_stream->i_stco_pos += trak->i_buffer; - box_gather( trak, mdia ); + stsz = box_full_new( "stsz", 0, 0 ); + bo_add_32be( stsz, 0 ); // sample-size + bo_add_32be( stsz, p_stream->i_entry_count ); // sample-count + for( i = 0; i < p_stream->i_entry_count; i++ ) + { + bo_add_32be( stsz, p_stream->entry[i].i_size ); // sample-size + } + box_fix( stsz ); - /* append trak to moov */ - box_fix( trak ); - p_stream->i_stco_pos += moov->i_buffer; - box_gather( moov, trak ); + /* create stss table */ + stss = NULL; + for( i = 0, i_index = 0; i < p_stream->i_entry_count; i++ ) + { + if( p_stream->entry[i].i_flags & BLOCK_FLAG_TYPE_I ) + { + if( stss == NULL ) + { + stss = box_full_new( "stss", 0, 0 ); + bo_add_32be( stss, 0 ); /* fixed later */ + } + bo_add_32be( stss, 1 + i ); + i_index++; + } + } + if( stss ) + { + bo_fix_32be( stss, 12, i_index ); + box_fix( stss ); } - /* Add user data tags */ - box_gather( moov, GetUdtaTag( p_mux ) ); + /* Now gather all boxes into stbl */ + box_gather( stbl, stsd ); + box_gather( stbl, stts ); + if( stss ) + { + box_gather( stbl, stss ); + } + box_gather( stbl, stsc ); + box_gather( stbl, stsz ); + p_stream->i_stco_pos = stbl->i_buffer + 16; + box_gather( stbl, stco ); - box_fix( moov ); - return moov; + /* finish stbl */ + box_fix( stbl ); + + return stbl; } -/***************************************************************************** - * Close: - *****************************************************************************/ -static void Close( vlc_object_t * p_this ) +static int64_t get_timestamp(void); + +static uint32_t mvhd_matrix[9] = + { 0x10000, 0, 0, 0, 0x10000, 0, 0, 0, 0x40000000 }; + +static bo_t *GetMoovBox( sout_mux_t *p_mux ) { - sout_mux_t *p_mux = (sout_mux_t*)p_this; - sout_mux_sys_t *p_sys = p_mux->p_sys; - sout_buffer_t *p_hdr; - bo_t bo, *moov; - vlc_value_t val; + sout_mux_sys_t *p_sys = p_mux->p_sys; - int i_trak; - uint64_t i_moov_pos; + bo_t *moov, *mvhd; + int i_trak, i; uint32_t i_movie_timescale = 90000; int64_t i_movie_duration = 0; - msg_Dbg( p_mux, "Close" ); + moov = box_new( "moov" ); /* Create general info */ for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ ) @@ -1028,291 +1554,383 @@ static void Close( vlc_object_t * p_this ) i_movie_duration = i_movie_duration * i_movie_timescale / 1000000; - /* Update mdat size */ - bo_init( &bo, 0, NULL, VLC_TRUE ); - if( p_sys->i_pos - p_sys->i_mdat_pos >= (((uint64_t)1)<<32) ) + /* *** add /moov/mvhd *** */ + if( !p_sys->b_64_ext ) { - /* Extended size */ - bo_add_32be ( &bo, 1 ); - bo_add_fourcc( &bo, "mdat" ); - bo_add_64be ( &bo, p_sys->i_pos - p_sys->i_mdat_pos ); + mvhd = box_full_new( "mvhd", 0, 0 ); + bo_add_32be( mvhd, get_timestamp() ); // creation time + bo_add_32be( mvhd, get_timestamp() ); // modification time + bo_add_32be( mvhd, i_movie_timescale); // timescale + bo_add_32be( mvhd, i_movie_duration ); // duration } else { - bo_add_32be ( &bo, 8 ); - bo_add_fourcc( &bo, "wide" ); - bo_add_32be ( &bo, p_sys->i_pos - p_sys->i_mdat_pos - 8 ); - bo_add_fourcc( &bo, "mdat" ); + mvhd = box_full_new( "mvhd", 1, 0 ); + bo_add_64be( mvhd, get_timestamp() ); // creation time + bo_add_64be( mvhd, get_timestamp() ); // modification time + bo_add_32be( mvhd, i_movie_timescale); // timescale + bo_add_64be( mvhd, i_movie_duration ); // duration + } + bo_add_32be( mvhd, 0x10000 ); // rate + bo_add_16be( mvhd, 0x100 ); // volume + bo_add_16be( mvhd, 0 ); // reserved + for( i = 0; i < 2; i++ ) + { + bo_add_32be( mvhd, 0 ); // reserved + } + for( i = 0; i < 9; i++ ) + { + bo_add_32be( mvhd, mvhd_matrix[i] );// matrix + } + for( i = 0; i < 6; i++ ) + { + bo_add_32be( mvhd, 0 ); // pre-defined } - p_hdr = bo_to_sout( p_mux->p_sout, &bo ); - free( bo.p_buffer ); - sout_AccessOutSeek( p_mux->p_access, p_sys->i_mdat_pos ); - sout_AccessOutWrite( p_mux->p_access, p_hdr ); + /* Next available track id */ + bo_add_32be( mvhd, p_sys->i_nb_streams + 1 ); // next-track-id - /* Create MOOV header */ - i_moov_pos = p_sys->i_pos; - moov = GetMoovTag( p_mux ); + box_fix( mvhd ); + box_gather( moov, mvhd ); - /* Check we need to create "fast start" files */ - var_Create( p_this, "mp4-faststart", VLC_VAR_BOOL | VLC_VAR_DOINHERIT ); - var_Get( p_this, "mp4-faststart", &val ); - p_sys->b_fast_start = val.b_bool; - while( p_sys->b_fast_start ) + for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ ) { - /* Move data to the end of the file so we can fit the moov header - * at the start */ - sout_buffer_t *p_buf; - int64_t i_chunk, i_size = p_sys->i_pos - p_sys->i_mdat_pos; - int i_moov_size = moov->i_buffer; + mp4_stream_t *p_stream; + uint32_t i_timescale; - while( i_size > 0 ) + bo_t *trak, *tkhd, *edts, *elst, *mdia, *mdhd, *hdlr; + bo_t *minf, *dinf, *dref, *url, *stbl; + + p_stream = p_sys->pp_streams[i_trak]; + + if( p_stream->fmt.i_cat == AUDIO_ES ) + i_timescale = p_stream->fmt.audio.i_rate; + else + i_timescale = 1001; + + /* *** add /moov/trak *** */ + trak = box_new( "trak" ); + + /* *** add /moov/trak/tkhd *** */ + if( !p_sys->b_64_ext ) { - i_chunk = __MIN( 32768, i_size ); - p_buf = sout_BufferNew( p_mux->p_sout, i_chunk ); - sout_AccessOutSeek( p_mux->p_access, - p_sys->i_mdat_pos + i_size - i_chunk ); - if( sout_AccessOutRead( p_mux->p_access, p_buf ) < i_chunk ) + if( p_sys->b_mov ) + tkhd = box_full_new( "tkhd", 0, 0x0f ); + else + tkhd = box_full_new( "tkhd", 0, 1 ); + + bo_add_32be( tkhd, get_timestamp() ); // creation time + bo_add_32be( tkhd, get_timestamp() ); // modification time + bo_add_32be( tkhd, p_stream->i_track_id ); + bo_add_32be( tkhd, 0 ); // reserved 0 + bo_add_32be( tkhd, p_stream->i_duration * + (int64_t)i_movie_timescale / + (mtime_t)1000000 ); // duration + } + else + { + if( p_sys->b_mov ) + tkhd = box_full_new( "tkhd", 1, 0x0f ); + else + tkhd = box_full_new( "tkhd", 1, 1 ); + + bo_add_64be( tkhd, get_timestamp() ); // creation time + bo_add_64be( tkhd, get_timestamp() ); // modification time + bo_add_32be( tkhd, p_stream->i_track_id ); + bo_add_32be( tkhd, 0 ); // reserved 0 + bo_add_64be( tkhd, p_stream->i_duration * + (int64_t)i_movie_timescale / + (mtime_t)1000000 ); // duration + } + + for( i = 0; i < 2; i++ ) + { + bo_add_32be( tkhd, 0 ); // reserved + } + bo_add_16be( tkhd, 0 ); // layer + bo_add_16be( tkhd, 0 ); // pre-defined + // volume + bo_add_16be( tkhd, p_stream->fmt.i_cat == AUDIO_ES ? 0x100 : 0 ); + bo_add_16be( tkhd, 0 ); // reserved + for( i = 0; i < 9; i++ ) + { + bo_add_32be( tkhd, mvhd_matrix[i] ); // matrix + } + if( p_stream->fmt.i_cat == AUDIO_ES ) + { + bo_add_32be( tkhd, 0 ); // width (presentation) + bo_add_32be( tkhd, 0 ); // height(presentation) + } + else if( p_stream->fmt.i_cat == VIDEO_ES ) + { + int i_width = p_stream->fmt.video.i_width << 16; + if( p_stream->fmt.video.i_aspect > 0 ) { - msg_Warn( p_this, "read() not supported by acces output, " - "won't create a fast start file" ); - p_sys->b_fast_start = VLC_FALSE; - break; + i_width = (int64_t)p_stream->fmt.video.i_aspect * + ((int64_t)p_stream->fmt.video.i_height << 16) / + VOUT_ASPECT_FACTOR; + } + // width (presentation) + bo_add_32be( tkhd, i_width ); + // height(presentation) + bo_add_32be( tkhd, p_stream->fmt.video.i_height << 16 ); + } + else + { + int i_width = 320 << 16; + int i_height = 200; + int i; + for( i = 0; i < p_sys->i_nb_streams; i++ ) + { + mp4_stream_t *tk = p_sys->pp_streams[i]; + if( tk->fmt.i_cat == VIDEO_ES ) + { + if( p_stream->fmt.video.i_aspect ) + i_width = (int64_t)p_stream->fmt.video.i_aspect * + ((int64_t)p_stream->fmt.video.i_height<<16) / VOUT_ASPECT_FACTOR; + else + i_width = p_stream->fmt.video.i_width << 16; + i_height = p_stream->fmt.video.i_height; + break; + } } - sout_AccessOutSeek( p_mux->p_access, p_sys->i_mdat_pos + i_size + - i_moov_size - i_chunk ); - sout_AccessOutWrite( p_mux->p_access, p_buf ); - i_size -= i_chunk; + bo_add_32be( tkhd, i_width ); // width (presentation) + bo_add_32be( tkhd, i_height << 16 ); // height(presentation) } - if( !p_sys->b_fast_start ) break; + box_fix( tkhd ); + box_gather( trak, tkhd ); - /* Fix-up samples to chunks table in MOOV header */ - for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ ) + /* *** add /moov/trak/edts and elst */ + edts = box_new( "edts" ); + elst = box_full_new( "elst", p_sys->b_64_ext ? 1 : 0, 0 ); + if( p_stream->i_dts_start > p_sys->i_dts_start ) { - mp4_stream_t *p_stream = p_sys->pp_streams[i_trak]; - unsigned int i; - int i_chunk; + bo_add_32be( elst, 2 ); - moov->i_buffer = p_stream->i_stco_pos; - for( i_chunk = 0, i = 0; i < p_stream->i_entry_count; i_chunk++ ) + if( p_sys->b_64_ext ) { - if( p_stream->b_stco64 ) - bo_add_64be( moov, p_stream->entry[i].i_pos + i_moov_size); - else - bo_add_32be( moov, p_stream->entry[i].i_pos + i_moov_size); - - while( i < p_stream->i_entry_count ) - { - if( i + 1 < p_stream->i_entry_count && - p_stream->entry[i].i_pos + p_stream->entry[i].i_size - != p_stream->entry[i + 1].i_pos ) - { - i++; - break; - } - - i++; - } + bo_add_64be( elst, (p_stream->i_dts_start-p_sys->i_dts_start) * + i_movie_timescale / I64C(1000000) ); + bo_add_64be( elst, -1 ); + } + else + { + bo_add_32be( elst, (p_stream->i_dts_start-p_sys->i_dts_start) * + i_movie_timescale / I64C(1000000) ); + bo_add_32be( elst, -1 ); } + bo_add_16be( elst, 1 ); + bo_add_16be( elst, 0 ); } + else + { + bo_add_32be( elst, 1 ); + } + if( p_sys->b_64_ext ) + { + bo_add_64be( elst, p_stream->i_duration * + i_movie_timescale / I64C(1000000) ); + bo_add_64be( elst, 0 ); + } + else + { + bo_add_32be( elst, p_stream->i_duration * + i_movie_timescale / I64C(1000000) ); + bo_add_32be( elst, 0 ); + } + bo_add_16be( elst, 1 ); + bo_add_16be( elst, 0 ); - moov->i_buffer = i_moov_size; - i_moov_pos = p_sys->i_mdat_pos; - p_sys->b_fast_start = VLC_FALSE; - } - - /* Write MOOV header */ - sout_AccessOutSeek( p_mux->p_access, i_moov_pos ); - box_send( p_mux, moov ); + box_fix( elst ); + box_gather( edts, elst ); + box_fix( edts ); + box_gather( trak, edts ); - /* Clean-up */ - for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ ) - { - mp4_stream_t *p_stream = p_sys->pp_streams[i_trak]; + /* *** add /moov/trak/mdia *** */ + mdia = box_new( "mdia" ); - if( p_stream->p_fmt->p_extra ) + /* media header */ + if( !p_sys->b_64_ext ) + { + mdhd = box_full_new( "mdhd", 0, 0 ); + bo_add_32be( mdhd, get_timestamp() ); // creation time + bo_add_32be( mdhd, get_timestamp() ); // modification time + bo_add_32be( mdhd, i_timescale); // timescale + bo_add_32be( mdhd, p_stream->i_duration * (int64_t)i_timescale / + (mtime_t)1000000 ); // duration + } + else { - free( p_stream->p_fmt->p_extra ); + mdhd = box_full_new( "mdhd", 1, 0 ); + bo_add_64be( mdhd, get_timestamp() ); // creation time + bo_add_64be( mdhd, get_timestamp() ); // modification time + bo_add_32be( mdhd, i_timescale); // timescale + bo_add_64be( mdhd, p_stream->i_duration * (int64_t)i_timescale / + (mtime_t)1000000 ); // duration } - free( p_stream->p_fmt ); - free( p_stream->entry ); - free( p_stream ); - } - free( p_sys ); -} -static int Capability( sout_mux_t *p_mux, int i_query, void *p_args, - void *p_answer ) -{ - 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 ); - default: - return( SOUT_MUX_CAP_ERR_UNIMPLEMENTED ); - } -} + if( p_stream->fmt.psz_language ) + { + char *psz = p_stream->fmt.psz_language; + const iso639_lang_t *pl = NULL; + uint16_t lang = 0x0; -static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input ) -{ - sout_mux_sys_t *p_sys = p_mux->p_sys; - mp4_stream_t *p_stream; + if( strlen( psz ) == 2 ) + { + pl = GetLang_1( psz ); + } + else if( strlen( psz ) == 3 ) + { + pl = GetLang_2B( psz ); + if( !strcmp( pl->psz_iso639_1, "??" ) ) + { + pl = GetLang_2T( psz ); + } + } + if( pl && strcmp( pl->psz_iso639_1, "??" ) ) + { + lang = ( ( pl->psz_iso639_2T[0] - 0x60 ) << 10 ) | + ( ( pl->psz_iso639_2T[1] - 0x60 ) << 5 ) | + ( ( pl->psz_iso639_2T[2] - 0x60 ) ); + } + bo_add_16be( mdhd, lang ); // language + } + else + { + bo_add_16be( mdhd, 0 ); // language + } + bo_add_16be( mdhd, 0 ); // predefined + box_fix( mdhd ); + box_gather( mdia, mdhd ); - switch( p_input->p_fmt->i_codec ) - { - case VLC_FOURCC( 'm', 'p', '4', 'a' ): - case VLC_FOURCC( 'm', 'p', '4', 'v' ): - case VLC_FOURCC( 'm', 'p', 'g', 'a' ): - case VLC_FOURCC( 'm', 'p', 'g', 'v' ): - case VLC_FOURCC( 'M', 'J', 'P', 'G' ): - case VLC_FOURCC( 'm', 'j', 'p', 'b' ): - case VLC_FOURCC( 'S', 'V', 'Q', '3' ): - break; - default: - msg_Err( p_mux, "unsupported codec %4.4s in mp4", - (char*)&p_input->p_fmt->i_codec ); - return VLC_EGENERIC; - } + /* handler reference */ + hdlr = box_full_new( "hdlr", 0, 0 ); - p_stream = malloc( sizeof( mp4_stream_t ) ); - p_stream->p_fmt = malloc( sizeof( es_format_t ) ); - memcpy( p_stream->p_fmt, p_input->p_fmt, sizeof( es_format_t ) ); - if( p_stream->p_fmt->i_extra ) - { - p_stream->p_fmt->p_extra = - malloc( p_stream->p_fmt->i_extra ); - memcpy( p_stream->p_fmt->p_extra, - p_input->p_fmt->p_extra, - p_input->p_fmt->i_extra ); - } - p_stream->i_track_id = p_sys->i_nb_streams + 1; - p_stream->i_entry_count = 0; - p_stream->i_entry_max = 1000; - p_stream->entry = - calloc( p_stream->i_entry_max, sizeof( mp4_entry_t ) ); - p_stream->i_duration = 0; + if( p_sys->b_mov ) + bo_add_fourcc( hdlr, "mhlr" ); // media handler + else + bo_add_32be( hdlr, 0 ); - p_input->p_sys = p_stream; + if( p_stream->fmt.i_cat == AUDIO_ES ) + bo_add_fourcc( hdlr, "soun" ); + else if( p_stream->fmt.i_cat == VIDEO_ES ) + bo_add_fourcc( hdlr, "vide" ); + else if( p_stream->fmt.i_cat == SPU_ES ) + bo_add_fourcc( hdlr, "text" ); - msg_Dbg( p_mux, "adding input" ); + bo_add_32be( hdlr, 0 ); // reserved + bo_add_32be( hdlr, 0 ); // reserved + bo_add_32be( hdlr, 0 ); // reserved - TAB_APPEND( p_sys->i_nb_streams, p_sys->pp_streams, p_stream ); - return( VLC_SUCCESS ); -} + if( p_sys->b_mov ) + bo_add_8( hdlr, 12 ); /* Pascal string for .mov */ -static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input ) -{ - msg_Dbg( p_mux, "removing input" ); - return( 0 ); -} + if( p_stream->fmt.i_cat == AUDIO_ES ) + bo_add_mem( hdlr, 12, (uint8_t*)"SoundHandler" ); + else if( p_stream->fmt.i_cat == VIDEO_ES ) + bo_add_mem( hdlr, 12, (uint8_t*)"VideoHandler" ); + else + bo_add_mem( hdlr, 12, (uint8_t*)"Text Handler" ); -/****************************************************************************/ + if( !p_sys->b_mov ) + bo_add_8( hdlr, 0 ); /* asciiz string for .mp4, yes that's BRAIN DAMAGED F**K MP4 */ -static int MuxGetStream( sout_mux_t *p_mux, int *pi_stream, mtime_t *pi_dts ) -{ - mtime_t i_dts; - int i_stream; - int i; + box_fix( hdlr ); + box_gather( mdia, hdlr ); - for( i = 0, i_dts = 0, i_stream = -1; i < p_mux->i_nb_inputs; i++ ) - { - sout_fifo_t *p_fifo; + /* minf*/ + minf = box_new( "minf" ); + + /* add smhd|vmhd */ + if( p_stream->fmt.i_cat == AUDIO_ES ) + { + bo_t *smhd; - p_fifo = p_mux->pp_inputs[i]->p_fifo; + smhd = box_full_new( "smhd", 0, 0 ); + bo_add_16be( smhd, 0 ); // balance + bo_add_16be( smhd, 0 ); // reserved + box_fix( smhd ); - if( p_fifo->i_depth > 1 ) + box_gather( minf, smhd ); + } + else if( p_stream->fmt.i_cat == VIDEO_ES ) { - sout_buffer_t *p_buf; + bo_t *vmhd; - p_buf = sout_FifoShow( p_fifo ); - if( i_stream < 0 || p_buf->i_dts < i_dts ) + vmhd = box_full_new( "vmhd", 0, 1 ); + bo_add_16be( vmhd, 0 ); // graphicsmode + for( i = 0; i < 3; i++ ) { - i_dts = p_buf->i_dts; - i_stream = i; + bo_add_16be( vmhd, 0 ); // opcolor } + box_fix( vmhd ); + + box_gather( minf, vmhd ); } - else + else if( p_stream->fmt.i_cat == SPU_ES ) { - return( -1 ); // wait that all fifo have at least 2 packets - } - } - if( pi_stream ) - { - *pi_stream = i_stream; - } - if( pi_dts ) - { - *pi_dts = i_dts; - } - return( i_stream ); -} + bo_t *gmhd = box_new( "gmhd" ); + bo_t *gmin = box_full_new( "gmin", 0, 1 ); -static int Mux( sout_mux_t *p_mux ) -{ - sout_mux_sys_t *p_sys = p_mux->p_sys; + bo_add_16be( gmin, 0 ); // graphicsmode + for( i = 0; i < 3; i++ ) + { + bo_add_16be( gmin, 0 ); // opcolor + } + bo_add_16be( gmin, 0 ); // balance + bo_add_16be( gmin, 0 ); // reserved + box_fix( gmin ); - for( ;; ) - { - sout_input_t *p_input; - int i_stream; - mp4_stream_t *p_stream; - sout_buffer_t *p_data; - mtime_t i_dts; + box_gather( gmhd, gmin ); + box_fix( gmhd ); - if( MuxGetStream( p_mux, &i_stream, &i_dts) < 0 ) - { - return( VLC_SUCCESS ); + box_gather( minf, gmhd ); } - if( !p_sys->i_start_dts ) - p_sys->i_start_dts = i_dts; - - p_input = p_mux->pp_inputs[i_stream]; - p_stream = (mp4_stream_t*)p_input->p_sys; + /* dinf */ + dinf = box_new( "dinf" ); + dref = box_full_new( "dref", 0, 0 ); + bo_add_32be( dref, 1 ); + url = box_full_new( "url ", 0, 0x01 ); + box_fix( url ); + box_gather( dref, url ); + box_fix( dref ); + box_gather( dinf, dref ); - p_data = sout_FifoGet( p_input->p_fifo ); - //msg_Dbg( p_mux, "stream=%d size=%6d pos=%8lld", i_stream, p_data->i_size, p_sys->i_pos ); + /* append dinf to mdia */ + box_fix( dinf ); + box_gather( minf, dinf ); - /* add index entry */ - p_stream->entry[p_stream->i_entry_count].i_pos = p_sys->i_pos; - p_stream->entry[p_stream->i_entry_count].i_size = p_data->i_size; - p_stream->entry[p_stream->i_entry_count].i_pts = p_data->i_pts; - p_stream->entry[p_stream->i_entry_count].i_dts = p_data->i_dts; - p_stream->entry[p_stream->i_entry_count].i_length= - __MAX( p_data->i_length, 0 ); + /* add stbl */ + stbl = GetStblBox( p_mux, p_stream ); - if( p_stream->i_entry_count == 0 ) - { - /* Here is another bad hack. - * To make sure audio/video are in sync, we report a corrected - * length for the 1st sample. */ - p_stream->entry[p_stream->i_entry_count].i_length = - __MAX( p_data->i_length, 0 ) + - p_data->i_pts - p_sys->i_start_dts; - } + /* append stbl to minf */ + p_stream->i_stco_pos += minf->i_buffer; + box_gather( minf, stbl ); - p_stream->i_entry_count++; - if( p_stream->i_entry_count >= p_stream->i_entry_max ) - { - p_stream->i_entry_max += 1000; - p_stream->entry = - realloc( p_stream->entry, - p_stream->i_entry_max * sizeof( mp4_entry_t ) ); - } + /* append minf to mdia */ + box_fix( minf ); + p_stream->i_stco_pos += mdia->i_buffer; + box_gather( mdia, minf ); - /* update */ - p_stream->i_duration += __MAX( p_data->i_length, 0 ); - p_sys->i_pos += p_data->i_size; + /* append mdia to trak */ + box_fix( mdia ); + p_stream->i_stco_pos += trak->i_buffer; + box_gather( trak, mdia ); - /* write data */ - sout_AccessOutWrite( p_mux->p_access, p_data ); + /* append trak to moov */ + box_fix( trak ); + p_stream->i_stco_pos += moov->i_buffer; + box_gather( moov, trak ); } - return( VLC_SUCCESS ); -} + /* Add user data tags */ + box_gather( moov, GetUdtaTag( p_mux ) ); + box_fix( moov ); + return moov; +} /****************************************************************************/ @@ -1383,7 +2001,7 @@ static void bo_add_64be( bo_t *p_bo, uint64_t i ) bo_add_32be( p_bo, i &0xffffffff ); } -static void bo_add_fourcc( bo_t *p_bo, char *fcc ) +static void bo_add_fourcc( bo_t *p_bo, const char *fcc ) { bo_add_8( p_bo, fcc[0] ); bo_add_8( p_bo, fcc[1] ); @@ -1409,9 +2027,9 @@ static void bo_add_descr( bo_t *p_bo, uint8_t tag, uint32_t i_size ) i_length = i_size; vals[3] = (unsigned char)(i_length & 0x7f); i_length >>= 7; - vals[2] = (unsigned char)((i_length & 0x7f) | 0x80); + vals[2] = (unsigned char)((i_length & 0x7f) | 0x80); i_length >>= 7; - vals[1] = (unsigned char)((i_length & 0x7f) | 0x80); + vals[1] = (unsigned char)((i_length & 0x7f) | 0x80); i_length >>= 7; vals[0] = (unsigned char)((i_length & 0x7f) | 0x80); @@ -1451,7 +2069,7 @@ static void bo_add_bo( bo_t *p_bo, bo_t *p_bo2 ) } } -static bo_t * box_new( char *fcc ) +static bo_t * box_new( const char *fcc ) { bo_t *box; @@ -1466,7 +2084,7 @@ static bo_t * box_new( char *fcc ) return box; } -static bo_t * box_full_new( char *fcc, uint8_t v, uint32_t f ) +static bo_t * box_full_new( const char *fcc, uint8_t v, uint32_t f ) { bo_t *box; @@ -1509,24 +2127,22 @@ static void box_gather ( bo_t *box, bo_t *box2 ) box_free( box2 ); } -static sout_buffer_t * bo_to_sout( sout_instance_t *p_sout, bo_t *box ) +static block_t * bo_to_sout( sout_instance_t *p_sout, bo_t *box ) { - sout_buffer_t *p_buf; + block_t *p_buf; - p_buf = sout_BufferNew( p_sout, box->i_buffer ); + p_buf = block_New( p_sout, box->i_buffer ); if( box->i_buffer > 0 ) { memcpy( p_buf->p_buffer, box->p_buffer, box->i_buffer ); } - p_buf->i_size = box->i_buffer; - return p_buf; } static void box_send( sout_mux_t *p_mux, bo_t *box ) { - sout_buffer_t *p_buf; + block_t *p_buf; p_buf = bo_to_sout( p_mux->p_sout, box ); box_free( box ); @@ -1534,7 +2150,7 @@ static void box_send( sout_mux_t *p_mux, bo_t *box ) sout_AccessOutWrite( p_mux->p_access, p_buf ); } -static int64_t get_timestamp() +static int64_t get_timestamp(void) { int64_t i_timestamp = 0;