[vlc-devel] [PATCH 3/5] input: es_out_timeshift: store commands as different sizes
Rémi Denis-Courmont
remi at remlab.net
Thu Apr 23 16:16:36 CEST 2020
Le torstaina 23. huhtikuuta 2020, 14.00.12 EEST Francois Cartegnie a écrit :
> ---
> src/input/es_out_timeshift.c | 424 +++++++++++++++++++----------------
> 1 file changed, 226 insertions(+), 198 deletions(-)
>
> diff --git a/src/input/es_out_timeshift.c b/src/input/es_out_timeshift.c
> index 6f1561cc89..7704b4f4b3 100644
> --- a/src/input/es_out_timeshift.c
> +++ b/src/input/es_out_timeshift.c
> @@ -59,16 +59,22 @@
> # define attribute_packed
> #endif
>
> -enum
> +enum ts_storage_cmd_type_e
> {
> - C_ADD,
> + C_ADD = 0,
> C_SEND,
> C_DEL,
> C_CONTROL,
> + C_PRIVCONTROL,
> };
>
> +#define TIMESHIFT_CMD_HEADER \
> + int8_t i_type;\
> + vlc_tick_t i_date
I don't see the point having a macro here. And having 64-bits timestamps does
not strike me as saving space if it comes to that.
> +
> typedef struct attribute_packed
> {
> + TIMESHIFT_CMD_HEADER;
> input_source_t *in;
> es_out_id_t *p_es;
> es_format_t *p_fmt;
> @@ -76,11 +82,13 @@ typedef struct attribute_packed
>
> typedef struct attribute_packed
> {
> + TIMESHIFT_CMD_HEADER;
> es_out_id_t *p_es;
> } ts_cmd_del_t;
>
> typedef struct attribute_packed
> {
> + TIMESHIFT_CMD_HEADER;
> es_out_id_t *p_es;
> block_t *p_block;
> int i_offset; /* We do not use file > INT_MAX */
> @@ -88,8 +96,9 @@ typedef struct attribute_packed
>
> typedef struct attribute_packed
> {
> - input_source_t *in;
> + TIMESHIFT_CMD_HEADER;
> int i_query;
> + input_source_t *in;
>
> union
> {
> @@ -137,6 +146,7 @@ typedef struct attribute_packed
>
> typedef struct attribute_packed
> {
> + TIMESHIFT_CMD_HEADER;
> int i_query;
>
> union
> @@ -160,16 +170,17 @@ typedef struct attribute_packed
>
> typedef struct attribute_packed
> {
> - int8_t i_type;
> - vlc_tick_t i_date;
> - union
> - {
> - ts_cmd_add_t add;
> - ts_cmd_del_t del;
> - ts_cmd_send_t send;
> - ts_cmd_control_t control;
> - ts_cmd_privcontrol_t privcontrol;
> - } u;
> + TIMESHIFT_CMD_HEADER;
> +} ts_cmd_header_t;
> +
> +typedef union
> +{
> + ts_cmd_header_t header;
> + ts_cmd_add_t add;
> + ts_cmd_del_t del;
> + ts_cmd_send_t send;
> + ts_cmd_control_t control;
> + ts_cmd_privcontrol_t privcontrol;
> } ts_cmd_t;
>
> typedef struct ts_storage_t ts_storage_t;
> @@ -286,23 +297,23 @@ static void TsStoragePopCmd( ts_storage_t
> *p_storage, ts_cmd_t *p_cmd, b
>
> static void CmdClean( ts_cmd_t * );
>
> -static int CmdInitAdd ( ts_cmd_t *, input_source_t *, es_out_id_t *,
> const es_format_t *, bool b_copy ); -static void CmdInitSend ( ts_cmd_t
> *, es_out_id_t *, block_t * ); -static int CmdInitDel ( ts_cmd_t *,
> es_out_id_t * );
> -static int CmdInitControl( ts_cmd_t *, input_source_t *, int i_query,
> va_list, bool b_copy ); -static int CmdInitPrivControl( ts_cmd_t *, int
> i_query, va_list, bool b_copy ); +static int CmdInitAdd ( ts_cmd_add_t
> *, input_source_t *, es_out_id_t *, const es_format_t *, bool b_copy );
> +static void CmdInitSend ( ts_cmd_send_t *, es_out_id_t *, block_t * );
> +static int CmdInitDel ( ts_cmd_del_t *, es_out_id_t * );
> +static int CmdInitControl( ts_cmd_control_t *, input_source_t *, int
> i_query, va_list, bool b_copy ); +static int CmdInitPrivControl(
> ts_cmd_privcontrol_t *, int i_query, va_list, bool b_copy );
>
> /* */
> -static void CmdCleanAdd ( ts_cmd_t * );
> -static void CmdCleanSend ( ts_cmd_t * );
> -static void CmdCleanControl( ts_cmd_t *p_cmd );
> +static void CmdCleanAdd ( ts_cmd_add_t * );
> +static void CmdCleanSend ( ts_cmd_send_t * );
> +static void CmdCleanControl( ts_cmd_control_t * );
>
> /* XXX these functions will take the destination es_out_t */
> -static void CmdExecuteAdd ( es_out_t *, ts_cmd_t * );
> -static int CmdExecuteSend ( es_out_t *, ts_cmd_t * );
> -static void CmdExecuteDel ( es_out_t *, ts_cmd_t * );
> -static int CmdExecuteControl( es_out_t *, ts_cmd_t * );
> -static int CmdExecutePrivControl( es_out_t *, ts_cmd_t * );
> +static void CmdExecuteAdd ( es_out_t *, ts_cmd_add_t * );
> +static int CmdExecuteSend ( es_out_t *, ts_cmd_send_t * );
> +static void CmdExecuteDel ( es_out_t *, ts_cmd_del_t * );
> +static int CmdExecuteControl( es_out_t *, ts_cmd_control_t * );
> +static int CmdExecutePrivControl( es_out_t *, ts_cmd_privcontrol_t * );
>
> /* File helpers */
> static int GetTmpFile( char **ppsz_file, const char *psz_path );
> @@ -389,9 +400,10 @@ es_out_t *input_EsOutTimeshiftNew( input_thread_t
> *p_input, es_out_t *p_next_out msg_Dbg( p_input, "using default timeshift
> path" );
>
> #if 0
> -#define S(t) msg_Err( p_input, "SIZEOF("#t")=%d", sizeof(t) )
> +#define S(t) msg_Err( p_input, "SIZEOF("#t")=%zd", sizeof(t) )
> S(ts_cmd_t);
> S(ts_cmd_control_t);
> + S(ts_cmd_privcontrol_t);
> S(ts_cmd_send_t);
> S(ts_cmd_del_t);
> S(ts_cmd_add_t);
> @@ -425,7 +437,7 @@ static void Destroy( es_out_t *p_out )
> static es_out_id_t *Add( es_out_t *p_out, input_source_t *in, const
> es_format_t *p_fmt ) {
> es_out_sys_t *p_sys = container_of(p_out, es_out_sys_t, out);
> - ts_cmd_t cmd;
> + ts_cmd_add_t cmd;
>
> es_out_id_t *p_es = malloc( sizeof( *p_es ) );
> if( !p_es )
> @@ -445,7 +457,7 @@ static es_out_id_t *Add( es_out_t *p_out, input_source_t
> *in, const es_format_t TAB_APPEND( p_sys->i_es, p_sys->pp_es, p_es );
>
> if( p_sys->b_delayed )
> - TsPushCmd( p_sys->p_ts, &cmd );
> + TsPushCmd( p_sys->p_ts, (ts_cmd_t *) &cmd );
> else
> CmdExecuteAdd( p_sys->p_out, &cmd );
>
> @@ -456,7 +468,7 @@ static es_out_id_t *Add( es_out_t *p_out, input_source_t
> *in, const es_format_t static int Send( es_out_t *p_out, es_out_id_t *p_es,
> block_t *p_block ) {
> es_out_sys_t *p_sys = container_of(p_out, es_out_sys_t, out);
> - ts_cmd_t cmd;
> + ts_cmd_send_t cmd;
> int i_ret = VLC_SUCCESS;
>
> vlc_mutex_lock( &p_sys->lock );
> @@ -465,7 +477,7 @@ static int Send( es_out_t *p_out, es_out_id_t *p_es,
> block_t *p_block )
>
> CmdInitSend( &cmd, p_es, p_block );
> if( p_sys->b_delayed )
> - TsPushCmd( p_sys->p_ts, &cmd );
> + TsPushCmd( p_sys->p_ts, (ts_cmd_t *)&cmd );
> else
> i_ret = CmdExecuteSend( p_sys->p_out, &cmd) ;
>
> @@ -476,7 +488,7 @@ static int Send( es_out_t *p_out, es_out_id_t *p_es,
> block_t *p_block ) static void Del( es_out_t *p_out, es_out_id_t *p_es )
> {
> es_out_sys_t *p_sys = container_of(p_out, es_out_sys_t, out);
> - ts_cmd_t cmd;
> + ts_cmd_del_t cmd;
>
> vlc_mutex_lock( &p_sys->lock );
>
> @@ -484,7 +496,7 @@ static void Del( es_out_t *p_out, es_out_id_t *p_es )
>
> CmdInitDel( &cmd, p_es );
> if( p_sys->b_delayed )
> - TsPushCmd( p_sys->p_ts, &cmd );
> + TsPushCmd( p_sys->p_ts, (ts_cmd_t *)&cmd );
> else
> CmdExecuteDel( p_sys->p_out, &cmd );
>
> @@ -659,12 +671,12 @@ static int ControlLocked( es_out_t *p_out,
> input_source_t *in, int i_query, case ES_OUT_SET_ES_CAT_POLICY:
> case ES_OUT_SET_ES_FMT:
> {
> - ts_cmd_t cmd;
> + ts_cmd_control_t cmd;
> if( CmdInitControl( &cmd, in, i_query, args, p_sys->b_delayed ) )
> return VLC_EGENERIC;
> if( p_sys->b_delayed )
> {
> - TsPushCmd( p_sys->p_ts, &cmd );
> + TsPushCmd( p_sys->p_ts, (ts_cmd_t *) &cmd );
> return VLC_SUCCESS;
> }
> return CmdExecuteControl( p_sys->p_out, &cmd );
> @@ -775,14 +787,14 @@ static int PrivControlLocked( es_out_t *p_out, int
> i_query, va_list args ) case ES_OUT_PRIV_SET_EOS:
> {
> ts_cmd_t cmd;
> - if( CmdInitPrivControl( &cmd, i_query, args, p_sys->b_delayed ) )
> + if( CmdInitPrivControl( &cmd.privcontrol, i_query, args,
> p_sys->b_delayed ) ) return VLC_EGENERIC;
> if( p_sys->b_delayed )
> {
> TsPushCmd( p_sys->p_ts, &cmd );
> return VLC_SUCCESS;
> }
> - return CmdExecutePrivControl( p_sys->p_out, &cmd );
> + return CmdExecutePrivControl( p_sys->p_out, &cmd.privcontrol );
> }
> case ES_OUT_PRIV_GET_WAKE_UP: /* TODO ? */
> {
> @@ -1095,24 +1107,24 @@ static void *TsRun( void *p_data )
>
> if( b_buffering && i_buffering_date < 0 )
> {
> - i_buffering_date = cmd.i_date;
> + i_buffering_date = cmd.header.i_date;
> }
> else if( i_buffering_date > 0 )
> {
> - p_ts->i_buffering_delay += i_buffering_date - cmd.i_date; /* It
> is < 0 */ + p_ts->i_buffering_delay += i_buffering_date -
> cmd.header.i_date; /* It is < 0 */ if( b_buffering )
> - i_buffering_date = cmd.i_date;
> + i_buffering_date = cmd.header.i_date;
> else
> i_buffering_date = -1;
> }
>
> if( p_ts->i_rate_date < 0 )
> - p_ts->i_rate_date = cmd.i_date;
> + p_ts->i_rate_date = cmd.header.i_date;
>
> p_ts->i_rate_delay = 0;
> if( p_ts->rate_source != p_ts->rate )
> {
> - const vlc_tick_t i_duration = cmd.i_date - p_ts->i_rate_date;
> + const vlc_tick_t i_duration = cmd.header.i_date -
> p_ts->i_rate_date; p_ts->i_rate_delay = i_duration * p_ts->rate_source /
> p_ts->rate - i_duration; }
> if( p_ts->i_cmd_delay + p_ts->i_rate_delay +
> p_ts->i_buffering_delay < 0 && p_ts->rate != p_ts->rate_source ) @@ -1136,7
> +1148,7 @@ static void *TsRun( void *p_data )
> input_ControlPushHelper( p_ts->p_input,
> INPUT_CONTROL_SET_RATE, &val ); }
> }
> - i_deadline = cmd.i_date + p_ts->i_cmd_delay + p_ts->i_rate_delay +
> p_ts->i_buffering_delay; + i_deadline = cmd.header.i_date +
> p_ts->i_cmd_delay + p_ts->i_rate_delay + p_ts->i_buffering_delay;
>
> vlc_mutex_unlock( &p_ts->lock );
>
> @@ -1149,22 +1161,25 @@ static void *TsRun( void *p_data )
> }
>
> /* Execute the command */
> - switch( cmd.i_type )
> + switch( cmd.header.i_type )
> {
> case C_ADD:
> - CmdExecuteAdd( p_ts->p_out, &cmd );
> - CmdCleanAdd( &cmd );
> + CmdExecuteAdd( p_ts->p_out, &cmd.add );
> + CmdCleanAdd( &cmd.add );
> break;
> case C_SEND:
> - CmdExecuteSend( p_ts->p_out, &cmd );
> - CmdCleanSend( &cmd );
> + CmdExecuteSend( p_ts->p_out, &cmd.send );
> + CmdCleanSend( &cmd.send );
> break;
> case C_CONTROL:
> - CmdExecuteControl( p_ts->p_out, &cmd );
> - CmdCleanControl( &cmd );
> + CmdExecuteControl( p_ts->p_out, &cmd.control );
> + CmdCleanControl( &cmd.control );
> + break;
> + case C_PRIVCONTROL:
> + CmdExecutePrivControl( p_ts->p_out, &cmd.privcontrol );
> break;
> case C_DEL:
> - CmdExecuteDel( p_ts->p_out, &cmd );
> + CmdExecuteDel( p_ts->p_out, &cmd.del );
> break;
> default:
> vlc_assert_unreachable();
> @@ -1182,6 +1197,15 @@ static void *TsRun( void *p_data )
> #define MAX_COMMAND_SIZE sizeof(ts_cmd_t)
> #define TS_STORAGE_COMMAND_PREALLOC 30000
>
> +static const size_t TsStorageSizeofCommand[] =
> +{
> + [C_ADD] = sizeof(ts_cmd_add_t),
> + [C_SEND] = sizeof(ts_cmd_send_t),
> + [C_DEL] = sizeof(ts_cmd_del_t),
> + [C_CONTROL] = sizeof(ts_cmd_control_t),
> + [C_PRIVCONTROL] = sizeof(ts_cmd_privcontrol_t)
> +};
> +
> static ts_storage_t *TsStorageNew( const char *psz_tmp_path, int64_t
> i_tmp_size_max ) {
> ts_storage_t *p_storage = malloc( sizeof (*p_storage) );
> @@ -1283,9 +1307,9 @@ static void TsStoragePack( ts_storage_t *p_storage )
>
> static bool TsStorageIsFull( ts_storage_t *p_storage, const ts_cmd_t *p_cmd
> ) {
> - if( p_cmd && p_cmd->i_type == C_SEND && p_storage->p_cmd_w )
> + if( p_cmd && p_cmd->header.i_type == C_SEND && p_storage->p_cmd_w )
> {
> - size_t i_size = sizeof(*p_cmd->u.send.p_block) +
> p_cmd->u.send.p_block->i_buffer; + size_t i_size =
> sizeof(*p_cmd->send.p_block) + p_cmd->send.p_block->i_buffer;
>
> if( p_storage->i_file_size + i_size >= p_storage->i_file_max )
> return true;
> @@ -1300,16 +1324,15 @@ static bool TsStorageIsEmpty( ts_storage_t
> *p_storage )
>
> static void TsStoragePushCmd( ts_storage_t *p_storage, const ts_cmd_t
> *p_cmd, bool b_flush ) {
> - ts_cmd_t cmd = *p_cmd;
> -
> assert( !TsStorageIsFull( p_storage, p_cmd ) );
> + ts_cmd_t cmd = *p_cmd;
>
> - if( cmd.i_type == C_SEND )
> + if( cmd.header.i_type == C_SEND )
> {
> - block_t *p_block = cmd.u.send.p_block;
> + block_t *p_block = cmd.send.p_block;
>
> - cmd.u.send.p_block = NULL;
> - cmd.u.send.i_offset = ftell( p_storage->p_filew );
> + cmd.send.p_block = NULL;
> + cmd.send.i_offset = ftell( p_storage->p_filew );
>
> if( fwrite( p_block, sizeof(*p_block), 1, p_storage->p_filew ) != 1
> ) {
> @@ -1331,24 +1354,26 @@ static void TsStoragePushCmd( ts_storage_t
> *p_storage, const ts_cmd_t *p_cmd, bo if( b_flush )
> fflush( p_storage->p_filew );
> }
> -
> - memcpy( p_storage->p_cmd_w, &cmd, sizeof(cmd) );
> - p_storage->p_cmd_w += sizeof(cmd);
> + size_t i_cmdsize = TsStorageSizeofCommand[ cmd.header.i_type ];
> + memcpy( p_storage->p_cmd_w, &cmd, i_cmdsize );
> + p_storage->p_cmd_w += i_cmdsize;
> }
>
> static void TsStoragePopCmd( ts_storage_t *p_storage, ts_cmd_t *p_cmd, bool
> b_flush ) {
> assert( !TsStorageIsEmpty( p_storage ) );
>
> - memcpy(p_cmd, p_storage->p_cmd_r, sizeof(ts_cmd_t));
> - p_storage->p_cmd_r += sizeof(ts_cmd_t);
> + p_cmd->header.i_type = p_storage->p_cmd_r[0];
> + size_t i_cmdsize = TsStorageSizeofCommand[ p_cmd->header.i_type ];
> + memcpy(p_cmd, p_storage->p_cmd_r, i_cmdsize);
> + p_storage->p_cmd_r += i_cmdsize;
>
> - if( p_cmd->i_type == C_SEND )
> + if( p_cmd->header.i_type == C_SEND )
> {
> block_t block;
>
> if( !b_flush &&
> - !fseek( p_storage->p_filer, p_cmd->u.send.i_offset, SEEK_SET )
> && + !fseek( p_storage->p_filer, p_cmd->send.i_offset, SEEK_SET
> ) && fread( &block, sizeof(block), 1, p_storage->p_filer ) == 1 ) {
> block_t *p_block = block_Alloc( block.i_buffer );
> @@ -1361,12 +1386,12 @@ static void TsStoragePopCmd( ts_storage_t
> *p_storage, ts_cmd_t *p_cmd, bool b_fl p_block->i_nb_samples =
> block.i_nb_samples;
> p_block->i_buffer = fread( p_block->p_buffer, 1,
> block.i_buffer, p_storage->p_filer ); }
> - p_cmd->u.send.p_block = p_block;
> + p_cmd->send.p_block = p_block;
> }
> else
> {
> //perror( "TsStoragePopCmd" );
> - p_cmd->u.send.p_block = block_Alloc( 1 );
> + p_cmd->send.p_block = block_Alloc( 1 );
> }
> }
> }
> @@ -1376,16 +1401,18 @@ static void TsStoragePopCmd( ts_storage_t
> *p_storage, ts_cmd_t *p_cmd, bool b_fl
> ***************************************************************************
> **/ static void CmdClean( ts_cmd_t *p_cmd )
> {
> - switch( p_cmd->i_type )
> + switch( p_cmd->header.i_type )
> {
> case C_ADD:
> - CmdCleanAdd( p_cmd );
> + CmdCleanAdd( &p_cmd->add );
> break;
> case C_SEND:
> - CmdCleanSend( p_cmd );
> + CmdCleanSend( &p_cmd->send );
> break;
> case C_CONTROL:
> - CmdCleanControl( p_cmd );
> + CmdCleanControl( &p_cmd->control );
> + break;
> + case C_PRIVCONTROL:
> break;
> case C_DEL:
> break;
> @@ -1395,114 +1422,115 @@ static void CmdClean( ts_cmd_t *p_cmd )
> }
> }
>
> -static int CmdInitAdd( ts_cmd_t *p_cmd, input_source_t *in, es_out_id_t
> *p_es, +static int CmdInitAdd( ts_cmd_add_t *p_cmd, input_source_t *in,
> es_out_id_t *p_es, const es_format_t *p_fmt, bool b_copy )
> {
> p_cmd->i_type = C_ADD;
> p_cmd->i_date = vlc_tick_now();
> - p_cmd->u.add.p_es = p_es;
> + p_cmd->p_es = p_es;
> if( b_copy )
> {
> - p_cmd->u.add.p_fmt = malloc( sizeof(*p_fmt) );
> - if( !p_cmd->u.add.p_fmt )
> + p_cmd->p_fmt = malloc( sizeof(*p_fmt) );
> + if( !p_cmd->p_fmt )
> return VLC_EGENERIC;
> - es_format_Copy( p_cmd->u.add.p_fmt, p_fmt );
> - p_cmd->u.add.in = in ? input_source_Hold( in ) : NULL;
> + es_format_Copy( p_cmd->p_fmt, p_fmt );
> + p_cmd->in = in ? input_source_Hold( in ) : NULL;
> }
> else
> {
> - p_cmd->u.add.p_fmt = (es_format_t*)p_fmt;
> - p_cmd->u.add.in = in;
> + p_cmd->p_fmt = (es_format_t*)p_fmt;
> + p_cmd->in = in;
> }
> return VLC_SUCCESS;
> }
> -static void CmdExecuteAdd( es_out_t *p_out, ts_cmd_t *p_cmd )
> +
> +static void CmdExecuteAdd( es_out_t *p_out, ts_cmd_add_t *p_cmd )
> {
> - p_cmd->u.add.p_es->p_es = p_out->cbs->add( p_out, p_cmd->u.add.in,
> - p_cmd->u.add.p_fmt );
> + p_cmd->p_es->p_es = p_out->cbs->add( p_out, p_cmd->in,
> + p_cmd->p_fmt );
> }
> -static void CmdCleanAdd( ts_cmd_t *p_cmd )
> +static void CmdCleanAdd( ts_cmd_add_t *p_cmd )
> {
> - es_format_Clean( p_cmd->u.add.p_fmt );
> - if( p_cmd->u.add.in )
> - input_source_Release( p_cmd->u.add.in );
> - free( p_cmd->u.add.p_fmt );
> + es_format_Clean( p_cmd->p_fmt );
> + if( p_cmd->in )
> + input_source_Release( p_cmd->in );
> + free( p_cmd->p_fmt );
> }
>
> -static void CmdInitSend( ts_cmd_t *p_cmd, es_out_id_t *p_es, block_t
> *p_block ) +static void CmdInitSend( ts_cmd_send_t *p_cmd, es_out_id_t
> *p_es, block_t *p_block ) {
> p_cmd->i_type = C_SEND;
> p_cmd->i_date = vlc_tick_now();
> - p_cmd->u.send.p_es = p_es;
> - p_cmd->u.send.p_block = p_block;
> + p_cmd->p_es = p_es;
> + p_cmd->p_block = p_block;
> }
> -static int CmdExecuteSend( es_out_t *p_out, ts_cmd_t *p_cmd )
> +static int CmdExecuteSend( es_out_t *p_out, ts_cmd_send_t *p_cmd )
> {
> - block_t *p_block = p_cmd->u.send.p_block;
> + block_t *p_block = p_cmd->p_block;
>
> - p_cmd->u.send.p_block = NULL;
> + p_cmd->p_block = NULL;
>
> if( p_block )
> {
> - if( p_cmd->u.send.p_es->p_es )
> - return es_out_Send( p_out, p_cmd->u.send.p_es->p_es, p_block );
> + if( p_cmd->p_es->p_es )
> + return es_out_Send( p_out, p_cmd->p_es->p_es, p_block );
> block_Release( p_block );
> }
> return VLC_EGENERIC;
> }
> -static void CmdCleanSend( ts_cmd_t *p_cmd )
> +static void CmdCleanSend( ts_cmd_send_t *p_cmd )
> {
> - if( p_cmd->u.send.p_block )
> - block_Release( p_cmd->u.send.p_block );
> + if( p_cmd->p_block )
> + block_Release( p_cmd->p_block );
> }
>
> -static int CmdInitDel( ts_cmd_t *p_cmd, es_out_id_t *p_es )
> +static int CmdInitDel( ts_cmd_del_t *p_cmd, es_out_id_t *p_es )
> {
> p_cmd->i_type = C_DEL;
> p_cmd->i_date = vlc_tick_now();
> - p_cmd->u.del.p_es = p_es;
> + p_cmd->p_es = p_es;
> return VLC_SUCCESS;
> }
> -static void CmdExecuteDel( es_out_t *p_out, ts_cmd_t *p_cmd )
> +static void CmdExecuteDel( es_out_t *p_out, ts_cmd_del_t *p_cmd )
> {
> - if( p_cmd->u.del.p_es->p_es )
> - es_out_Del( p_out, p_cmd->u.del.p_es->p_es );
> - free( p_cmd->u.del.p_es );
> + if( p_cmd->p_es->p_es )
> + es_out_Del( p_out, p_cmd->p_es->p_es );
> + free( p_cmd->p_es );
> }
>
> -static int CmdInitControl( ts_cmd_t *p_cmd, input_source_t *in,
> +static int CmdInitControl( ts_cmd_control_t *p_cmd, input_source_t *in,
> int i_query, va_list args, bool b_copy )
> {
> p_cmd->i_type = C_CONTROL;
> p_cmd->i_date = vlc_tick_now();
> - p_cmd->u.control.i_query = i_query;
> + p_cmd->i_query = i_query;
>
> if( b_copy )
> - p_cmd->u.control.in = in ? input_source_Hold( in ) : NULL;
> + p_cmd->in = in ? input_source_Hold( in ) : NULL;
> else
> - p_cmd->u.control.in = in;
> + p_cmd->in = in;
>
> switch( i_query )
> {
> /* Pass-through control */
> case ES_OUT_SET_GROUP: /* arg1= int */
> case ES_OUT_DEL_GROUP: /* arg1=int i_group */
> - p_cmd->u.control.u.i_int = va_arg( args, int );
> + p_cmd->u.i_int = va_arg( args, int );
> break;
>
> case ES_OUT_SET_PCR: /* arg1=vlc_tick_t
> i_pcr(microsecond!) (using default group 0)*/ case
> ES_OUT_SET_NEXT_DISPLAY_TIME: /* arg1=int64_t i_pts(microsecond) */ -
> p_cmd->u.control.u.i_i64 = va_arg( args, int64_t );
> + p_cmd->u.i_i64 = va_arg( args, int64_t );
> break;
>
> case ES_OUT_SET_GROUP_PCR: /* arg1= int i_group,
> arg2=vlc_tick_t i_pcr(microsecond!)*/ -
> p_cmd->u.control.u.int_i64.i_int = va_arg( args, int );
> - p_cmd->u.control.u.int_i64.i_i64 = va_arg( args, vlc_tick_t );
> + p_cmd->u.int_i64.i_int = va_arg( args, int );
> + p_cmd->u.int_i64.i_i64 = va_arg( args, vlc_tick_t );
> break;
>
> case ES_OUT_SET_ES_SCRAMBLED_STATE:
> - p_cmd->u.control.u.es_bool.p_es = va_arg( args, es_out_id_t * );
> - p_cmd->u.control.u.es_bool.b_bool = (bool)va_arg( args, int );
> + p_cmd->u.es_bool.p_es = va_arg( args, es_out_id_t * );
> + p_cmd->u.es_bool.b_bool = (bool)va_arg( args, int );
> break;
>
> case ES_OUT_RESET_PCR: /* no arg */
> @@ -1512,62 +1540,62 @@ static int CmdInitControl( ts_cmd_t *p_cmd,
> input_source_t *in, case ES_OUT_SET_GROUP_META: /* arg1=int i_group
> arg2=const vlc_meta_t* */ {
> if( i_query == ES_OUT_SET_GROUP_META )
> - p_cmd->u.control.u.int_meta.i_int = va_arg( args, int );
> + p_cmd->u.int_meta.i_int = va_arg( args, int );
> const vlc_meta_t *p_meta = va_arg( args, const vlc_meta_t * );
>
> if( b_copy )
> {
> - p_cmd->u.control.u.int_meta.p_meta = vlc_meta_New();
> - if( !p_cmd->u.control.u.int_meta.p_meta )
> + p_cmd->u.int_meta.p_meta = vlc_meta_New();
> + if( !p_cmd->u.int_meta.p_meta )
> return VLC_EGENERIC;
> - vlc_meta_Merge( p_cmd->u.control.u.int_meta.p_meta, p_meta );
> + vlc_meta_Merge( p_cmd->u.int_meta.p_meta, p_meta );
> }
> else
> {
> /* The cast is only needed to avoid warning */
> - p_cmd->u.control.u.int_meta.p_meta = (vlc_meta_t*)p_meta;
> + p_cmd->u.int_meta.p_meta = (vlc_meta_t*)p_meta;
> }
> break;
> }
>
> case ES_OUT_SET_GROUP_EPG: /* arg1=int i_group arg2=const vlc_epg_t*
> */ {
> - p_cmd->u.control.u.int_epg.i_int = va_arg( args, int );
> + p_cmd->u.int_epg.i_int = va_arg( args, int );
> const vlc_epg_t *p_epg = va_arg( args, const vlc_epg_t * );
>
> if( b_copy )
> {
> - p_cmd->u.control.u.int_epg.p_epg = vlc_epg_Duplicate( p_epg );
> - if( !p_cmd->u.control.u.int_epg.p_epg )
> + p_cmd->u.int_epg.p_epg = vlc_epg_Duplicate( p_epg );
> + if( !p_cmd->u.int_epg.p_epg )
> return VLC_EGENERIC;
> }
> else
> {
> /* The cast is only needed to avoid warning */
> - p_cmd->u.control.u.int_epg.p_epg = (vlc_epg_t*)p_epg;
> + p_cmd->u.int_epg.p_epg = (vlc_epg_t*)p_epg;
> }
> break;
> }
> case ES_OUT_SET_GROUP_EPG_EVENT: /* arg1=int i_group arg2=const
> vlc_epg_event_t* */ {
> - p_cmd->u.control.u.int_epg_evt.i_int = va_arg( args, int );
> + p_cmd->u.int_epg_evt.i_int = va_arg( args, int );
> const vlc_epg_event_t *p_evt = va_arg( args, const vlc_epg_event_t
> * );
>
> if( b_copy )
> {
> - p_cmd->u.control.u.int_epg_evt.p_evt = vlc_epg_event_Duplicate(
> p_evt ); - if( !p_cmd->u.control.u.int_epg_evt.p_evt )
> + p_cmd->u.int_epg_evt.p_evt = vlc_epg_event_Duplicate( p_evt );
> + if( !p_cmd->u.int_epg_evt.p_evt )
> return VLC_EGENERIC;
> }
> else
> {
> /* The cast is only needed to avoid warning */
> - p_cmd->u.control.u.int_epg_evt.p_evt = (vlc_epg_event_t*)p_evt;
> + p_cmd->u.int_epg_evt.p_evt = (vlc_epg_event_t*)p_evt; }
> break;
> }
> case ES_OUT_SET_EPG_TIME: /* arg1=int64_t (seconds) */
> - p_cmd->u.control.u.i_i64 = va_arg( args, int64_t );
> + p_cmd->u.i_i64 = va_arg( args, int64_t );
> break;
>
> /* Modified control */
> @@ -1575,34 +1603,34 @@ static int CmdInitControl( ts_cmd_t *p_cmd,
> input_source_t *in, case ES_OUT_UNSET_ES: /* arg1= es_out_id_t*
> */ case ES_OUT_RESTART_ES: /* arg1= es_out_id_t*
> */ case ES_OUT_SET_ES_DEFAULT: /* arg1= es_out_id_t* */ -
> p_cmd->u.control.u.p_es = va_arg( args, es_out_id_t * );
> + p_cmd->u.p_es = va_arg( args, es_out_id_t * );
> break;
>
> case ES_OUT_SET_ES_CAT_POLICY:
> - p_cmd->u.control.u.es_policy.i_cat = va_arg( args, int );
> - p_cmd->u.control.u.es_policy.i_policy = va_arg( args, int );
> + p_cmd->u.es_policy.i_cat = va_arg( args, int );
> + p_cmd->u.es_policy.i_policy = va_arg( args, int );
> break;
>
> case ES_OUT_SET_ES_STATE:/* arg1= es_out_id_t* arg2=bool */
> - p_cmd->u.control.u.es_bool.p_es = va_arg( args, es_out_id_t * );
> - p_cmd->u.control.u.es_bool.b_bool = (bool)va_arg( args, int );
> + p_cmd->u.es_bool.p_es = va_arg( args, es_out_id_t * );
> + p_cmd->u.es_bool.b_bool = (bool)va_arg( args, int );
> break;
>
> case ES_OUT_SET_ES_FMT: /* arg1= es_out_id_t* arg2=es_format_t* */
> {
> - p_cmd->u.control.u.es_fmt.p_es = va_arg( args, es_out_id_t * );
> + p_cmd->u.es_fmt.p_es = va_arg( args, es_out_id_t * );
> es_format_t *p_fmt = va_arg( args, es_format_t * );
>
> if( b_copy )
> {
> - p_cmd->u.control.u.es_fmt.p_fmt = malloc( sizeof(*p_fmt) );
> - if( !p_cmd->u.control.u.es_fmt.p_fmt )
> + p_cmd->u.es_fmt.p_fmt = malloc( sizeof(*p_fmt) );
> + if( !p_cmd->u.es_fmt.p_fmt )
> return VLC_EGENERIC;
> - es_format_Copy( p_cmd->u.control.u.es_fmt.p_fmt, p_fmt );
> + es_format_Copy( p_cmd->u.es_fmt.p_fmt, p_fmt );
> }
> else
> {
> - p_cmd->u.control.u.es_fmt.p_fmt = p_fmt;
> + p_cmd->u.es_fmt.p_fmt = p_fmt;
> }
> break;
> }
> @@ -1613,118 +1641,118 @@ static int CmdInitControl( ts_cmd_t *p_cmd,
> input_source_t *in,
>
> return VLC_SUCCESS;
> }
> -static int CmdExecuteControl( es_out_t *p_out, ts_cmd_t *p_cmd )
> +static int CmdExecuteControl( es_out_t *p_out, ts_cmd_control_t *p_cmd )
> {
> - const int i_query = p_cmd->u.control.i_query;
> - input_source_t *in = p_cmd->u.control.in;
> + const int i_query = p_cmd->i_query;
> + input_source_t *in = p_cmd->in;
>
> switch( i_query )
> {
> /* Pass-through control */
> case ES_OUT_SET_GROUP: /* arg1= int */
> case ES_OUT_DEL_GROUP: /* arg1=int i_group */
> - return es_out_in_Control( p_out, in, i_query,
> p_cmd->u.control.u.i_int ); + return es_out_in_Control( p_out, in,
> i_query, p_cmd->u.i_int );
>
> case ES_OUT_SET_PCR: /* arg1=vlc_tick_t
> i_pcr(microsecond!) (using default group 0)*/ case
> ES_OUT_SET_NEXT_DISPLAY_TIME: /* arg1=int64_t i_pts(microsecond) */ -
> return es_out_in_Control( p_out, in, i_query, p_cmd->u.control.u.i_i64 );
> + return es_out_in_Control( p_out, in, i_query, p_cmd->u.i_i64 );
>
> case ES_OUT_SET_GROUP_PCR: /* arg1= int i_group,
> arg2=vlc_tick_t i_pcr(microsecond!)*/ - return es_out_in_Control(
> p_out, in, i_query, p_cmd->u.control.u.int_i64.i_int, -
> p_cmd->u.control.u.int_i64.i_i64 ); + return
> es_out_in_Control( p_out, in, i_query, p_cmd->u.int_i64.i_int, +
> p_cmd->u.int_i64.i_i64 );
>
> case ES_OUT_RESET_PCR: /* no arg */
> return es_out_in_Control( p_out, in, i_query );
>
> case ES_OUT_SET_GROUP_META: /* arg1=int i_group arg2=const vlc_meta_t*
> */ - return es_out_in_Control( p_out, in, i_query,
> p_cmd->u.control.u.int_meta.i_int, -
> p_cmd->u.control.u.int_meta.p_meta ); + return es_out_in_Control(
> p_out, in, i_query, p_cmd->u.int_meta.i_int, +
> p_cmd->u.int_meta.p_meta );
>
> case ES_OUT_SET_GROUP_EPG: /* arg1=int i_group arg2=const vlc_epg_t*
> */ - return es_out_in_Control( p_out, in, i_query,
> p_cmd->u.control.u.int_epg.i_int, -
> p_cmd->u.control.u.int_epg.p_epg ); + return es_out_in_Control(
> p_out, in, i_query, p_cmd->u.int_epg.i_int, +
> p_cmd->u.int_epg.p_epg );
>
> case ES_OUT_SET_GROUP_EPG_EVENT: /* arg1=int i_group arg2=const
> vlc_epg_event_t* */ - return es_out_in_Control( p_out, in, i_query,
> p_cmd->u.control.u.int_epg_evt.i_int, -
> p_cmd->u.control.u.int_epg_evt.p_evt ); + return es_out_in_Control(
> p_out, in, i_query, p_cmd->u.int_epg_evt.i_int, +
> p_cmd->u.int_epg_evt.p_evt );
>
> case ES_OUT_SET_EPG_TIME: /* arg1=int64_t */
> - return es_out_in_Control( p_out, in, i_query,
> p_cmd->u.control.u.i_i64 ); + return es_out_in_Control( p_out, in,
> i_query, p_cmd->u.i_i64 );
>
> case ES_OUT_SET_ES_SCRAMBLED_STATE: /* arg1=int es_out_id_t* arg2=bool
> */ - return es_out_in_Control( p_out, in, i_query,
> p_cmd->u.control.u.es_bool.p_es->p_es, -
> p_cmd->u.control.u.es_bool.b_bool ); + return es_out_in_Control(
> p_out, in, i_query, p_cmd->u.es_bool.p_es->p_es, +
> p_cmd->u.es_bool.b_bool );
>
> case ES_OUT_SET_META: /* arg1=const vlc_meta_t* */
> - return es_out_in_Control( p_out, in, i_query,
> p_cmd->u.control.u.int_meta.p_meta ); + return es_out_in_Control(
> p_out, in, i_query, p_cmd->u.int_meta.p_meta );
>
> /* Modified control */
> case ES_OUT_SET_ES: /* arg1= es_out_id_t* */
> case ES_OUT_UNSET_ES: /* arg1= es_out_id_t* */
> case ES_OUT_RESTART_ES: /* arg1= es_out_id_t* */
> case ES_OUT_SET_ES_DEFAULT: /* arg1= es_out_id_t* */
> - return es_out_in_Control( p_out, in, i_query,
> !p_cmd->u.control.u.p_es ? NULL : -
> p_cmd->u.control.u.p_es->p_es ); + return es_out_in_Control( p_out,
> in, i_query, !p_cmd->u.p_es ? NULL : +
> p_cmd->u.p_es->p_es );
>
> case ES_OUT_SET_ES_STATE:/* arg1= es_out_id_t* arg2=bool */
> - return es_out_in_Control( p_out, in, i_query,
> p_cmd->u.control.u.es_bool.p_es->p_es, -
> p_cmd->u.control.u.es_bool.b_bool ); + return es_out_in_Control(
> p_out, in, i_query, p_cmd->u.es_bool.p_es->p_es, +
> p_cmd->u.es_bool.b_bool );
>
> case ES_OUT_SET_ES_CAT_POLICY:
> - return es_out_in_Control( p_out, in, i_query,
> p_cmd->u.control.u.es_policy.i_cat, -
> p_cmd->u.control.u.es_policy.i_policy ); + return es_out_in_Control(
> p_out, in, i_query, p_cmd->u.es_policy.i_cat, +
> p_cmd->u.es_policy.i_policy );
>
> case ES_OUT_SET_ES_FMT: /* arg1= es_out_id_t* arg2=es_format_t* */
> - return es_out_in_Control( p_out, in, i_query,
> p_cmd->u.control.u.es_fmt.p_es->p_es, -
> p_cmd->u.control.u.es_fmt.p_fmt ); + return es_out_in_Control(
> p_out, in, i_query, p_cmd->u.es_fmt.p_es->p_es, +
> p_cmd->u.es_fmt.p_fmt );
>
> default:
> vlc_assert_unreachable();
> return VLC_EGENERIC;
> }
> }
> -static void CmdCleanControl( ts_cmd_t *p_cmd )
> +static void CmdCleanControl( ts_cmd_control_t *p_cmd )
> {
> - if( p_cmd->u.control.in )
> - input_source_Release( p_cmd->u.control.in );
> + if( p_cmd->in )
> + input_source_Release( p_cmd->in );
>
> - switch( p_cmd->u.control.i_query )
> + switch( p_cmd->i_query )
> {
> case ES_OUT_SET_GROUP_META:
> case ES_OUT_SET_META:
> - if( p_cmd->u.control.u.int_meta.p_meta )
> - vlc_meta_Delete( p_cmd->u.control.u.int_meta.p_meta );
> + if( p_cmd->u.int_meta.p_meta )
> + vlc_meta_Delete( p_cmd->u.int_meta.p_meta );
> break;
> case ES_OUT_SET_GROUP_EPG:
> - if( p_cmd->u.control.u.int_epg.p_epg )
> - vlc_epg_Delete( p_cmd->u.control.u.int_epg.p_epg );
> + if( p_cmd->u.int_epg.p_epg )
> + vlc_epg_Delete( p_cmd->u.int_epg.p_epg );
> break;
> case ES_OUT_SET_GROUP_EPG_EVENT:
> - if( p_cmd->u.control.u.int_epg_evt.p_evt )
> - vlc_epg_event_Delete( p_cmd->u.control.u.int_epg_evt.p_evt );
> + if( p_cmd->u.int_epg_evt.p_evt )
> + vlc_epg_event_Delete( p_cmd->u.int_epg_evt.p_evt );
> break;
> case ES_OUT_SET_ES_FMT:
> - if( p_cmd->u.control.u.es_fmt.p_fmt )
> + if( p_cmd->u.es_fmt.p_fmt )
> {
> - es_format_Clean( p_cmd->u.control.u.es_fmt.p_fmt );
> - free( p_cmd->u.control.u.es_fmt.p_fmt );
> + es_format_Clean( p_cmd->u.es_fmt.p_fmt );
> + free( p_cmd->u.es_fmt.p_fmt );
> }
> break;
> }
> }
>
> -static int CmdInitPrivControl( ts_cmd_t *p_cmd, int i_query, va_list args,
> bool b_copy ) +static int CmdInitPrivControl( ts_cmd_privcontrol_t *p_cmd,
> int i_query, va_list args, bool b_copy ) {
> VLC_UNUSED( b_copy );
> - p_cmd->i_type = C_CONTROL;
> + p_cmd->i_type = C_PRIVCONTROL;
> p_cmd->i_date = vlc_tick_now();
> - p_cmd->u.privcontrol.i_query = i_query;
> + p_cmd->i_query = i_query;
>
> switch( i_query )
> {
> /* Pass-through control */
> case ES_OUT_PRIV_SET_MODE: /* arg1= int
> */ - p_cmd->u.privcontrol.u.i_int = va_arg( args, int );
> + p_cmd->u.i_int = va_arg( args, int );
> break;
> case ES_OUT_PRIV_SET_JITTER:
> {
> @@ -1732,9 +1760,9 @@ static int CmdInitPrivControl( ts_cmd_t *p_cmd, int
> i_query, va_list args, bool vlc_tick_t i_pts_jitter = va_arg( args,
> vlc_tick_t );
> int i_cr_average = va_arg( args, int );
>
> - p_cmd->u.privcontrol.u.jitter.i_pts_delay = i_pts_delay;
> - p_cmd->u.privcontrol.u.jitter.i_pts_jitter = i_pts_jitter;
> - p_cmd->u.privcontrol.u.jitter.i_cr_average = i_cr_average;
> + p_cmd->u.jitter.i_pts_delay = i_pts_delay;
> + p_cmd->u.jitter.i_pts_jitter = i_pts_jitter;
> + p_cmd->u.jitter.i_cr_average = i_cr_average;
> break;
> }
> case ES_OUT_PRIV_SET_TIMES:
> @@ -1744,10 +1772,10 @@ static int CmdInitPrivControl( ts_cmd_t *p_cmd, int
> i_query, va_list args, bool vlc_tick_t i_normal_time = va_arg( args,
> vlc_tick_t );
> vlc_tick_t i_length = va_arg( args, vlc_tick_t );
>
> - p_cmd->u.privcontrol.u.times.f_position = f_position;
> - p_cmd->u.privcontrol.u.times.i_time = i_time;
> - p_cmd->u.privcontrol.u.times.i_normal_time = i_normal_time;
> - p_cmd->u.privcontrol.u.times.i_length = i_length;
> + p_cmd->u.times.f_position = f_position;
> + p_cmd->u.times.i_time = i_time;
> + p_cmd->u.times.i_normal_time = i_normal_time;
> + p_cmd->u.times.i_length = i_length;
> break;
> }
> case ES_OUT_PRIV_SET_EOS: /* no arg */
> @@ -1758,25 +1786,25 @@ static int CmdInitPrivControl( ts_cmd_t *p_cmd, int
> i_query, va_list args, bool return VLC_SUCCESS;
> }
>
> -static int CmdExecutePrivControl( es_out_t *p_out, ts_cmd_t *p_cmd )
> +static int CmdExecutePrivControl( es_out_t *p_out, ts_cmd_privcontrol_t
> *p_cmd ) {
> - const int i_query = p_cmd->u.privcontrol.i_query;
> + const int i_query = p_cmd->i_query;
>
> switch( i_query )
> {
> /* Pass-through control */
> case ES_OUT_PRIV_SET_MODE: /* arg1= int
> */ - return es_out_PrivControl( p_out, i_query,
> p_cmd->u.privcontrol.u.i_int ); + return es_out_PrivControl( p_out,
> i_query, p_cmd->u.i_int ); case ES_OUT_PRIV_SET_JITTER:
> - return es_out_PrivControl( p_out, i_query,
> p_cmd->u.privcontrol.u.jitter.i_pts_delay, -
> p_cmd->u.privcontrol.u.jitter.i_pts_jitter, -
> p_cmd->u.privcontrol.u.jitter.i_cr_average ); + return
> es_out_PrivControl( p_out, i_query, p_cmd->u.jitter.i_pts_delay, +
> p_cmd->u.jitter.i_pts_jitter,
> + p_cmd->u.jitter.i_cr_average );
> case ES_OUT_PRIV_SET_TIMES:
> return es_out_PrivControl( p_out, i_query,
> - p_cmd->u.privcontrol.u.times.f_position,
> - p_cmd->u.privcontrol.u.times.i_time, -
>
> p_cmd->u.privcontrol.u.times.i_normal_time, -
> p_cmd->u.privcontrol.u.times.i_length ); +
> p_cmd->u.times.f_position,
> + p_cmd->u.times.i_time,
> + p_cmd->u.times.i_normal_time,
> + p_cmd->u.times.i_length );
> case ES_OUT_PRIV_SET_EOS: /* no arg */
> return es_out_PrivControl( p_out, i_query );
> default: vlc_assert_unreachable();
--
レミ・デニ-クールモン
http://www.remlab.net/
Rémi Denis-Courmont
More information about the vlc-devel
mailing list