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

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

midi

开发平台：

Unix_Linux

mp4.c：源码内容
  1. /*****************************************************************************
  2.  * mp4.c: mp4/mov muxer
  3.  *****************************************************************************
  4.  * Copyright (C) 2001, 2002, 2003, 2006 the VideoLAN team
  5.  * $Id: 3001fbd8659bab3e7ec1b551b91cb5e314ebcdef $
  6.  *
  7.  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
  8.  *          Gildas Bazin <gbazin at videolan dot 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>
  38. #include <time.h>
  40. #include <vlc_iso_lang.h>
  41. #include "vlc_meta.h"
  43. /*****************************************************************************
  44.  * Module descriptor
  45.  *****************************************************************************/
  46. #define FASTSTART_TEXT N_("Create "Fast Start" files")
  47. #define FASTSTART_LONGTEXT N_( 
  48.     "Create "Fast Start" files. " 
  49.     ""Fast Start" files are optimized for downloads and allow the user " 
  50.     "to start previewing the file while it is downloading.")
  52. static int  Open   ( vlc_object_t * );
  53. static void Close  ( vlc_object_t * );
  55. #define SOUT_CFG_PREFIX "sout-mp4-"
  57. vlc_module_begin ()
  58.     set_description( N_("MP4/MOV muxer") )
  59.     set_category( CAT_SOUT )
  60.     set_subcategory( SUBCAT_SOUT_MUX )
  61.     set_shortname( "MP4" )
  63.     add_bool( SOUT_CFG_PREFIX "faststart", 1, NULL,
  64.               FASTSTART_TEXT, FASTSTART_LONGTEXT,
  65.               true )
  66.     set_capability( "sout mux", 5 )
  67.     add_shortcut( "mp4" )
  68.     add_shortcut( "mov" )
  69.     add_shortcut( "3gp" )
  70.     set_callbacks( Open, Close )
  71. vlc_module_end ()
  73. /*****************************************************************************
  74.  * Exported prototypes
  75.  *****************************************************************************/
  76. static const char *const ppsz_sout_options[] = {
  77.     "faststart", NULL
  78. };
  80. static int Control( sout_mux_t *, int, va_list );
  81. static int AddStream( sout_mux_t *, sout_input_t * );
  82. static int DelStream( sout_mux_t *, sout_input_t * );
  83. static int Mux      ( sout_mux_t * );
  85. /*****************************************************************************
  86.  * Local prototypes
  87.  *****************************************************************************/
  88. typedef struct
  89. {
  90.     uint64_t i_pos;
  91.     int      i_size;
  93.     mtime_t  i_pts_dts;
  94.     mtime_t  i_length;
  95.     unsigned int i_flags;
  97. } mp4_entry_t;
  99. typedef struct
  100. {
  101.     es_format_t   fmt;
  102.     int           i_track_id;
  104.     /* index */
  105.     unsigned int i_entry_count;
  106.     unsigned int i_entry_max;
  107.     mp4_entry_t  *entry;
  108.     int64_t      i_length_neg;
  110.     /* stats */
  111.     int64_t      i_dts_start;
  112.     int64_t      i_duration;
  114.     /* for later stco fix-up (fast start files) */
  115.     uint64_t i_stco_pos;
  116.     bool b_stco64;
  118.     /* for spu */
  119.     int64_t i_last_dts;
  121. } mp4_stream_t;
  123. struct sout_mux_sys_t
  124. {
  125.     bool b_mov;
  126.     bool b_3gp;
  127.     bool b_64_ext;
  128.     bool b_fast_start;
  130.     uint64_t i_mdat_pos;
  131.     uint64_t i_pos;
  133.     int64_t  i_dts_start;
  135.     int          i_nb_streams;
  136.     mp4_stream_t **pp_streams;
  137. };
  139. typedef struct bo_t
  140. {
  141.     bool b_grow;
  143.     int        i_buffer_size;
  144.     int        i_buffer;
  145.     uint8_t    *p_buffer;
  147. } bo_t;
  149. static void bo_init     ( bo_t *, int , uint8_t *, bool  );
  150. static void bo_add_8    ( bo_t *, uint8_t );
  151. static void bo_add_16be ( bo_t *, uint16_t );
  152. static void bo_add_24be ( bo_t *, uint32_t );
  153. static void bo_add_32be ( bo_t *, uint32_t );
  154. static void bo_add_64be ( bo_t *, uint64_t );
  155. static void bo_add_fourcc(bo_t *, const char * );
  156. static void bo_add_bo   ( bo_t *, bo_t * );
  157. static void bo_add_mem  ( bo_t *, int , uint8_t * );
  158. static void bo_add_descr( bo_t *, uint8_t , uint32_t );
  160. static void bo_fix_32be ( bo_t *, int , uint32_t );
  162. static bo_t *box_new     ( const char *fcc );
  163. static bo_t *box_full_new( const char *fcc, uint8_t v, uint32_t f );
  164. static void  box_fix     ( bo_t *box );
  165. static void  box_free    ( bo_t *box );
  166. static void  box_gather  ( bo_t *box, bo_t *box2 );
  168. static void box_send( sout_mux_t *p_mux,  bo_t *box );
  170. static block_t *bo_to_sout( sout_instance_t *p_sout,  bo_t *box );
  172. static bo_t *GetMoovBox( sout_mux_t *p_mux );
  174. static block_t *ConvertSUBT( block_t *);
  175. static block_t *ConvertAVC1( block_t * );
  177. /*****************************************************************************
  178.  * Open:
  179.  *****************************************************************************/
  180. static int Open( vlc_object_t *p_this )
  181. {
  182.     sout_mux_t      *p_mux = (sout_mux_t*)p_this;
  183.     sout_mux_sys_t  *p_sys;
  184.     bo_t            *box;
  186.     msg_Dbg( p_mux, "Mp4 muxer opened" );
  187.     config_ChainParse( p_mux, SOUT_CFG_PREFIX, ppsz_sout_options, p_mux->p_cfg );
  189.     p_mux->pf_control   = Control;
  190.     p_mux->pf_addstream = AddStream;
  191.     p_mux->pf_delstream = DelStream;
  192.     p_mux->pf_mux       = Mux;
  193.     p_mux->p_sys        = p_sys = malloc( sizeof( sout_mux_sys_t ) );
  194.     if( !p_sys )
  195.         return VLC_ENOMEM;
  196.     p_sys->i_pos        = 0;
  197.     p_sys->i_nb_streams = 0;
  198.     p_sys->pp_streams   = NULL;
  199.     p_sys->i_mdat_pos   = 0;
  200.     p_sys->b_mov        = p_mux->psz_mux && !strcmp( p_mux->psz_mux, "mov" );
  201.     p_sys->b_3gp        = p_mux->psz_mux && !strcmp( p_mux->psz_mux, "3gp" );
  202.     p_sys->i_dts_start  = 0;
  205.     if( !p_sys->b_mov )
  206.     {
  207.         /* Now add ftyp header */
  208.         box = box_new( "ftyp" );
  209.         if( p_sys->b_3gp ) bo_add_fourcc( box, "3gp4" );
  210.         else bo_add_fourcc( box, "isom" );
  211.         bo_add_32be  ( box, 0 );
  212.         if( p_sys->b_3gp ) bo_add_fourcc( box, "3gp4" );
  213.         else bo_add_fourcc( box, "mp41" );
  214.         box_fix( box );
  216.         p_sys->i_pos += box->i_buffer;
  217.         p_sys->i_mdat_pos = p_sys->i_pos;
  219.         box_send( p_mux, box );
  220.     }
  222.     /* FIXME FIXME
  223.      * Quicktime actually doesn't like the 64 bits extensions !!! */
  224.     p_sys->b_64_ext = false;
  226.     /* Now add mdat header */
  227.     box = box_new( "mdat" );
  228.     bo_add_64be  ( box, 0 ); // enough to store an extended size
  230.     p_sys->i_pos += box->i_buffer;
  232.     box_send( p_mux, box );
  234.     return VLC_SUCCESS;
  235. }
  237. /*****************************************************************************
  238.  * Close:
  239.  *****************************************************************************/
  240. static void Close( vlc_object_t * p_this )
  241. {
  242.     sout_mux_t      *p_mux = (sout_mux_t*)p_this;
  243.     sout_mux_sys_t  *p_sys = p_mux->p_sys;
  244.     block_t   *p_hdr;
  245.     bo_t            bo, *moov;
  246.     vlc_value_t     val;
  248.     int             i_trak;
  249.     uint64_t        i_moov_pos;
  251.     msg_Dbg( p_mux, "Close" );
  253.     /* Update mdat size */
  254.     bo_init( &bo, 0, NULL, true );
  255.     if( p_sys->i_pos - p_sys->i_mdat_pos >= (((uint64_t)1)<<32) )
  256.     {
  257.         /* Extended size */
  258.         bo_add_32be  ( &bo, 1 );
  259.         bo_add_fourcc( &bo, "mdat" );
  260.         bo_add_64be  ( &bo, p_sys->i_pos - p_sys->i_mdat_pos );
  261.     }
  262.     else
  263.     {
  264.         bo_add_32be  ( &bo, 8 );
  265.         bo_add_fourcc( &bo, "wide" );
  266.         bo_add_32be  ( &bo, p_sys->i_pos - p_sys->i_mdat_pos - 8 );
  267.         bo_add_fourcc( &bo, "mdat" );
  268.     }
  269.     p_hdr = bo_to_sout( p_mux->p_sout, &bo );
  270.     free( bo.p_buffer );
  272.     sout_AccessOutSeek( p_mux->p_access, p_sys->i_mdat_pos );
  273.     sout_AccessOutWrite( p_mux->p_access, p_hdr );
  275.     /* Create MOOV header */
  276.     i_moov_pos = p_sys->i_pos;
  277.     moov = GetMoovBox( p_mux );
  279.     /* Check we need to create "fast start" files */
  280.     var_Get( p_this, SOUT_CFG_PREFIX "faststart", &val );
  281.     p_sys->b_fast_start = val.b_bool;
  282.     while( p_sys->b_fast_start )
  283.     {
  284.         /* Move data to the end of the file so we can fit the moov header
  285.          * at the start */
  286.         block_t *p_buf;
  287.         int64_t i_chunk, i_size = p_sys->i_pos - p_sys->i_mdat_pos;
  288.         int i_moov_size = moov->i_buffer;
  290.         while( i_size > 0 )
  291.         {
  292.             i_chunk = __MIN( 32768, i_size );
  293.             p_buf = block_New( p_mux, i_chunk );
  294.             sout_AccessOutSeek( p_mux->p_access,
  295.                                 p_sys->i_mdat_pos + i_size - i_chunk );
  296.             if( sout_AccessOutRead( p_mux->p_access, p_buf ) < i_chunk )
  297.             {
  298.                 msg_Warn( p_this, "read() not supported by access output, "
  299.                           "won't create a fast start file" );
  300.                 p_sys->b_fast_start = false;
  301.                 block_Release( p_buf );
  302.                 break;
  303.             }
  304.             sout_AccessOutSeek( p_mux->p_access, p_sys->i_mdat_pos + i_size +
  305.                                 i_moov_size - i_chunk );
  306.             sout_AccessOutWrite( p_mux->p_access, p_buf );
  307.             i_size -= i_chunk;
  308.         }
  310.         if( !p_sys->b_fast_start ) break;
  312.         /* Fix-up samples to chunks table in MOOV header */
  313.         for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ )
  314.         {
  315.             mp4_stream_t *p_stream = p_sys->pp_streams[i_trak];
  316.             unsigned int i;
  317.             int i_chunk;
  319.             moov->i_buffer = p_stream->i_stco_pos;
  320.             for( i_chunk = 0, i = 0; i < p_stream->i_entry_count; i_chunk++ )
  321.             {
  322.                 if( p_stream->b_stco64 )
  323.                     bo_add_64be( moov, p_stream->entry[i].i_pos + i_moov_size);
  324.                 else
  325.                     bo_add_32be( moov, p_stream->entry[i].i_pos + i_moov_size);
  327.                 while( i < p_stream->i_entry_count )
  328.                 {
  329.                     if( i + 1 < p_stream->i_entry_count &&
  330.                         p_stream->entry[i].i_pos + p_stream->entry[i].i_size
  331.                         != p_stream->entry[i + 1].i_pos )
  332.                     {
  333.                         i++;
  334.                         break;
  335.                     }
  337.                     i++;
  338.                 }
  339.             }
  340.         }
  342.         moov->i_buffer = i_moov_size;
  343.         i_moov_pos = p_sys->i_mdat_pos;
  344.         p_sys->b_fast_start = false;
  345.     }
  347.     /* Write MOOV header */
  348.     sout_AccessOutSeek( p_mux->p_access, i_moov_pos );
  349.     box_send( p_mux, moov );
  351.     /* Clean-up */
  352.     for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ )
  353.     {
  354.         mp4_stream_t *p_stream = p_sys->pp_streams[i_trak];
  356.         es_format_Clean( &p_stream->fmt );
  357.         free( p_stream->entry );
  358.         free( p_stream );
  359.     }
  360.     if( p_sys->i_nb_streams ) free( p_sys->pp_streams );
  361.     free( p_sys );
  362. }
  364. /*****************************************************************************
  365.  * Control:
  366.  *****************************************************************************/
  367. static int Control( sout_mux_t *p_mux, int i_query, va_list args )
  368. {
  369.     VLC_UNUSED(p_mux);
  370.     bool *pb_bool;
  372.     switch( i_query )
  373.     {
  374.         case MUX_CAN_ADD_STREAM_WHILE_MUXING:
  375.             pb_bool = (bool*)va_arg( args, bool * );
  376.             *pb_bool = false;
  377.             return VLC_SUCCESS;
  379.         case MUX_GET_ADD_STREAM_WAIT:
  380.             pb_bool = (bool*)va_arg( args, bool * );
  381.             *pb_bool = true;
  382.             return VLC_SUCCESS;
  384.         case MUX_GET_MIME:   /* Not needed, as not streamable */
  385.         default:
  386.             return VLC_EGENERIC;
  387.     }
  388. }
  390. /*****************************************************************************
  391.  * AddStream:
  392.  *****************************************************************************/
  393. static int AddStream( sout_mux_t *p_mux, sout_input_t *p_input )
  394. {
  395.     sout_mux_sys_t  *p_sys = p_mux->p_sys;
  396.     mp4_stream_t    *p_stream;
  398.     switch( p_input->p_fmt->i_codec )
  399.     {
  400.         case VLC_FOURCC( 'm', 'p', '4', 'a' ):
  401.         case VLC_FOURCC( 'm', 'p', '4', 'v' ):
  402.         case VLC_FOURCC( 'm', 'p', 'g', 'a' ):
  403.         case VLC_FOURCC( 'm', 'p', '3', ' ' ):
  404.         case VLC_FOURCC( 'm', 'p', 'g', 'v' ):
  405.         case VLC_FOURCC( 'M', 'J', 'P', 'G' ):
  406.         case VLC_FOURCC( 'm', 'j', 'p', 'b' ):
  407.         case VLC_FOURCC( 'S', 'V', 'Q', '1' ):
  408.         case VLC_FOURCC( 'S', 'V', 'Q', '3' ):
  409.         case VLC_FOURCC( 'H', '2', '6', '3' ):
  410.         case VLC_FOURCC( 'h', '2', '6', '4' ):
  411.         case VLC_FOURCC( 's', 'a', 'm', 'r' ):
  412.         case VLC_FOURCC( 's', 'a', 'w', 'b' ):
  413.         case VLC_FOURCC( 'Y', 'V', '1', '2' ):
  414.         case VLC_FOURCC( 'Y', 'U', 'Y', '2' ):
  415.             break;
  416.         case VLC_FOURCC( 's', 'u', 'b', 't' ):
  417.             msg_Warn( p_mux, "subtitle track added like in .mov (even when creating .mp4)" );
  418.             break;
  419.         default:
  420.             msg_Err( p_mux, "unsupported codec %4.4s in mp4",
  421.                      (char*)&p_input->p_fmt->i_codec );
  422.             return VLC_EGENERIC;
  423.     }
  425.     p_stream                = malloc( sizeof( mp4_stream_t ) );
  426.     if( !p_stream )
  427.         return VLC_ENOMEM;
  428.     es_format_Copy( &p_stream->fmt, p_input->p_fmt );
  429.     p_stream->i_track_id    = p_sys->i_nb_streams + 1;
  430.     p_stream->i_length_neg  = 0;
  431.     p_stream->i_entry_count = 0;
  432.     p_stream->i_entry_max   = 1000;
  433.     p_stream->entry         =
  434.         calloc( p_stream->i_entry_max, sizeof( mp4_entry_t ) );
  435.     p_stream->i_dts_start   = 0;
  436.     p_stream->i_duration    = 0;
  438.     p_input->p_sys          = p_stream;
  440.     msg_Dbg( p_mux, "adding input" );
  442.     TAB_APPEND( p_sys->i_nb_streams, p_sys->pp_streams, p_stream );
  443.     return VLC_SUCCESS;
  444. }
  446. /*****************************************************************************
  447.  * DelStream:
  448.  *****************************************************************************/
  449. static int DelStream( sout_mux_t *p_mux, sout_input_t *p_input )
  450. {
  451.     VLC_UNUSED(p_input);
  452.     msg_Dbg( p_mux, "removing input" );
  453.     return VLC_SUCCESS;
  454. }
  456. static int MuxGetStream( sout_mux_t *p_mux, int *pi_stream, mtime_t *pi_dts )
  457. {
  458.     mtime_t i_dts;
  459.     int     i_stream, i;
  461.     for( i = 0, i_dts = 0, i_stream = -1; i < p_mux->i_nb_inputs; i++ )
  462.     {
  463.         block_fifo_t   *p_fifo = p_mux->pp_inputs[i]->p_fifo;
  464.         block_t *p_buf;
  466.         if( block_FifoCount( p_fifo ) <= 1 )
  467.         {
  468.             if( p_mux->pp_inputs[i]->p_fmt->i_cat != SPU_ES )
  469.             {
  470.                 return -1; // wait that all fifo have at least 2 packets
  471.             }
  472.             /* For SPU, we wait only 1 packet */
  473.             continue;
  474.         }
  476.         p_buf = block_FifoShow( p_fifo );
  477.         if( i_stream < 0 || p_buf->i_dts < i_dts )
  478.         {
  479.             i_dts = p_buf->i_dts;
  480.             i_stream = i;
  481.         }
  482.     }
  483.     if( pi_stream )
  484.     {
  485.         *pi_stream = i_stream;
  486.     }
  487.     if( pi_dts )
  488.     {
  489.         *pi_dts = i_dts;
  490.     }
  491.     return i_stream;
  492. }
  494. /*****************************************************************************
  495.  * Mux:
  496.  *****************************************************************************/
  497. static int Mux( sout_mux_t *p_mux )
  498. {
  499.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  501.     for( ;; )
  502.     {
  503.         sout_input_t    *p_input;
  504.         int             i_stream;
  505.         mp4_stream_t    *p_stream;
  506.         block_t         *p_data;
  507.         mtime_t         i_dts;
  509.         if( MuxGetStream( p_mux, &i_stream, &i_dts) < 0 )
  510.         {
  511.             return( VLC_SUCCESS );
  512.         }
  514.         p_input  = p_mux->pp_inputs[i_stream];
  515.         p_stream = (mp4_stream_t*)p_input->p_sys;
  517. again:
  518.         p_data  = block_FifoGet( p_input->p_fifo );
  519.         if( p_stream->fmt.i_codec == VLC_FOURCC( 'h', '2', '6', '4' ) )
  520.         {
  521.             p_data = ConvertAVC1( p_data );
  522.         }
  523.         else if( p_stream->fmt.i_codec == VLC_FOURCC( 's', 'u', 'b', 't' ) )
  524.         {
  525.             p_data = ConvertSUBT( p_data );
  526.         }
  527.         if( p_data == NULL ) goto again;
  529.         if( p_stream->fmt.i_cat != SPU_ES )
  530.         {
  531.             /* Fix length of the sample */
  532.             if( block_FifoCount( p_input->p_fifo ) > 0 )
  533.             {
  534.                 block_t *p_next = block_FifoShow( p_input->p_fifo );
  535.                 int64_t       i_diff  = p_next->i_dts - p_data->i_dts;
  537.                 if( i_diff < INT64_C(1000000 ) )   /* protection */
  538.                 {
  539.                     p_data->i_length = i_diff;
  540.                 }
  541.             }
  542.             if( p_data->i_length <= 0 )
  543.             {
  544.                 msg_Warn( p_mux, "i_length <= 0" );
  545.                 p_stream->i_length_neg += p_data->i_length - 1;
  546.                 p_data->i_length = 1;
  547.             }
  548.             else if( p_stream->i_length_neg < 0 )
  549.             {
  550.                 int64_t i_recover = __MIN( p_data->i_length / 4, - p_stream->i_length_neg );
  552.                 p_data->i_length -= i_recover;
  553.                 p_stream->i_length_neg += i_recover;
  554.             }
  555.         }
  557.         /* Save starting time */
  558.         if( p_stream->i_entry_count == 0 )
  559.         {
  560.             p_stream->i_dts_start = p_data->i_dts;
  562.             /* Update global dts_start */
  563.             if( p_sys->i_dts_start <= 0 ||
  564.                 p_stream->i_dts_start < p_sys->i_dts_start )
  565.             {
  566.                 p_sys->i_dts_start = p_stream->i_dts_start;
  567.             }
  568.         }
  570.         if( p_stream->fmt.i_cat == SPU_ES && p_stream->i_entry_count > 0 )
  571.         {
  572.             int64_t i_length = p_data->i_dts - p_stream->i_last_dts;
  574.             if( i_length <= 0 )
  575.             {
  576.                 /* FIXME handle this broken case */
  577.                 i_length = 1;
  578.             }
  580.             /* Fix last entry */
  581.             if( p_stream->entry[p_stream->i_entry_count-1].i_length <= 0 )
  582.             {
  583.                 p_stream->entry[p_stream->i_entry_count-1].i_length = i_length;
  584.             }
  585.         }
  588.         /* add index entry */
  589.         p_stream->entry[p_stream->i_entry_count].i_pos    = p_sys->i_pos;
  590.         p_stream->entry[p_stream->i_entry_count].i_size   = p_data->i_buffer;
  591.         p_stream->entry[p_stream->i_entry_count].i_pts_dts=
  592.             __MAX( p_data->i_pts - p_data->i_dts, 0 );
  593.         p_stream->entry[p_stream->i_entry_count].i_length = p_data->i_length;
  594.         p_stream->entry[p_stream->i_entry_count].i_flags  = p_data->i_flags;
  596.         p_stream->i_entry_count++;
  597.         /* XXX: -1 to always have 2 entry for easy adding of empty SPU */
  598.         if( p_stream->i_entry_count >= p_stream->i_entry_max - 1 )
  599.         {
  600.             p_stream->i_entry_max += 1000;
  601.             p_stream->entry =
  602.                 realloc( p_stream->entry,
  603.                          p_stream->i_entry_max * sizeof( mp4_entry_t ) );
  604.         }
  606.         /* update */
  607.         p_stream->i_duration += p_data->i_length;
  608.         p_sys->i_pos += p_data->i_buffer;
  610.         /* Save the DTS */
  611.         p_stream->i_last_dts = p_data->i_dts;
  613.         /* write data */
  614.         sout_AccessOutWrite( p_mux->p_access, p_data );
  616.         if( p_stream->fmt.i_cat == SPU_ES )
  617.         {
  618.             int64_t i_length = p_stream->entry[p_stream->i_entry_count-1].i_length;
  620.             if( i_length != 0 )
  621.             {
  622.                 /* TODO */
  623.                 msg_Dbg( p_mux, "writing an empty sub" ) ;
  625.                 /* Append a idx entry */
  626.                 p_stream->entry[p_stream->i_entry_count].i_pos    = p_sys->i_pos;
  627.                 p_stream->entry[p_stream->i_entry_count].i_size   = 3;
  628.                 p_stream->entry[p_stream->i_entry_count].i_pts_dts= 0;
  629.                 p_stream->entry[p_stream->i_entry_count].i_length = 0;
  630.                 p_stream->entry[p_stream->i_entry_count].i_flags  = 0;
  632.                 /* XXX: No need to grow the entry here */
  633.                 p_stream->i_entry_count++;
  635.                 /* Fix last dts */
  636.                 p_stream->i_last_dts += i_length;
  638.                 /* Write a " " */
  639.                 p_data = block_New( p_mux, 3 );
  640.                 p_data->p_buffer[0] = 0;
  641.                 p_data->p_buffer[1] = 1;
  642.                 p_data->p_buffer[2] = ' ';
  644.                 p_sys->i_pos += p_data->i_buffer;
  646.                 sout_AccessOutWrite( p_mux->p_access, p_data );
  647.             }
  649.             /* Fix duration */
  650.             p_stream->i_duration = p_stream->i_last_dts - p_stream->i_dts_start;
  651.         }
  652.     }
  654.     return( VLC_SUCCESS );
  655. }
  657. /*****************************************************************************
  658.  *
  659.  *****************************************************************************/
  660. static block_t *ConvertSUBT( block_t *p_block )
  661. {
  662.     p_block = block_Realloc( p_block, 2, p_block->i_buffer );
  664.     /* No trailling '' */
  665.     if( p_block->i_buffer > 2 && p_block->p_buffer[p_block->i_buffer-1] == '' )
  666.         p_block->i_buffer--;
  668.     p_block->p_buffer[0] = ( (p_block->i_buffer - 2) >> 8 )&0xff;
  669.     p_block->p_buffer[1] = ( (p_block->i_buffer - 2)      )&0xff;
  671.     return p_block;
  672. }
  674. static block_t *ConvertAVC1( block_t *p_block )
  675. {
  676.     uint8_t *last = p_block->p_buffer;  /* Assume it starts with 0x00000001 */
  677.     uint8_t *dat  = &p_block->p_buffer[4];
  678.     uint8_t *end = &p_block->p_buffer[p_block->i_buffer];
  681.     /* Replace the 4 bytes start code with 4 bytes size,
  682.      * FIXME are all startcodes 4 bytes ? (I don't think :( */
  683.     while( dat < end )
  684.     {
  685.         int i_size;
  687.         while( dat < end - 4 )
  688.         {
  689.             if( dat[0] == 0x00 && dat[1] == 0x00  &&
  690.                 dat[2] == 0x00 && dat[3] == 0x01 )
  691.             {
  692.                 break;
  693.             }
  694.             dat++;
  695.         }
  696.         if( dat >= end - 4 )
  697.         {
  698.             dat = end;
  699.         }
  701.         /* Fix size */
  702.         i_size = dat - &last[4];
  703.         last[0] = ( i_size >> 24 )&0xff;
  704.         last[1] = ( i_size >> 16 )&0xff;
  705.         last[2] = ( i_size >>  8 )&0xff;
  706.         last[3] = ( i_size       )&0xff;
  708.         /* Skip blocks with SPS/PPS */
  709.         if( (last[4]&0x1f) == 7 || (last[4]&0x1f) == 8 )
  710.         {
  711.             ; // FIXME Find a way to skip dat without frelling everything
  712.         }
  713.         last = dat;
  714.         dat += 4;
  715.     }
  716.     return p_block;
  717. }
  719. static int GetDescrLength( int i_size )
  720. {
  721.     if( i_size < 0x00000080 )
  722.         return 2 + i_size;
  723.     else if( i_size < 0x00004000 )
  724.         return 3 + i_size;
  725.     else if( i_size < 0x00200000 )
  726.         return 4 + i_size;
  727.     else
  728.         return 5 + i_size;
  729. }
  731. static bo_t *GetESDS( mp4_stream_t *p_stream )
  732. {
  733.     bo_t *esds;
  734.     int  i_stream_type;
  735.     int  i_object_type_indication;
  736.     int  i_decoder_specific_info_size;
  737.     unsigned int i;
  738.     int64_t i_bitrate_avg = 0;
  739.     int64_t i_bitrate_max = 0;
  741.     /* Compute avg/max bitrate */
  742.     for( i = 0; i < p_stream->i_entry_count; i++ )
  743.     {
  744.         i_bitrate_avg += p_stream->entry[i].i_size;
  745.         if( p_stream->entry[i].i_length > 0)
  746.         {
  747.             int64_t i_bitrate = INT64_C(8000000) * p_stream->entry[i].i_size / p_stream->entry[i].i_length;
  748.             if( i_bitrate > i_bitrate_max )
  749.                 i_bitrate_max = i_bitrate;
  750.         }
  751.     }
  753.     if( p_stream->i_duration > 0 )
  754.         i_bitrate_avg = INT64_C(8000000) * i_bitrate_avg / p_stream->i_duration;
  755.     else
  756.         i_bitrate_avg = 0;
  757.     if( i_bitrate_max <= 1 )
  758.         i_bitrate_max = 0x7fffffff;
  760.     /* */
  761.     if( p_stream->fmt.i_extra > 0 )
  762.     {
  763.         i_decoder_specific_info_size =
  764.             GetDescrLength( p_stream->fmt.i_extra );
  765.     }
  766.     else
  767.     {
  768.         i_decoder_specific_info_size = 0;
  769.     }
  771.     esds = box_full_new( "esds", 0, 0 );
  773.     /* ES_Descr */
  774.     bo_add_descr( esds, 0x03, 3 +
  775.                   GetDescrLength( 13 + i_decoder_specific_info_size ) +
  776.                   GetDescrLength( 1 ) );
  777.     bo_add_16be( esds, p_stream->i_track_id );
  778.     bo_add_8   ( esds, 0x1f );      // flags=0|streamPriority=0x1f
  780.     /* DecoderConfigDescr */
  781.     bo_add_descr( esds, 0x04, 13 + i_decoder_specific_info_size );
  783.     switch( p_stream->fmt.i_codec )
  784.     {
  785.         case VLC_FOURCC( 'm', 'p', '4', 'v' ):
  786.             i_object_type_indication = 0x20;
  787.             break;
  788.         case VLC_FOURCC( 'm', 'p', 'g', 'v' ):
  789.             /* FIXME MPEG-I=0x6b, MPEG-II = 0x60 -> 0x65 */
  790.             i_object_type_indication = 0x60;
  791.             break;
  792.         case VLC_FOURCC( 'm', 'p', '4', 'a' ):
  793.             /* FIXME for mpeg2-aac == 0x66->0x68 */
  794.             i_object_type_indication = 0x40;
  795.             break;
  796.         case VLC_FOURCC( 'm', 'p', 'g', 'a' ):
  797.         case VLC_FOURCC( 'm', 'p', '3', ' ' ):
  798.             i_object_type_indication =
  799.                 p_stream->fmt.audio.i_rate < 32000 ? 0x69 : 0x6b;
  800.             break;
  801.         default:
  802.             i_object_type_indication = 0x00;
  803.             break;
  804.     }
  805.     i_stream_type = p_stream->fmt.i_cat == VIDEO_ES ? 0x04 : 0x05;
  807.     bo_add_8   ( esds, i_object_type_indication );
  808.     bo_add_8   ( esds, ( i_stream_type << 2 ) | 1 );
  809.     bo_add_24be( esds, 1024 * 1024 );       // bufferSizeDB
  810.     bo_add_32be( esds, i_bitrate_max );     // maxBitrate
  811.     bo_add_32be( esds, i_bitrate_avg );     // avgBitrate
  813.     if( p_stream->fmt.i_extra > 0 )
  814.     {
  815.         int i;
  817.         /* DecoderSpecificInfo */
  818.         bo_add_descr( esds, 0x05, p_stream->fmt.i_extra );
  820.         for( i = 0; i < p_stream->fmt.i_extra; i++ )
  821.         {
  822.             bo_add_8( esds, ((uint8_t*)p_stream->fmt.p_extra)[i] );
  823.         }
  824.     }
  826.     /* SL_Descr mandatory */
  827.     bo_add_descr( esds, 0x06, 1 );
  828.     bo_add_8    ( esds, 0x02 );  // sl_predefined
  830.     box_fix( esds );
  832.     return esds;
  833. }
  835. static bo_t *GetWaveTag( mp4_stream_t *p_stream )
  836. {
  837.     bo_t *wave;
  838.     bo_t *box;
  840.     wave = box_new( "wave" );
  842.     box = box_new( "frma" );
  843.     bo_add_fourcc( box, "mp4a" );
  844.     box_fix( box );
  845.     box_gather( wave, box );
  847.     box = box_new( "mp4a" );
  848.     bo_add_32be( box, 0 );
  849.     box_fix( box );
  850.     box_gather( wave, box );
  852.     box = GetESDS( p_stream );
  853.     box_fix( box );
  854.     box_gather( wave, box );
  856.     box = box_new( "srcq" );
  857.     bo_add_32be( box, 0x40 );
  858.     box_fix( box );
  859.     box_gather( wave, box );
  861.     /* wazza ? */
  862.     bo_add_32be( wave, 8 ); /* new empty box */
  863.     bo_add_32be( wave, 0 ); /* box label */
  865.     box_fix( wave );
  867.     return wave;
  868. }
  870. static bo_t *GetDamrTag( mp4_stream_t *p_stream )
  871. {
  872.     bo_t *damr;
  874.     damr = box_new( "damr" );
  876.     bo_add_fourcc( damr, "REFC" );
  877.     bo_add_8( damr, 0 );
  879.     if( p_stream->fmt.i_codec == VLC_FOURCC( 's', 'a', 'm', 'r' ) )
  880.         bo_add_16be( damr, 0x81ff ); /* Mode set (all modes for AMR_NB) */
  881.     else
  882.         bo_add_16be( damr, 0x83ff ); /* Mode set (all modes for AMR_WB) */
  883.     bo_add_16be( damr, 0x1 ); /* Mode change period (no restriction) */
  885.     box_fix( damr );
  887.     return damr;
  888. }
  890. static bo_t *GetD263Tag( void )
  891. {
  892.     bo_t *d263;
  894.     d263 = box_new( "d263" );
  896.     bo_add_fourcc( d263, "VLC " );
  897.     bo_add_16be( d263, 0xa );
  898.     bo_add_8( d263, 0 );
  900.     box_fix( d263 );
  902.     return d263;
  903. }
  905. static bo_t *GetAvcCTag( mp4_stream_t *p_stream )
  906. {
  907.     bo_t    *avcC = NULL;
  908.     uint8_t *p_sps = NULL;
  909.     uint8_t *p_pps = NULL;
  910.     int     i_sps_size = 0;
  911.     int     i_pps_size = 0;
  913.     if( p_stream->fmt.i_extra > 0 )
  914.     {
  915.         /* FIXME: take into account multiple sps/pps */
  916.         uint8_t *p_buffer = p_stream->fmt.p_extra;
  917.         int     i_buffer = p_stream->fmt.i_extra;
  919.         while( i_buffer > 4 &&
  920.             p_buffer[0] == 0 && p_buffer[1] == 0 &&
  921.             p_buffer[2] == 0 && p_buffer[3] == 1 )
  922.         {
  923.             const int i_nal_type = p_buffer[4]&0x1f;
  924.             int i_offset    = 1;
  925.             int i_size      = 0;
  926.             int i_startcode = 0;
  927.  
  928.             //msg_Dbg( p_stream, "we found a startcode for NAL with TYPE:%d", i_nal_type );
  929.  
  930.             for( i_offset = 1; i_offset+3 < i_buffer ; i_offset++)
  931.             {
  932.                 if( p_buffer[i_offset] == 0 && p_buffer[i_offset+1] == 0 &&
  933.                     p_buffer[i_offset+2] == 0 && p_buffer[i_offset+3] == 1 )
  934.                 {
  935.                     /* we found another startcode */
  936.                     i_startcode = i_offset;
  937.                     break;
  938.                 }
  939.             }
  940.             i_size = i_startcode ? i_startcode : i_buffer;
  941.             if( i_nal_type == 7 )
  942.             {
  943.                 p_sps = &p_buffer[4];
  944.                 i_sps_size = i_size - 4;
  945.             }
  946.             if( i_nal_type == 8 )
  947.             {
  948.                 p_pps = &p_buffer[4];
  949.                 i_pps_size = i_size - 4;
  950.             }
  951.             i_buffer -= i_size;
  952.             p_buffer += i_size;
  953.         }
  954.     }
  955.  
  956.     /* FIXME use better value */
  957.     avcC = box_new( "avcC" );
  958.     bo_add_8( avcC, 1 );      /* configuration version */
  959.     bo_add_8( avcC, i_sps_size ? p_sps[1] : 77 );
  960.     bo_add_8( avcC, i_sps_size ? p_sps[2] : 64 );
  961.     bo_add_8( avcC, i_sps_size ? p_sps[3] : 30 );       /* level, 5.1 */
  962.     bo_add_8( avcC, 0xff );   /* 0b11111100 | lengthsize = 0x11 */
  964.     bo_add_8( avcC, 0xe0 | (i_sps_size > 0 ? 1 : 0) );   /* 0b11100000 | sps_count */
  965.     if( i_sps_size > 0 )
  966.     {
  967.         bo_add_16be( avcC, i_sps_size );
  968.         bo_add_mem( avcC, i_sps_size, p_sps );
  969.     }
  971.     bo_add_8( avcC, (i_pps_size > 0 ? 1 : 0) );   /* pps_count */
  972.     if( i_pps_size > 0 )
  973.     {
  974.         bo_add_16be( avcC, i_pps_size );
  975.         bo_add_mem( avcC, i_pps_size, p_pps );
  976.     }
  977.     box_fix( avcC );
  979.     return avcC;
  980. }
  982. /* TODO: No idea about these values */
  983. static bo_t *GetSVQ3Tag( mp4_stream_t *p_stream )
  984. {
  985.     bo_t *smi = box_new( "SMI " );
  987.     if( p_stream->fmt.i_extra > 0x4e )
  988.     {
  989.         uint8_t *p_end = &((uint8_t*)p_stream->fmt.p_extra)[p_stream->fmt.i_extra];
  990.         uint8_t *p     = &((uint8_t*)p_stream->fmt.p_extra)[0x46];
  992.         while( p + 8 < p_end )
  993.         {
  994.             int i_size = GetDWBE( p );
  995.             if( i_size <= 1 )
  996.             {
  997.                 /* FIXME handle 1 as long size */
  998.                 break;
  999.             }
  1000.             if( !strncmp( (const char *)&p[4], "SMI ", 4 ) )
  1001.             {
  1002.                 bo_add_mem( smi, p_end - p - 8, &p[8] );
  1003.                 return smi;
  1004.             }
  1005.             p += i_size;
  1006.         }
  1007.     }
  1009.     /* Create a dummy one in fallback */
  1010.     bo_add_fourcc( smi, "SEQH" );
  1011.     bo_add_32be( smi, 0x5 );
  1012.     bo_add_32be( smi, 0xe2c0211d );
  1013.     bo_add_8( smi, 0xc0 );
  1014.     box_fix( smi );
  1016.     return smi;
  1017. }
  1019. static bo_t *GetUdtaTag( sout_mux_t *p_mux )
  1020. {
  1021.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  1022.     bo_t *udta = box_new( "udta" );
  1023.     vlc_meta_t *p_meta = p_mux->p_sout->p_meta;
  1024.     int i_track;
  1026.     /* Requirements */
  1027.     for( i_track = 0; i_track < p_sys->i_nb_streams; i_track++ )
  1028.     {
  1029.         mp4_stream_t *p_stream = p_sys->pp_streams[i_track];
  1031.         if( p_stream->fmt.i_codec == VLC_FOURCC('m','p','4','v') ||
  1032.             p_stream->fmt.i_codec == VLC_FOURCC('m','p','4','a') )
  1033.         {
  1034.             bo_t *box = box_new( "251req" );
  1035.             /* String length */
  1036.             bo_add_16be( box, sizeof("QuickTime 6.0 or greater") - 1);
  1037.             bo_add_16be( box, 0 );
  1038.             bo_add_mem( box, sizeof("QuickTime 6.0 or greater") - 1,
  1039.                         (uint8_t *)"QuickTime 6.0 or greater" );
  1040.             box_fix( box );
  1041.             box_gather( udta, box );
  1042.             break;
  1043.         }
  1044.     }
  1046.     /* Encoder */
  1047.     {
  1048.         bo_t *box = box_new( "251enc" );
  1049.         /* String length */
  1050.         bo_add_16be( box, sizeof(PACKAGE_STRING " stream output") - 1);
  1051.         bo_add_16be( box, 0 );
  1052.         bo_add_mem( box, sizeof(PACKAGE_STRING " stream output") - 1,
  1053.                     (uint8_t*)PACKAGE_STRING " stream output" );
  1054.         box_fix( box );
  1055.         box_gather( udta, box );
  1056.     }
  1058.     /* Misc atoms */
  1059.     if( p_meta )
  1060.     {
  1061. #define ADD_META_BOX( type, box_string ) { 
  1062.         bo_t *box = NULL;  
  1063.         if( vlc_meta_Get( p_meta, vlc_meta_##type ) ) box = box_new( "251" box_string ); 
  1064.         if( box ) 
  1065.         { 
  1066.             bo_add_16be( box, strlen( vlc_meta_Get( p_meta, vlc_meta_##type ) )); 
  1067.             bo_add_16be( box, 0 ); 
  1068.             bo_add_mem( box, strlen( vlc_meta_Get( p_meta, vlc_meta_##type ) ), 
  1069.                         (uint8_t*)(vlc_meta_Get( p_meta, vlc_meta_##type ) ) ); 
  1070.             box_fix( box ); 
  1071.             box_gather( udta, box ); 
  1072.         } }
  1074.         ADD_META_BOX( Title, "nam" );
  1075.         ADD_META_BOX( Artist, "ART" );
  1076.         ADD_META_BOX( Genre, "gen" );
  1077.         ADD_META_BOX( Copyright, "cpy" );
  1078.         ADD_META_BOX( Description, "des" );
  1079.         ADD_META_BOX( Date, "day" );
  1080.         ADD_META_BOX( URL, "url" );
  1081. #undef ADD_META_BOX
  1082.     }
  1084.     box_fix( udta );
  1085.     return udta;
  1086. }
  1088. static bo_t *GetSounBox( sout_mux_t *p_mux, mp4_stream_t *p_stream )
  1089. {
  1090.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  1091.     bool b_descr = false;
  1092.     bo_t *soun;
  1093.     char fcc[4] = "    ";
  1094.     int  i;
  1096.     switch( p_stream->fmt.i_codec )
  1097.     {
  1098.     case VLC_FOURCC('m','p','4','a'):
  1099.         memcpy( fcc, "mp4a", 4 );
  1100.         b_descr = true;
  1101.         break;
  1103.     case VLC_FOURCC('s','a','m','r'):
  1104.     case VLC_FOURCC('s','a','w','b'):
  1105.         memcpy( fcc, (char*)&p_stream->fmt.i_codec, 4 );
  1106.         b_descr = true;
  1107.         break;
  1109.     case VLC_FOURCC('m','p','g','a'):
  1110.     case VLC_FOURCC('m','p','3',' '):
  1111.         if( p_sys->b_mov )
  1112.             memcpy( fcc, ".mp3", 4 );
  1113.         else
  1114.         {
  1115.             memcpy( fcc, "mp4a", 4 );
  1116.             b_descr = true;
  1117.         }
  1118.         break;
  1120.     default:
  1121.         memcpy( fcc, (char*)&p_stream->fmt.i_codec, 4 );
  1122.         break;
  1123.     }
  1125.     soun = box_new( fcc );
  1126.     for( i = 0; i < 6; i++ )
  1127.     {
  1128.         bo_add_8( soun, 0 );        // reserved;
  1129.     }
  1130.     bo_add_16be( soun, 1 );         // data-reference-index
  1132.     /* SoundDescription */
  1133.     if( p_sys->b_mov &&
  1134.         p_stream->fmt.i_codec == VLC_FOURCC('m','p','4','a') )
  1135.     {
  1136.         bo_add_16be( soun, 1 );     // version 1;
  1137.     }
  1138.     else
  1139.     {
  1140.         bo_add_16be( soun, 0 );     // version 0;
  1141.     }
  1142.     bo_add_16be( soun, 0 );         // revision level (0)
  1143.     bo_add_32be( soun, 0 );         // vendor
  1144.     // channel-count
  1145.     bo_add_16be( soun, p_stream->fmt.audio.i_channels );
  1146.     // sample size
  1147.     bo_add_16be( soun, p_stream->fmt.audio.i_bitspersample ?
  1148.                  p_stream->fmt.audio.i_bitspersample : 16 );
  1149.     bo_add_16be( soun, -2 );        // compression id
  1150.     bo_add_16be( soun, 0 );         // packet size (0)
  1151.     bo_add_16be( soun, p_stream->fmt.audio.i_rate ); // sampleratehi
  1152.     bo_add_16be( soun, 0 );                             // sampleratelo
  1154.     /* Extended data for SoundDescription V1 */
  1155.     if( p_sys->b_mov &&
  1156.         p_stream->fmt.i_codec == VLC_FOURCC('m','p','4','a') )
  1157.     {
  1158.         /* samples per packet */
  1159.         bo_add_32be( soun, p_stream->fmt.audio.i_frame_length );
  1160.         bo_add_32be( soun, 1536 ); /* bytes per packet */
  1161.         bo_add_32be( soun, 2 );    /* bytes per frame */
  1162.         /* bytes per sample */
  1163.         bo_add_32be( soun, 2 /*p_stream->fmt.audio.i_bitspersample/8 */);
  1164.     }
  1166.     /* Add an ES Descriptor */
  1167.     if( b_descr )
  1168.     {
  1169.         bo_t *box;
  1171.         if( p_sys->b_mov &&
  1172.             p_stream->fmt.i_codec == VLC_FOURCC('m','p','4','a') )
  1173.         {
  1174.             box = GetWaveTag( p_stream );
  1175.         }
  1176.         else if( p_stream->fmt.i_codec == VLC_FOURCC('s','a','m','r') )
  1177.         {
  1178.             box = GetDamrTag( p_stream );
  1179.         }
  1180.         else
  1181.         {
  1182.             box = GetESDS( p_stream );
  1183.         }
  1184.         box_fix( box );
  1185.         box_gather( soun, box );
  1186.     }
  1188.     box_fix( soun );
  1190.     return soun;
  1191. }
  1193. static bo_t *GetVideBox( mp4_stream_t *p_stream )
  1194. {
  1196.     bo_t *vide;
  1197.     char fcc[4] = "    ";
  1198.     int  i;
  1200.     switch( p_stream->fmt.i_codec )
  1201.     {
  1202.     case VLC_FOURCC('m','p','4','v'):
  1203.     case VLC_FOURCC('m','p','g','v'):
  1204.         memcpy( fcc, "mp4v", 4 );
  1205.         break;
  1207.     case VLC_FOURCC('M','J','P','G'):
  1208.         memcpy( fcc, "mjpa", 4 );
  1209.         break;
  1211.     case VLC_FOURCC('S','V','Q','1'):
  1212.         memcpy( fcc, "SVQ1", 4 );
  1213.         break;
  1215.     case VLC_FOURCC('S','V','Q','3'):
  1216.         memcpy( fcc, "SVQ3", 4 );
  1217.         break;
  1219.     case VLC_FOURCC('H','2','6','3'):
  1220.         memcpy( fcc, "s263", 4 );
  1221.         break;
  1223.     case VLC_FOURCC('h','2','6','4'):
  1224.         memcpy( fcc, "avc1", 4 );
  1225.         break;
  1227.     case VLC_FOURCC('Y','V','1','2'):
  1228.         memcpy( fcc, "yv12", 4 );
  1229.         break;
  1231.     case VLC_FOURCC('Y','U','Y','2'):
  1232.         memcpy( fcc, "yuy2", 4 );
  1233.         break;
  1235.     default:
  1236.         memcpy( fcc, (char*)&p_stream->fmt.i_codec, 4 );
  1237.         break;
  1238.     }
  1240.     vide = box_new( fcc );
  1241.     for( i = 0; i < 6; i++ )
  1242.     {
  1243.         bo_add_8( vide, 0 );        // reserved;
  1244.     }
  1245.     bo_add_16be( vide, 1 );         // data-reference-index
  1247.     bo_add_16be( vide, 0 );         // predefined;
  1248.     bo_add_16be( vide, 0 );         // reserved;
  1249.     for( i = 0; i < 3; i++ )
  1250.     {
  1251.         bo_add_32be( vide, 0 );     // predefined;
  1252.     }
  1254.     bo_add_16be( vide, p_stream->fmt.video.i_width );  // i_width
  1255.     bo_add_16be( vide, p_stream->fmt.video.i_height ); // i_height
  1257.     bo_add_32be( vide, 0x00480000 );                // h 72dpi
  1258.     bo_add_32be( vide, 0x00480000 );                // v 72dpi
  1260.     bo_add_32be( vide, 0 );         // data size, always 0
  1261.     bo_add_16be( vide, 1 );         // frames count per sample
  1263.     // compressor name;
  1264.     for( i = 0; i < 32; i++ )
  1265.     {
  1266.         bo_add_8( vide, 0 );
  1267.     }
  1269.     bo_add_16be( vide, 0x18 );      // depth
  1270.     bo_add_16be( vide, 0xffff );    // predefined
  1272.     /* add an ES Descriptor */
  1273.     switch( p_stream->fmt.i_codec )
  1274.     {
  1275.     case VLC_FOURCC('m','p','4','v'):
  1276.     case VLC_FOURCC('m','p','g','v'):
  1277.         {
  1278.             bo_t *esds = GetESDS( p_stream );
  1280.             box_fix( esds );
  1281.             box_gather( vide, esds );
  1282.         }
  1283.         break;
  1285.     case VLC_FOURCC('H','2','6','3'):
  1286.         {
  1287.             bo_t *d263 = GetD263Tag();
  1289.             box_fix( d263 );
  1290.             box_gather( vide, d263 );
  1291.         }
  1292.         break;
  1294.     case VLC_FOURCC('S','V','Q','3'):
  1295.         {
  1296.             bo_t *esds = GetSVQ3Tag( p_stream );
  1298.             box_fix( esds );
  1299.             box_gather( vide, esds );
  1300.         }
  1301.         break;
  1303.     case VLC_FOURCC('h','2','6','4'):
  1304.         box_gather( vide, GetAvcCTag( p_stream ) );
  1305.         break;
  1307.     default:
  1308.         break;
  1309.     }
  1311.     box_fix( vide );
  1313.     return vide;
  1314. }
  1316. static bo_t *GetTextBox( void )
  1317. {
  1319.     bo_t *text = box_new( "text" );
  1320.     int  i;
  1322.     for( i = 0; i < 6; i++ )
  1323.     {
  1324.         bo_add_8( text, 0 );        // reserved;
  1325.     }
  1326.     bo_add_16be( text, 1 );         // data-reference-index
  1328.     bo_add_32be( text, 0 );         // display flags
  1329.     bo_add_32be( text, 0 );         // justification
  1330.     for( i = 0; i < 3; i++ )
  1331.     {
  1332.         bo_add_16be( text, 0 );     // back ground color
  1333.     }
  1335.     bo_add_16be( text, 0 );         // box text
  1336.     bo_add_16be( text, 0 );         // box text
  1337.     bo_add_16be( text, 0 );         // box text
  1338.     bo_add_16be( text, 0 );         // box text
  1340.     bo_add_64be( text, 0 );         // reserved
  1341.     for( i = 0; i < 3; i++ )
  1342.     {
  1343.         bo_add_16be( text, 0xff );  // foreground color
  1344.     }
  1346.     bo_add_8 ( text, 9 );
  1347.     bo_add_mem( text, 9, (uint8_t*)"Helvetica" );
  1349.     box_fix( text );
  1351.     return text;
  1352. }
  1354. static bo_t *GetStblBox( sout_mux_t *p_mux, mp4_stream_t *p_stream )
  1355. {
  1356.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  1357.     unsigned int i_chunk, i_stsc_last_val, i_stsc_entries, i, i_index;
  1358.     bo_t *stbl, *stsd, *stts, *stco, *stsc, *stsz, *stss;
  1359.     uint32_t i_timescale;
  1360.     int64_t i_dts, i_dts_q;
  1362.     stbl = box_new( "stbl" );
  1364.     /* sample description */
  1365.     stsd = box_full_new( "stsd", 0, 0 );
  1366.     bo_add_32be( stsd, 1 );
  1367.     if( p_stream->fmt.i_cat == AUDIO_ES )
  1368.     {
  1369.         bo_t *soun = GetSounBox( p_mux, p_stream );
  1370.         box_gather( stsd, soun );
  1371.     }
  1372.     else if( p_stream->fmt.i_cat == VIDEO_ES )
  1373.     {
  1374.         bo_t *vide = GetVideBox( p_stream );
  1375.         box_gather( stsd, vide );
  1376.     }
  1377.     else if( p_stream->fmt.i_cat == SPU_ES )
  1378.     {
  1379.         box_gather( stsd, GetTextBox() );
  1380.     }
  1381.     box_fix( stsd );
  1383.     /* chunk offset table */
  1384.     if( p_sys->i_pos >= (((uint64_t)0x1) << 32) )
  1385.     {
  1386.         /* 64 bits version */
  1387.         p_stream->b_stco64 = true;
  1388.         stco = box_full_new( "co64", 0, 0 );
  1389.     }
  1390.     else
  1391.     {
  1392.         /* 32 bits version */
  1393.         p_stream->b_stco64 = false;
  1394.         stco = box_full_new( "stco", 0, 0 );
  1395.     }
  1396.     bo_add_32be( stco, 0 );     // entry-count (fixed latter)
  1398.     /* sample to chunk table */
  1399.     stsc = box_full_new( "stsc", 0, 0 );
  1400.     bo_add_32be( stsc, 0 );     // entry-count (fixed latter)
  1402.     for( i_chunk = 0, i_stsc_last_val = 0, i_stsc_entries = 0, i = 0;
  1403.          i < p_stream->i_entry_count; i_chunk++ )
  1404.     {
  1405.         int i_first = i;
  1407.         if( p_stream->b_stco64 )
  1408.             bo_add_64be( stco, p_stream->entry[i].i_pos );
  1409.         else
  1410.             bo_add_32be( stco, p_stream->entry[i].i_pos );
  1412.         while( i < p_stream->i_entry_count )
  1413.         {
  1414.             if( i + 1 < p_stream->i_entry_count &&
  1415.                 p_stream->entry[i].i_pos + p_stream->entry[i].i_size
  1416.                 != p_stream->entry[i + 1].i_pos )
  1417.             {
  1418.                 i++;
  1419.                 break;
  1420.             }
  1422.             i++;
  1423.         }
  1425.         /* Add entry to the stsc table */
  1426.         if( i_stsc_last_val != i - i_first )
  1427.         {
  1428.             bo_add_32be( stsc, 1 + i_chunk );   // first-chunk
  1429.             bo_add_32be( stsc, i - i_first ) ;  // samples-per-chunk
  1430.             bo_add_32be( stsc, 1 );             // sample-descr-index
  1431.             i_stsc_last_val = i - i_first;
  1432.             i_stsc_entries++;
  1433.         }
  1434.     }
  1436.     /* Fix stco entry count */
  1437.     bo_fix_32be( stco, 12, i_chunk );
  1438.     msg_Dbg( p_mux, "created %d chunks (stco)", i_chunk );
  1439.     box_fix( stco );
  1441.     /* Fix stsc entry count */
  1442.     bo_fix_32be( stsc, 12, i_stsc_entries  );
  1443.     box_fix( stsc );
  1445.     /* add stts */
  1446.     stts = box_full_new( "stts", 0, 0 );
  1447.     bo_add_32be( stts, 0 );     // entry-count (fixed latter)
  1449.     if( p_stream->fmt.i_cat == AUDIO_ES )
  1450.         i_timescale = p_stream->fmt.audio.i_rate;
  1451.     else
  1452.         i_timescale = 1001;
  1454.     /* first, create quantified length */
  1455.     for( i = 0, i_dts = 0, i_dts_q = 0; i < p_stream->i_entry_count; i++ )
  1456.     {
  1457.         int64_t i_dts_deq = i_dts_q * INT64_C(1000000) / (int64_t)i_timescale;
  1458.         int64_t i_delta = p_stream->entry[i].i_length + i_dts - i_dts_deq;
  1460.         i_dts += p_stream->entry[i].i_length;
  1462.         p_stream->entry[i].i_length =
  1463.             i_delta * (int64_t)i_timescale / INT64_C(1000000);
  1465.         i_dts_q += p_stream->entry[i].i_length;
  1466.     }
  1467.     /* then write encoded table */
  1468.     for( i = 0, i_index = 0; i < p_stream->i_entry_count; i_index++)
  1469.     {
  1470.         int     i_first = i;
  1471.         int64_t i_delta = p_stream->entry[i].i_length;
  1473.         while( i < p_stream->i_entry_count )
  1474.         {
  1475.             i++;
  1476.             if( i >= p_stream->i_entry_count ||
  1477.                 p_stream->entry[i].i_length != i_delta )
  1478.             {
  1479.                 break;
  1480.             }
  1481.         }
  1483.         bo_add_32be( stts, i - i_first ); // sample-count
  1484.         bo_add_32be( stts, i_delta );     // sample-delta
  1485.     }
  1486.     bo_fix_32be( stts, 12, i_index );
  1487.     box_fix( stts );
  1489.     /* FIXME add ctts ?? FIXME */
  1491.     stsz = box_full_new( "stsz", 0, 0 );
  1492.     bo_add_32be( stsz, 0 );                             // sample-size
  1493.     bo_add_32be( stsz, p_stream->i_entry_count );       // sample-count
  1494.     for( i = 0; i < p_stream->i_entry_count; i++ )
  1495.     {
  1496.         bo_add_32be( stsz, p_stream->entry[i].i_size ); // sample-size
  1497.     }
  1498.     box_fix( stsz );
  1500.     /* create stss table */
  1501.     stss = NULL;
  1502.     for( i = 0, i_index = 0; i < p_stream->i_entry_count; i++ )
  1503.     {
  1504.         if( p_stream->entry[i].i_flags & BLOCK_FLAG_TYPE_I )
  1505.         {
  1506.             if( stss == NULL )
  1507.             {
  1508.                 stss = box_full_new( "stss", 0, 0 );
  1509.                 bo_add_32be( stss, 0 ); /* fixed later */
  1510.             }
  1511.             bo_add_32be( stss, 1 + i );
  1512.             i_index++;
  1513.         }
  1514.     }
  1515.     if( stss )
  1516.     {
  1517.         bo_fix_32be( stss, 12, i_index );
  1518.         box_fix( stss );
  1519.     }
  1521.     /* Now gather all boxes into stbl */
  1522.     box_gather( stbl, stsd );
  1523.     box_gather( stbl, stts );
  1524.     if( stss )
  1525.     {
  1526.         box_gather( stbl, stss );
  1527.     }
  1528.     box_gather( stbl, stsc );
  1529.     box_gather( stbl, stsz );
  1530.     p_stream->i_stco_pos = stbl->i_buffer + 16;
  1531.     box_gather( stbl, stco );
  1533.     /* finish stbl */
  1534.     box_fix( stbl );
  1536.     return stbl;
  1537. }
  1539. static int64_t get_timestamp(void);
  1541. static const uint32_t mvhd_matrix[9] =
  1542.     { 0x10000, 0, 0, 0, 0x10000, 0, 0, 0, 0x40000000 };
  1544. static bo_t *GetMoovBox( sout_mux_t *p_mux )
  1545. {
  1546.     sout_mux_sys_t *p_sys = p_mux->p_sys;
  1548.     bo_t            *moov, *mvhd;
  1549.     int             i_trak, i;
  1551.     uint32_t        i_movie_timescale = 90000;
  1552.     int64_t         i_movie_duration  = 0;
  1554.     moov = box_new( "moov" );
  1556.     /* Create general info */
  1557.     for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ )
  1558.     {
  1559.         mp4_stream_t *p_stream = p_sys->pp_streams[i_trak];
  1560.         i_movie_duration = __MAX( i_movie_duration, p_stream->i_duration );
  1561.     }
  1562.     msg_Dbg( p_mux, "movie duration %ds",
  1563.              (uint32_t)( i_movie_duration / (mtime_t)1000000 ) );
  1565.     i_movie_duration = i_movie_duration * i_movie_timescale / 1000000;
  1567.     /* *** add /moov/mvhd *** */
  1568.     if( !p_sys->b_64_ext )
  1569.     {
  1570.         mvhd = box_full_new( "mvhd", 0, 0 );
  1571.         bo_add_32be( mvhd, get_timestamp() );   // creation time
  1572.         bo_add_32be( mvhd, get_timestamp() );   // modification time
  1573.         bo_add_32be( mvhd, i_movie_timescale);  // timescale
  1574.         bo_add_32be( mvhd, i_movie_duration );  // duration
  1575.     }
  1576.     else
  1577.     {
  1578.         mvhd = box_full_new( "mvhd", 1, 0 );
  1579.         bo_add_64be( mvhd, get_timestamp() );   // creation time
  1580.         bo_add_64be( mvhd, get_timestamp() );   // modification time
  1581.         bo_add_32be( mvhd, i_movie_timescale);  // timescale
  1582.         bo_add_64be( mvhd, i_movie_duration );  // duration
  1583.     }
  1584.     bo_add_32be( mvhd, 0x10000 );           // rate
  1585.     bo_add_16be( mvhd, 0x100 );             // volume
  1586.     bo_add_16be( mvhd, 0 );                 // reserved
  1587.     for( i = 0; i < 2; i++ )
  1588.     {
  1589.         bo_add_32be( mvhd, 0 );             // reserved
  1590.     }
  1591.     for( i = 0; i < 9; i++ )
  1592.     {
  1593.         bo_add_32be( mvhd, mvhd_matrix[i] );// matrix
  1594.     }
  1595.     for( i = 0; i < 6; i++ )
  1596.     {
  1597.         bo_add_32be( mvhd, 0 );             // pre-defined
  1598.     }
  1600.     /* Next available track id */
  1601.     bo_add_32be( mvhd, p_sys->i_nb_streams + 1 ); // next-track-id
  1603.     box_fix( mvhd );
  1604.     box_gather( moov, mvhd );
  1606.     for( i_trak = 0; i_trak < p_sys->i_nb_streams; i_trak++ )
  1607.     {
  1608.         mp4_stream_t *p_stream;
  1609.         uint32_t     i_timescale;
  1611.         bo_t *trak, *tkhd, *edts, *elst, *mdia, *mdhd, *hdlr;
  1612.         bo_t *minf, *dinf, *dref, *url, *stbl;
  1614.         p_stream = p_sys->pp_streams[i_trak];
  1616.         if( p_stream->fmt.i_cat == AUDIO_ES )
  1617.             i_timescale = p_stream->fmt.audio.i_rate;
  1618.         else
  1619.             i_timescale = 1001;
  1621.         /* *** add /moov/trak *** */
  1622.         trak = box_new( "trak" );
  1624.         /* *** add /moov/trak/tkhd *** */
  1625.         if( !p_sys->b_64_ext )
  1626.         {
  1627.             if( p_sys->b_mov )
  1628.                 tkhd = box_full_new( "tkhd", 0, 0x0f );
  1629.             else
  1630.                 tkhd = box_full_new( "tkhd", 0, 1 );
  1632.             bo_add_32be( tkhd, get_timestamp() );       // creation time
  1633.             bo_add_32be( tkhd, get_timestamp() );       // modification time
  1634.             bo_add_32be( tkhd, p_stream->i_track_id );
  1635.             bo_add_32be( tkhd, 0 );                     // reserved 0
  1636.             bo_add_32be( tkhd, p_stream->i_duration *
  1637.                          (int64_t)i_movie_timescale /
  1638.                          (mtime_t)1000000 );            // duration
  1639.         }
  1640.         else
  1641.         {
  1642.             if( p_sys->b_mov )
  1643.                 tkhd = box_full_new( "tkhd", 1, 0x0f );
  1644.             else
  1645.                 tkhd = box_full_new( "tkhd", 1, 1 );
  1647.             bo_add_64be( tkhd, get_timestamp() );       // creation time
  1648.             bo_add_64be( tkhd, get_timestamp() );       // modification time
  1649.             bo_add_32be( tkhd, p_stream->i_track_id );
  1650.             bo_add_32be( tkhd, 0 );                     // reserved 0
  1651.             bo_add_64be( tkhd, p_stream->i_duration *
  1652.                          (int64_t)i_movie_timescale /
  1653.                          (mtime_t)1000000 );            // duration
  1654.         }
  1656.         for( i = 0; i < 2; i++ )
  1657.         {
  1658.             bo_add_32be( tkhd, 0 );                 // reserved
  1659.         }
  1660.         bo_add_16be( tkhd, 0 );                     // layer
  1661.         bo_add_16be( tkhd, 0 );                     // pre-defined
  1662.         // volume
  1663.         bo_add_16be( tkhd, p_stream->fmt.i_cat == AUDIO_ES ? 0x100 : 0 );
  1664.         bo_add_16be( tkhd, 0 );                     // reserved
  1665.         for( i = 0; i < 9; i++ )
  1666.         {
  1667.             bo_add_32be( tkhd, mvhd_matrix[i] );    // matrix
  1668.         }
  1669.         if( p_stream->fmt.i_cat == AUDIO_ES )
  1670.         {
  1671.             bo_add_32be( tkhd, 0 );                 // width (presentation)
  1672.             bo_add_32be( tkhd, 0 );                 // height(presentation)
  1673.         }
  1674.         else if( p_stream->fmt.i_cat == VIDEO_ES )
  1675.         {
  1676.             int i_width = p_stream->fmt.video.i_width << 16;
  1677.             if( p_stream->fmt.video.i_aspect > 0 )
  1678.             {
  1679.                 i_width = (int64_t)p_stream->fmt.video.i_aspect *
  1680.                           ((int64_t)p_stream->fmt.video.i_height << 16) /
  1681.                           VOUT_ASPECT_FACTOR;
  1682.             }
  1683.             // width (presentation)
  1684.             bo_add_32be( tkhd, i_width );
  1685.             // height(presentation)
  1686.             bo_add_32be( tkhd, p_stream->fmt.video.i_height << 16 );
  1687.         }
  1688.         else
  1689.         {
  1690.             int i_width = 320 << 16;
  1691.             int i_height = 200;
  1692.             int i;
  1693.             for( i = 0; i < p_sys->i_nb_streams; i++ )
  1694.             {
  1695.                 mp4_stream_t *tk = p_sys->pp_streams[i];
  1696.                 if( tk->fmt.i_cat == VIDEO_ES )
  1697.                 {
  1698.                     if( p_stream->fmt.video.i_aspect )
  1699.                         i_width = (int64_t)p_stream->fmt.video.i_aspect *
  1700.                                    ((int64_t)p_stream->fmt.video.i_height<<16) / VOUT_ASPECT_FACTOR;
  1701.                     else
  1702.                         i_width = p_stream->fmt.video.i_width << 16;
  1703.                     i_height = p_stream->fmt.video.i_height;
  1704.                     break;
  1705.                 }
  1706.             }
  1707.             bo_add_32be( tkhd, i_width );     // width (presentation)
  1708.             bo_add_32be( tkhd, i_height << 16 );    // height(presentation)
  1709.         }
  1711.         box_fix( tkhd );
  1712.         box_gather( trak, tkhd );
  1714.         /* *** add /moov/trak/edts and elst */
  1715.         edts = box_new( "edts" );
  1716.         elst = box_full_new( "elst", p_sys->b_64_ext ? 1 : 0, 0 );
  1717.         if( p_stream->i_dts_start > p_sys->i_dts_start )
  1718.         {
  1719.             bo_add_32be( elst, 2 );
  1721.             if( p_sys->b_64_ext )
  1722.             {
  1723.                 bo_add_64be( elst, (p_stream->i_dts_start-p_sys->i_dts_start) *
  1724.                              i_movie_timescale / INT64_C(1000000) );
  1725.                 bo_add_64be( elst, -1 );
  1726.             }
  1727.             else
  1728.             {
  1729.                 bo_add_32be( elst, (p_stream->i_dts_start-p_sys->i_dts_start) *
  1730.                              i_movie_timescale / INT64_C(1000000) );
  1731.                 bo_add_32be( elst, -1 );
  1732.             }
  1733.             bo_add_16be( elst, 1 );
  1734.             bo_add_16be( elst, 0 );
  1735.         }
  1736.         else
  1737.         {
  1738.             bo_add_32be( elst, 1 );
  1739.         }
  1740.         if( p_sys->b_64_ext )
  1741.         {
  1742.             bo_add_64be( elst, p_stream->i_duration *
  1743.                          i_movie_timescale / INT64_C(1000000) );
  1744.             bo_add_64be( elst, 0 );
  1745.         }
  1746.         else
  1747.         {
  1748.             bo_add_32be( elst, p_stream->i_duration *
  1749.                          i_movie_timescale / INT64_C(1000000) );
  1750.             bo_add_32be( elst, 0 );
  1751.         }
  1752.         bo_add_16be( elst, 1 );
  1753.         bo_add_16be( elst, 0 );
  1755.         box_fix( elst );
  1756.         box_gather( edts, elst );
  1757.         box_fix( edts );
  1758.         box_gather( trak, edts );
  1760.         /* *** add /moov/trak/mdia *** */
  1761.         mdia = box_new( "mdia" );
  1763.         /* media header */
  1764.         if( !p_sys->b_64_ext )
  1765.         {
  1766.             mdhd = box_full_new( "mdhd", 0, 0 );
  1767.             bo_add_32be( mdhd, get_timestamp() );   // creation time
  1768.             bo_add_32be( mdhd, get_timestamp() );   // modification time
  1769.             bo_add_32be( mdhd, i_timescale);        // timescale
  1770.             bo_add_32be( mdhd, p_stream->i_duration * (int64_t)i_timescale /
  1771.                                (mtime_t)1000000 );  // duration
  1772.         }
  1773.         else
  1774.         {
  1775.             mdhd = box_full_new( "mdhd", 1, 0 );
  1776.             bo_add_64be( mdhd, get_timestamp() );   // creation time
  1777.             bo_add_64be( mdhd, get_timestamp() );   // modification time
  1778.             bo_add_32be( mdhd, i_timescale);        // timescale
  1779.             bo_add_64be( mdhd, p_stream->i_duration * (int64_t)i_timescale /
  1780.                                (mtime_t)1000000 );  // duration
  1781.         }
  1783.         if( p_stream->fmt.psz_language )
  1784.         {
  1785.             char *psz = p_stream->fmt.psz_language;
  1786.             const iso639_lang_t *pl = NULL;
  1787.             uint16_t lang = 0x0;
  1789.             if( strlen( psz ) == 2 )
  1790.             {
  1791.                 pl = GetLang_1( psz );
  1792.             }
  1793.             else if( strlen( psz ) == 3 )
  1794.             {
  1795.                 pl = GetLang_2B( psz );
  1796.                 if( !strcmp( pl->psz_iso639_1, "??" ) )
  1797.                 {
  1798.                     pl = GetLang_2T( psz );
  1799.                 }
  1800.             }
  1801.             if( pl && strcmp( pl->psz_iso639_1, "??" ) )
  1802.             {
  1803.                 lang = ( ( pl->psz_iso639_2T[0] - 0x60 ) << 10 ) |
  1804.                        ( ( pl->psz_iso639_2T[1] - 0x60 ) <<  5 ) |
  1805.                        ( ( pl->psz_iso639_2T[2] - 0x60 ) );
  1806.             }
  1807.             bo_add_16be( mdhd, lang );          // language
  1808.         }
  1809.         else
  1810.         {
  1811.             bo_add_16be( mdhd, 0    );          // language
  1812.         }
  1813.         bo_add_16be( mdhd, 0    );              // predefined
  1814.         box_fix( mdhd );
  1815.         box_gather( mdia, mdhd );
  1817.         /* handler reference */
  1818.         hdlr = box_full_new( "hdlr", 0, 0 );
  1820.         if( p_sys->b_mov )
  1821.             bo_add_fourcc( hdlr, "mhlr" );         // media handler
  1822.         else
  1823.             bo_add_32be( hdlr, 0 );
  1825.         if( p_stream->fmt.i_cat == AUDIO_ES )
  1826.             bo_add_fourcc( hdlr, "soun" );
  1827.         else if( p_stream->fmt.i_cat == VIDEO_ES )
  1828.             bo_add_fourcc( hdlr, "vide" );
  1829.         else if( p_stream->fmt.i_cat == SPU_ES )
  1830.             bo_add_fourcc( hdlr, "text" );
  1832.         bo_add_32be( hdlr, 0 );         // reserved
  1833.         bo_add_32be( hdlr, 0 );         // reserved
  1834.         bo_add_32be( hdlr, 0 );         // reserved
  1836.         if( p_sys->b_mov )
  1837.             bo_add_8( hdlr, 12 );   /* Pascal string for .mov */
  1839.         if( p_stream->fmt.i_cat == AUDIO_ES )
  1840.             bo_add_mem( hdlr, 12, (uint8_t*)"SoundHandler" );
  1841.         else if( p_stream->fmt.i_cat == VIDEO_ES )
  1842.             bo_add_mem( hdlr, 12, (uint8_t*)"VideoHandler" );
  1843.         else
  1844.             bo_add_mem( hdlr, 12, (uint8_t*)"Text Handler" );
  1846.         if( !p_sys->b_mov )
  1847.             bo_add_8( hdlr, 0 );   /* asciiz string for .mp4, yes that's BRAIN DAMAGED F**K MP4 */
  1849.         box_fix( hdlr );
  1850.         box_gather( mdia, hdlr );
  1852.         /* minf*/
  1853.         minf = box_new( "minf" );
  1855.         /* add smhd|vmhd */
  1856.         if( p_stream->fmt.i_cat == AUDIO_ES )
  1857.         {
  1858.             bo_t *smhd;
  1860.             smhd = box_full_new( "smhd", 0, 0 );
  1861.             bo_add_16be( smhd, 0 );     // balance
  1862.             bo_add_16be( smhd, 0 );     // reserved
  1863.             box_fix( smhd );
  1865.             box_gather( minf, smhd );
  1866.         }
  1867.         else if( p_stream->fmt.i_cat == VIDEO_ES )
  1868.         {
  1869.             bo_t *vmhd;
  1871.             vmhd = box_full_new( "vmhd", 0, 1 );
  1872.             bo_add_16be( vmhd, 0 );     // graphicsmode
  1873.             for( i = 0; i < 3; i++ )
  1874.             {
  1875.                 bo_add_16be( vmhd, 0 ); // opcolor
  1876.             }
  1877.             box_fix( vmhd );
  1879.             box_gather( minf, vmhd );
  1880.         }
  1881.         else if( p_stream->fmt.i_cat == SPU_ES )
  1882.         {
  1883.             bo_t *gmhd = box_new( "gmhd" );
  1884.             bo_t *gmin = box_full_new( "gmin", 0, 1 );
  1886.             bo_add_16be( gmin, 0 );     // graphicsmode
  1887.             for( i = 0; i < 3; i++ )
  1888.             {
  1889.                 bo_add_16be( gmin, 0 ); // opcolor
  1890.             }
  1891.             bo_add_16be( gmin, 0 );     // balance
  1892.             bo_add_16be( gmin, 0 );     // reserved
  1893.             box_fix( gmin );
  1895.             box_gather( gmhd, gmin );
  1896.             box_fix( gmhd );
  1898.             box_gather( minf, gmhd );
  1899.         }
  1901.         /* dinf */
  1902.         dinf = box_new( "dinf" );
  1903.         dref = box_full_new( "dref", 0, 0 );
  1904.         bo_add_32be( dref, 1 );
  1905.         url = box_full_new( "url ", 0, 0x01 );
  1906.         box_fix( url );
  1907.         box_gather( dref, url );
  1908.         box_fix( dref );
  1909.         box_gather( dinf, dref );
  1911.         /* append dinf to mdia */
  1912.         box_fix( dinf );
  1913.         box_gather( minf, dinf );
  1915.         /* add stbl */
  1916.         stbl = GetStblBox( p_mux, p_stream );
  1918.         /* append stbl to minf */
  1919.         p_stream->i_stco_pos += minf->i_buffer;
  1920.         box_gather( minf, stbl );
  1922.         /* append minf to mdia */
  1923.         box_fix( minf );
  1924.         p_stream->i_stco_pos += mdia->i_buffer;
  1925.         box_gather( mdia, minf );
  1927.         /* append mdia to trak */
  1928.         box_fix( mdia );
  1929.         p_stream->i_stco_pos += trak->i_buffer;
  1930.         box_gather( trak, mdia );
  1932.         /* append trak to moov */
  1933.         box_fix( trak );
  1934.         p_stream->i_stco_pos += moov->i_buffer;
  1935.         box_gather( moov, trak );
  1936.     }
  1938.     /* Add user data tags */
  1939.     box_gather( moov, GetUdtaTag( p_mux ) );
  1941.     box_fix( moov );
  1942.     return moov;
  1943. }
  1945. /****************************************************************************/
  1947. static void bo_init( bo_t *p_bo, int i_size, uint8_t *p_buffer,
  1948.                      bool b_grow )
  1949. {
  1950.     if( !p_buffer )
  1951.     {
  1952.         p_bo->i_buffer_size = __MAX( i_size, 1024 );
  1953.         p_bo->p_buffer = malloc( p_bo->i_buffer_size );
  1954.     }
  1955.     else
  1956.     {
  1957.         p_bo->i_buffer_size = i_size;
  1958.         p_bo->p_buffer = p_buffer;
  1959.     }
  1961.     p_bo->b_grow = b_grow;
  1962.     p_bo->i_buffer = 0;
  1963. }
  1965. static void bo_add_8( bo_t *p_bo, uint8_t i )
  1966. {
  1967.     if( p_bo->i_buffer < p_bo->i_buffer_size )
  1968.     {
  1969.         p_bo->p_buffer[p_bo->i_buffer] = i;
  1970.     }
  1971.     else if( p_bo->b_grow )
  1972.     {
  1973.         p_bo->i_buffer_size += 1024;
  1974.         p_bo->p_buffer = realloc( p_bo->p_buffer, p_bo->i_buffer_size );
  1976.         p_bo->p_buffer[p_bo->i_buffer] = i;
  1977.     }
  1979.     p_bo->i_buffer++;
  1980. }
  1982. static void bo_add_16be( bo_t *p_bo, uint16_t i )
  1983. {
  1984.     bo_add_8( p_bo, ( ( i >> 8) &0xff ) );
  1985.     bo_add_8( p_bo, i &0xff );
  1986. }
  1988. static void bo_add_24be( bo_t *p_bo, uint32_t i )
  1989. {
  1990.     bo_add_8( p_bo, ( ( i >> 16) &0xff ) );
  1991.     bo_add_8( p_bo, ( ( i >> 8) &0xff ) );
  1992.     bo_add_8( p_bo, (   i &0xff ) );
  1993. }
  1994. static void bo_add_32be( bo_t *p_bo, uint32_t i )
  1995. {
  1996.     bo_add_16be( p_bo, ( ( i >> 16) &0xffff ) );
  1997.     bo_add_16be( p_bo, i &0xffff );
  1998. }
  2000. static void bo_fix_32be ( bo_t *p_bo, int i_pos, uint32_t i)
  2001. {
  2002.     p_bo->p_buffer[i_pos    ] = ( i >> 24 )&0xff;
  2003.     p_bo->p_buffer[i_pos + 1] = ( i >> 16 )&0xff;
  2004.     p_bo->p_buffer[i_pos + 2] = ( i >>  8 )&0xff;
  2005.     p_bo->p_buffer[i_pos + 3] = ( i       )&0xff;
  2006. }
  2008. static void bo_add_64be( bo_t *p_bo, uint64_t i )
  2009. {
  2010.     bo_add_32be( p_bo, ( ( i >> 32) &0xffffffff ) );
  2011.     bo_add_32be( p_bo, i &0xffffffff );
  2012. }
  2014. static void bo_add_fourcc( bo_t *p_bo, const char *fcc )
  2015. {
  2016.     bo_add_8( p_bo, fcc[0] );
  2017.     bo_add_8( p_bo, fcc[1] );
  2018.     bo_add_8( p_bo, fcc[2] );
  2019.     bo_add_8( p_bo, fcc[3] );
  2020. }
  2022. static void bo_add_mem( bo_t *p_bo, int i_size, uint8_t *p_mem )
  2023. {
  2024.     int i;
  2026.     for( i = 0; i < i_size; i++ )
  2027.     {
  2028.         bo_add_8( p_bo, p_mem[i] );
  2029.     }
  2030. }
  2032. static void bo_add_descr( bo_t *p_bo, uint8_t tag, uint32_t i_size )
  2033. {
  2034.     uint32_t i_length;
  2035.     uint8_t  vals[4];
  2037.     i_length = i_size;
  2038.     vals[3] = (unsigned char)(i_length & 0x7f);
  2039.     i_length >>= 7;
  2040.     vals[2] = (unsigned char)((i_length & 0x7f) | 0x80);
  2041.     i_length >>= 7;
  2042.     vals[1] = (unsigned char)((i_length & 0x7f) | 0x80);
  2043.     i_length >>= 7;
  2044.     vals[0] = (unsigned char)((i_length & 0x7f) | 0x80);
  2046.     bo_add_8( p_bo, tag );
  2048.     if( i_size < 0x00000080 )
  2049.     {
  2050.         bo_add_8( p_bo, vals[3] );
  2051.     }
  2052.     else if( i_size < 0x00004000 )
  2053.     {
  2054.         bo_add_8( p_bo, vals[2] );
  2055.         bo_add_8( p_bo, vals[3] );
  2056.     }
  2057.     else if( i_size < 0x00200000 )
  2058.     {
  2059.         bo_add_8( p_bo, vals[1] );
  2060.         bo_add_8( p_bo, vals[2] );
  2061.         bo_add_8( p_bo, vals[3] );
  2062.     }
  2063.     else if( i_size < 0x10000000 )
  2064.     {
  2065.         bo_add_8( p_bo, vals[0] );
  2066.         bo_add_8( p_bo, vals[1] );
  2067.         bo_add_8( p_bo, vals[2] );
  2068.         bo_add_8( p_bo, vals[3] );
  2069.     }
  2070. }
  2072. static void bo_add_bo( bo_t *p_bo, bo_t *p_bo2 )
  2073. {
  2074.     int i;
  2076.     for( i = 0; i < p_bo2->i_buffer; i++ )
  2077.     {
  2078.         bo_add_8( p_bo, p_bo2->p_buffer[i] );
  2079.     }
  2080. }
  2082. static bo_t * box_new( const char *fcc )
  2083. {
  2084.     bo_t *box;
  2086.     if( ( box = malloc( sizeof( bo_t ) ) ) )
  2087.     {
  2088.         bo_init( box, 0, NULL, true );
  2090.         bo_add_32be  ( box, 0 );
  2091.         bo_add_fourcc( box, fcc );
  2092.     }
  2094.     return box;
  2095. }
  2097. static bo_t * box_full_new( const char *fcc, uint8_t v, uint32_t f )
  2098. {
  2099.     bo_t *box;
  2101.     if( ( box = malloc( sizeof( bo_t ) ) ) )
  2102.     {
  2103.         bo_init( box, 0, NULL, true );
  2105.         bo_add_32be  ( box, 0 );
  2106.         bo_add_fourcc( box, fcc );
  2107.         bo_add_8     ( box, v );
  2108.         bo_add_24be  ( box, f );
  2109.     }
  2111.     return box;
  2112. }
  2114. static void box_fix( bo_t *box )
  2115. {
  2116.     bo_t box_tmp;
  2118.     memcpy( &box_tmp, box, sizeof( bo_t ) );
  2120.     box_tmp.i_buffer = 0;
  2121.     bo_add_32be( &box_tmp, box->i_buffer );
  2122. }
  2124. static void box_free( bo_t *box )
  2125. {
  2126.     free( box->p_buffer );
  2127.     free( box );
  2128. }
  2130. static void box_gather ( bo_t *box, bo_t *box2 )
  2131. {
  2132.     bo_add_bo( box, box2 );
  2133.     box_free( box2 );
  2134. }
  2136. static block_t * bo_to_sout( sout_instance_t *p_sout,  bo_t *box )
  2137. {
  2138.     (void)p_sout;
  2139.     block_t *p_buf;
  2141.     p_buf = block_New( p_sout, box->i_buffer );
  2142.     if( box->i_buffer > 0 )
  2143.     {
  2144.         memcpy( p_buf->p_buffer, box->p_buffer, box->i_buffer );
  2145.     }
  2147.     return p_buf;
  2148. }
  2150. static void box_send( sout_mux_t *p_mux,  bo_t *box )
  2151. {
  2152.     block_t *p_buf;
  2154.     p_buf = bo_to_sout( p_mux->p_sout, box );
  2155.     box_free( box );
  2157.     sout_AccessOutWrite( p_mux->p_access, p_buf );
  2158. }
  2160. static int64_t get_timestamp(void)
  2161. {
  2162.     int64_t i_timestamp = time(NULL);
  2164.     i_timestamp += 2082844800; // MOV/MP4 start date is 1/1/1904
  2165.     // 208284480 is (((1970 - 1904) * 365) + 17) * 24 * 60 * 60
  2167.     return i_timestamp;
  2168. }