[vlc-devel] [PATCH 3/4] vlc_decoder: use a specific opaque struct for input API
Thomas Guillem
thomas at gllm.fr
Wed Mar 18 15:10:18 CET 2020
That way, the input API can't be used with used creater decoder_t.
This is a prerequisite of the packetizer API rework.
---
include/vlc_decoder.h | 15 +-
modules/stream_out/display.c | 10 +-
src/input/decoder.c | 281 ++++++++++++++++-------------------
src/input/decoder.h | 64 ++++----
src/input/es_out.c | 18 +--
5 files changed, 180 insertions(+), 208 deletions(-)
diff --git a/include/vlc_decoder.h b/include/vlc_decoder.h
index 24ca74a9cf..4652fbb479 100644
--- a/include/vlc_decoder.h
+++ b/include/vlc_decoder.h
@@ -31,18 +31,21 @@
#include <vlc_subpicture.h>
+typedef struct vlc_input_decoder_t vlc_input_decoder_t;
+
/**
* This defines an opaque input resource handler.
*/
typedef struct input_resource_t input_resource_t;
/* */
-VLC_API decoder_t * input_DecoderCreate( vlc_object_t *, const es_format_t *, input_resource_t * ) VLC_USED;
-VLC_API void input_DecoderDelete( decoder_t * );
-VLC_API void input_DecoderDecode( decoder_t *, block_t *, bool b_do_pace );
-VLC_API void input_DecoderDrain( decoder_t * );
-VLC_API void input_DecoderFlush( decoder_t * );
-VLC_API int input_DecoderSetSpuHighlight( decoder_t *, const vlc_spu_highlight_t * );
+VLC_API vlc_input_decoder_t *
+input_DecoderCreate( vlc_object_t *, const es_format_t *, input_resource_t * ) VLC_USED;
+VLC_API void input_DecoderDelete( vlc_input_decoder_t * );
+VLC_API void input_DecoderDecode( vlc_input_decoder_t *, block_t *, bool b_do_pace );
+VLC_API void input_DecoderDrain( vlc_input_decoder_t * );
+VLC_API void input_DecoderFlush( vlc_input_decoder_t * );
+VLC_API int input_DecoderSetSpuHighlight( vlc_input_decoder_t *, const vlc_spu_highlight_t * );
/**
* It creates an empty input resource handler.
diff --git a/modules/stream_out/display.c b/modules/stream_out/display.c
index 2f84ce408b..de78a2f34d 100644
--- a/modules/stream_out/display.c
+++ b/modules/stream_out/display.c
@@ -146,8 +146,8 @@ static void *Add( sout_stream_t *p_stream, const es_format_t *p_fmt )
return NULL;
}
- decoder_t *p_dec = input_DecoderCreate( VLC_OBJECT(p_stream), p_fmt,
- p_sys->p_resource );
+ vlc_input_decoder_t *p_dec =
+ input_DecoderCreate( VLC_OBJECT(p_stream), p_fmt, p_sys->p_resource );
if( p_dec == NULL )
{
msg_Err( p_stream, "cannot create decoder for fcc=`%4.4s'",
@@ -160,7 +160,7 @@ static void *Add( sout_stream_t *p_stream, const es_format_t *p_fmt )
static void Del( sout_stream_t *p_stream, void *id )
{
(void) p_stream;
- input_DecoderDelete( (decoder_t *)id );
+ input_DecoderDelete( id );
}
static int Send( sout_stream_t *p_stream, void *id, block_t *p_buffer )
@@ -185,7 +185,7 @@ static int Send( sout_stream_t *p_stream, void *id, block_t *p_buffer )
else
p_buffer->i_pts += p_sys->i_delay;
- input_DecoderDecode( (decoder_t *)id, p_buffer, false );
+ input_DecoderDecode( id, p_buffer, false );
}
p_buffer = p_next;
@@ -198,7 +198,7 @@ static int Control( sout_stream_t *p_stream, int i_query, va_list args )
{
if( i_query == SOUT_STREAM_ID_SPU_HIGHLIGHT )
{
- decoder_t *p_dec = va_arg(args, void *);
+ vlc_input_decoder_t *p_dec = va_arg(args, void *);
void *spu_hl = va_arg(args, void *);
return input_DecoderSetSpuHighlight( p_dec, spu_hl );
}
diff --git a/src/input/decoder.c b/src/input/decoder.c
index b6208368d6..39546b93f8 100644
--- a/src/input/decoder.c
+++ b/src/input/decoder.c
@@ -62,7 +62,7 @@ enum reload
RELOAD_DECODER_AOUT /* Stop the aout and reload the decoder module */
};
-struct decoder_owner
+struct vlc_input_decoder_t
{
decoder_t dec;
input_resource_t*p_resource;
@@ -165,7 +165,7 @@ struct decoder_owner
{
bool b_supported;
decoder_cc_desc_t desc;
- decoder_t *pp_decoder[MAX_CC_DECODERS];
+ vlc_input_decoder_t *pp_decoder[MAX_CC_DECODERS];
bool b_sout_created;
sout_packetizer_input_t *p_sout_input;
} cc;
@@ -186,12 +186,12 @@ struct decoder_owner
#define decoder_Notify(decoder_priv, event, ...) \
if (decoder_priv->cbs && decoder_priv->cbs->event) \
- decoder_priv->cbs->event(&decoder_priv->dec, __VA_ARGS__, \
+ decoder_priv->cbs->event(decoder_priv, __VA_ARGS__, \
decoder_priv->cbs_userdata);
-static inline struct decoder_owner *dec_get_owner( decoder_t *p_dec )
+static inline vlc_input_decoder_t *dec_get_owner( decoder_t *p_dec )
{
- return container_of( p_dec, struct decoder_owner, dec );
+ return container_of( p_dec, vlc_input_decoder_t, dec );
}
/**
@@ -226,7 +226,7 @@ static int LoadDecoder( decoder_t *p_dec, bool b_packetizer,
return 0;
}
-static int DecoderThread_Reload( struct decoder_owner *p_owner,
+static int DecoderThread_Reload( vlc_input_decoder_t *p_owner,
const es_format_t *restrict p_fmt,
enum reload reload )
{
@@ -266,7 +266,7 @@ static int DecoderThread_Reload( struct decoder_owner *p_owner,
return VLC_SUCCESS;
}
-static void DecoderUpdateFormatLocked( struct decoder_owner *p_owner )
+static void DecoderUpdateFormatLocked( vlc_input_decoder_t *p_owner )
{
decoder_t *p_dec = &p_owner->dec;
@@ -291,7 +291,7 @@ static void DecoderUpdateFormatLocked( struct decoder_owner *p_owner )
static void MouseEvent( const vlc_mouse_t *newmouse, void *user_data )
{
decoder_t *dec = user_data;
- struct decoder_owner *owner = dec_get_owner( dec );
+ vlc_input_decoder_t *owner = dec_get_owner( dec );
vlc_mutex_lock( &owner->mouse_lock );
if( owner->mouse_event )
@@ -318,7 +318,7 @@ static bool aout_replaygain_changed( const audio_replay_gain_t *a,
static int ModuleThread_UpdateAudioFormat( decoder_t *p_dec )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
if( p_owner->p_aout &&
( !AOUT_FMTS_IDENTICAL(&p_dec->fmt_out.audio, &p_owner->fmt.audio) ||
@@ -404,12 +404,12 @@ static int ModuleThread_UpdateAudioFormat( decoder_t *p_dec )
return 0;
}
-static int CreateVoutIfNeeded(struct decoder_owner *, vout_thread_t **, enum vlc_vout_order *, vlc_decoder_device **);
+static int CreateVoutIfNeeded(vlc_input_decoder_t *, vout_thread_t **, enum vlc_vout_order *, vlc_decoder_device **);
static int ModuleThread_UpdateVideoFormat( decoder_t *p_dec, vlc_video_context *vctx )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
enum vlc_vout_order vout_order;
vout_thread_t *p_vout = NULL;
@@ -485,7 +485,7 @@ static int ModuleThread_UpdateVideoFormat( decoder_t *p_dec, vlc_video_context *
return res;
}
-static int CreateVoutIfNeeded(struct decoder_owner *p_owner,
+static int CreateVoutIfNeeded(vlc_input_decoder_t *p_owner,
vout_thread_t **pp_vout, enum vlc_vout_order *order,
vlc_decoder_device **pp_dec_dev)
{
@@ -600,7 +600,7 @@ static int CreateVoutIfNeeded(struct decoder_owner *p_owner,
static vlc_decoder_device * ModuleThread_GetDecoderDevice( decoder_t *p_dec )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
/* Requesting a decoder device will automatically enable hw decoding */
if( !var_InheritBool( p_dec, "hw-dec" ) )
@@ -649,7 +649,7 @@ static vlc_decoder_device * ModuleThread_GetDecoderDevice( decoder_t *p_dec )
static picture_t *ModuleThread_NewVideoBuffer( decoder_t *p_dec )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
assert( p_owner->p_vout );
assert( p_owner->out_pool );
@@ -662,7 +662,7 @@ static picture_t *ModuleThread_NewVideoBuffer( decoder_t *p_dec )
static subpicture_t *ModuleThread_NewSpuBuffer( decoder_t *p_dec,
const subpicture_updater_t *p_updater )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
vout_thread_t *p_vout = NULL;
subpicture_t *p_subpic;
int i_attempts = 30;
@@ -758,11 +758,11 @@ static int InputThread_GetInputAttachments( decoder_t *p_dec,
input_attachment_t ***ppp_attachment,
int *pi_attachment )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
if (!p_owner->cbs || !p_owner->cbs->get_attachments)
return VLC_ENOOBJ;
- int ret = p_owner->cbs->get_attachments(p_dec, ppp_attachment,
+ int ret = p_owner->cbs->get_attachments(p_owner, ppp_attachment,
p_owner->cbs_userdata);
if (ret < 0)
return VLC_EGENERIC;
@@ -773,7 +773,7 @@ static int InputThread_GetInputAttachments( decoder_t *p_dec,
static vlc_tick_t ModuleThread_GetDisplayDate( decoder_t *p_dec,
vlc_tick_t system_now, vlc_tick_t i_ts )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
vlc_mutex_lock( &p_owner->lock );
if( p_owner->b_waiting || p_owner->paused )
@@ -789,7 +789,7 @@ static vlc_tick_t ModuleThread_GetDisplayDate( decoder_t *p_dec,
static float ModuleThread_GetDisplayRate( decoder_t *p_dec )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
if( !p_owner->p_clock )
return 1.f;
@@ -818,7 +818,7 @@ block_t *decoder_NewAudioBuffer( decoder_t *dec, int samples )
return block;
}
-static void RequestReload( struct decoder_owner *p_owner )
+static void RequestReload( vlc_input_decoder_t *p_owner )
{
/* Don't override reload if it's RELOAD_DECODER_AOUT */
int expected = RELOAD_NO_REQUEST;
@@ -827,7 +827,7 @@ static void RequestReload( struct decoder_owner *p_owner )
static void DecoderThread_AbortPictures( decoder_t *p_dec, bool b_abort )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
vlc_mutex_lock( &p_owner->lock ); // called in DecoderThread
if (p_owner->out_pool)
@@ -835,7 +835,7 @@ static void DecoderThread_AbortPictures( decoder_t *p_dec, bool b_abort )
vlc_mutex_unlock( &p_owner->lock );
}
-static void DecoderWaitUnblock( struct decoder_owner *p_owner )
+static void DecoderWaitUnblock( vlc_input_decoder_t *p_owner )
{
vlc_mutex_assert( &p_owner->lock );
@@ -862,7 +862,7 @@ static inline void DecoderUpdatePreroll( vlc_tick_t *pi_preroll, const block_t *
}
#ifdef ENABLE_SOUT
-static int DecoderThread_PlaySout( struct decoder_owner *p_owner, block_t *p_sout_block )
+static int DecoderThread_PlaySout( vlc_input_decoder_t *p_owner, block_t *p_sout_block )
{
assert( !p_sout_block->p_next );
@@ -884,7 +884,7 @@ static int DecoderThread_PlaySout( struct decoder_owner *p_owner, block_t *p_sou
/* This function process a block for sout
*/
-static void DecoderThread_ProcessSout( struct decoder_owner *p_owner, block_t *p_block )
+static void DecoderThread_ProcessSout( vlc_input_decoder_t *p_owner, block_t *p_block )
{
decoder_t *p_dec = &p_owner->dec;
block_t *p_sout_block;
@@ -982,7 +982,7 @@ static void DecoderThread_ProcessSout( struct decoder_owner *p_owner, block_t *p
}
#endif
-static void DecoderPlayCc( struct decoder_owner *p_owner, block_t *p_cc,
+static void DecoderPlayCc( vlc_input_decoder_t *p_owner, block_t *p_cc,
const decoder_cc_desc_t *p_desc )
{
vlc_mutex_lock( &p_owner->lock );
@@ -996,9 +996,8 @@ static void DecoderPlayCc( struct decoder_owner *p_owner, block_t *p_cc,
for( int i=0; i_bitmap > 0; i_bitmap >>= 1, i++ )
{
- decoder_t *p_ccdec = p_owner->cc.pp_decoder[i];
- struct decoder_owner *p_ccowner = dec_get_owner( p_ccdec );
- if( !p_ccdec )
+ vlc_input_decoder_t *p_ccowner = p_owner->cc.pp_decoder[i];
+ if( !p_ccowner )
continue;
if( i_bitmap > 1 )
@@ -1018,7 +1017,7 @@ static void DecoderPlayCc( struct decoder_owner *p_owner, block_t *p_cc,
block_Release( p_cc );
}
-static void PacketizerGetCc( struct decoder_owner *p_owner, decoder_t *p_dec_cc )
+static void PacketizerGetCc( vlc_input_decoder_t *p_owner, decoder_t *p_dec_cc )
{
block_t *p_cc;
decoder_cc_desc_t desc;
@@ -1038,7 +1037,7 @@ static void PacketizerGetCc( struct decoder_owner *p_owner, decoder_t *p_dec_cc
static void ModuleThread_QueueCc( decoder_t *p_videodec, block_t *p_cc,
const decoder_cc_desc_t *p_desc )
{
- struct decoder_owner *p_owner = dec_get_owner( p_videodec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_videodec );
if( unlikely( p_cc != NULL ) )
{
@@ -1050,7 +1049,7 @@ static void ModuleThread_QueueCc( decoder_t *p_videodec, block_t *p_cc,
}
}
-static int ModuleThread_PlayVideo( struct decoder_owner *p_owner, picture_t *p_picture )
+static int ModuleThread_PlayVideo( vlc_input_decoder_t *p_owner, picture_t *p_picture )
{
decoder_t *p_dec = &p_owner->dec;
vout_thread_t *p_vout = p_owner->vout_thread_started ? p_owner->p_vout : NULL;
@@ -1124,7 +1123,7 @@ static int ModuleThread_PlayVideo( struct decoder_owner *p_owner, picture_t *p_p
return VLC_SUCCESS;
}
-static void ModuleThread_UpdateStatVideo( struct decoder_owner *p_owner,
+static void ModuleThread_UpdateStatVideo( vlc_input_decoder_t *p_owner,
bool lost )
{
unsigned displayed = 0;
@@ -1141,7 +1140,7 @@ static void ModuleThread_UpdateStatVideo( struct decoder_owner *p_owner,
static void ModuleThread_QueueVideo( decoder_t *p_dec, picture_t *p_pic )
{
assert( p_pic );
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
int success = ModuleThread_PlayVideo( p_owner, p_pic );
@@ -1159,7 +1158,7 @@ static vlc_decoder_device * thumbnailer_get_device( decoder_t *p_dec )
static picture_t *thumbnailer_buffer_new( decoder_t *p_dec )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
/* Avoid decoding more than one frame when a thumbnail was
* already generated */
vlc_mutex_lock( &p_owner->lock );
@@ -1174,7 +1173,7 @@ static picture_t *thumbnailer_buffer_new( decoder_t *p_dec )
static void ModuleThread_QueueThumbnail( decoder_t *p_dec, picture_t *p_pic )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
bool b_first;
vlc_mutex_lock( &p_owner->lock );
@@ -1188,7 +1187,7 @@ static void ModuleThread_QueueThumbnail( decoder_t *p_dec, picture_t *p_pic )
}
-static int ModuleThread_PlayAudio( struct decoder_owner *p_owner, block_t *p_audio )
+static int ModuleThread_PlayAudio( vlc_input_decoder_t *p_owner, block_t *p_audio )
{
decoder_t *p_dec = &p_owner->dec;
@@ -1259,7 +1258,7 @@ static int ModuleThread_PlayAudio( struct decoder_owner *p_owner, block_t *p_aud
return VLC_SUCCESS;
}
-static void ModuleThread_UpdateStatAudio( struct decoder_owner *p_owner,
+static void ModuleThread_UpdateStatAudio( vlc_input_decoder_t *p_owner,
bool lost )
{
unsigned played = 0;
@@ -1275,14 +1274,14 @@ static void ModuleThread_UpdateStatAudio( struct decoder_owner *p_owner,
static void ModuleThread_QueueAudio( decoder_t *p_dec, block_t *p_aout_buf )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
int success = ModuleThread_PlayAudio( p_owner, p_aout_buf );
ModuleThread_UpdateStatAudio( p_owner, success != VLC_SUCCESS );
}
-static void ModuleThread_PlaySpu( struct decoder_owner *p_owner, subpicture_t *p_subpic )
+static void ModuleThread_PlaySpu( vlc_input_decoder_t *p_owner, subpicture_t *p_subpic )
{
decoder_t *p_dec = &p_owner->dec;
vout_thread_t *p_vout = p_owner->p_vout;
@@ -1319,7 +1318,7 @@ static void ModuleThread_PlaySpu( struct decoder_owner *p_owner, subpicture_t *p
static void ModuleThread_QueueSpu( decoder_t *p_dec, subpicture_t *p_spu )
{
assert( p_spu );
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ vlc_input_decoder_t *p_owner = dec_get_owner( p_dec );
/* The vout must be created from a previous decoder_NewSubpicture call. */
assert( p_owner->p_vout );
@@ -1340,8 +1339,8 @@ static void ModuleThread_QueueSpu( decoder_t *p_dec, subpicture_t *p_spu )
}
}
-static void DecoderThread_ProcessInput( struct decoder_owner *p_owner, block_t *p_block );
-static void DecoderThread_DecodeBlock( struct decoder_owner *p_owner, block_t *p_block )
+static void DecoderThread_ProcessInput( vlc_input_decoder_t *p_owner, block_t *p_block );
+static void DecoderThread_DecodeBlock( vlc_input_decoder_t *p_owner, block_t *p_block )
{
decoder_t *p_dec = &p_owner->dec;
@@ -1376,7 +1375,7 @@ static void DecoderThread_DecodeBlock( struct decoder_owner *p_owner, block_t *p
* \param p_dec the decoder object
* \param p_block the block to decode
*/
-static void DecoderThread_ProcessInput( struct decoder_owner *p_owner, block_t *p_block )
+static void DecoderThread_ProcessInput( vlc_input_decoder_t *p_owner, block_t *p_block )
{
decoder_t *p_dec = &p_owner->dec;
@@ -1475,7 +1474,7 @@ error:
block_Release( p_block );
}
-static void DecoderThread_Flush( struct decoder_owner *p_owner )
+static void DecoderThread_Flush( vlc_input_decoder_t *p_owner )
{
decoder_t *p_dec = &p_owner->dec;
decoder_t *p_packetizer = p_owner->p_packetizer;
@@ -1494,9 +1493,9 @@ static void DecoderThread_Flush( struct decoder_owner *p_owner )
{
for( int i=0; i<MAX_CC_DECODERS; i++ )
{
- decoder_t *p_subdec = p_owner->cc.pp_decoder[i];
- if( p_subdec && p_subdec->pf_flush )
- p_subdec->pf_flush( p_subdec );
+ vlc_input_decoder_t *p_ccowner = p_owner->cc.pp_decoder[i];
+ if( p_ccowner && p_ccowner->dec.pf_flush )
+ p_ccowner->dec.pf_flush( &p_ccowner->dec );
}
}
@@ -1530,7 +1529,7 @@ static void DecoderThread_Flush( struct decoder_owner *p_owner )
vlc_mutex_unlock( &p_owner->lock );
}
-static void DecoderThread_ChangePause( struct decoder_owner *p_owner, bool paused, vlc_tick_t date )
+static void DecoderThread_ChangePause( vlc_input_decoder_t *p_owner, bool paused, vlc_tick_t date )
{
decoder_t *p_dec = &p_owner->dec;
@@ -1556,7 +1555,7 @@ static void DecoderThread_ChangePause( struct decoder_owner *p_owner, bool pause
}
}
-static void DecoderThread_ChangeRate( struct decoder_owner *p_owner, float rate )
+static void DecoderThread_ChangeRate( vlc_input_decoder_t *p_owner, float rate )
{
decoder_t *p_dec = &p_owner->dec;
@@ -1587,7 +1586,7 @@ static void DecoderThread_ChangeRate( struct decoder_owner *p_owner, float rate
vlc_mutex_unlock( &p_owner->lock );
}
-static void DecoderThread_ChangeDelay( struct decoder_owner *p_owner, vlc_tick_t delay )
+static void DecoderThread_ChangeDelay( vlc_input_decoder_t *p_owner, vlc_tick_t delay )
{
decoder_t *p_dec = &p_owner->dec;
@@ -1629,7 +1628,7 @@ static void DecoderThread_ChangeDelay( struct decoder_owner *p_owner, vlc_tick_t
*/
static void *DecoderThread( void *p_data )
{
- struct decoder_owner *p_owner = (struct decoder_owner *)p_data;
+ vlc_input_decoder_t *p_owner = (vlc_input_decoder_t *)p_data;
float rate = 1.f;
vlc_tick_t delay = 0;
bool paused = false;
@@ -1804,7 +1803,7 @@ static const struct decoder_owner_callbacks dec_spu_cbs =
* \param b_packetizer instead of a decoder
* \return the decoder object
*/
-static struct decoder_owner * CreateDecoder( vlc_object_t *p_parent,
+static vlc_input_decoder_t * CreateDecoder( vlc_object_t *p_parent,
const es_format_t *fmt, vlc_clock_t *p_clock,
input_resource_t *p_resource,
sout_instance_t *p_sout, bool b_thumbnailing,
@@ -1812,8 +1811,8 @@ static struct decoder_owner * CreateDecoder( vlc_object_t *p_parent,
void *cbs_userdata )
{
decoder_t *p_dec;
- struct decoder_owner *p_owner;
- static_assert(offsetof(struct decoder_owner, dec) == 0,
+ vlc_input_decoder_t *p_owner;
+ static_assert(offsetof(vlc_input_decoder_t, dec) == 0,
"the decoder must be first in the owner structure");
p_owner = vlc_custom_create( p_parent, sizeof( *p_owner ), "decoder" );
@@ -1957,10 +1956,9 @@ static struct decoder_owner * CreateDecoder( vlc_object_t *p_parent,
* \param p_dec the decoder object
* \return nothing
*/
-static void DeleteDecoder( decoder_t * p_dec )
+static void DeleteDecoder( vlc_input_decoder_t *p_owner )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
+ decoder_t *p_dec = &p_owner->dec;
msg_Dbg( p_dec, "killing decoder fourcc `%4.4s'",
(char*)&p_dec->fmt_in.i_codec );
@@ -2063,18 +2061,19 @@ static void DecoderUnsupportedCodec( decoder_t *p_dec, const es_format_t *fmt, b
}
/* TODO: pass p_sout through p_resource? -- Courmisch */
-static decoder_t *decoder_New( vlc_object_t *p_parent, const es_format_t *fmt,
- vlc_clock_t *p_clock, input_resource_t *p_resource,
- sout_instance_t *p_sout, bool thumbnailing,
- const struct input_decoder_callbacks *cbs,
- void *userdata)
+static vlc_input_decoder_t *
+decoder_New( vlc_object_t *p_parent, const es_format_t *fmt,
+ vlc_clock_t *p_clock, input_resource_t *p_resource,
+ sout_instance_t *p_sout, bool thumbnailing,
+ const struct input_decoder_callbacks *cbs, void *userdata)
{
const char *psz_type = p_sout ? N_("packetizer") : N_("decoder");
int i_priority;
/* Create the decoder configuration structure */
- struct decoder_owner *p_owner = CreateDecoder( p_parent, fmt, p_clock, p_resource, p_sout,
- thumbnailing, cbs, userdata );
+ vlc_input_decoder_t *p_owner =
+ CreateDecoder( p_parent, fmt, p_clock, p_resource, p_sout,
+ thumbnailing, cbs, userdata );
if( p_owner == NULL )
{
msg_Err( p_parent, "could not create %s", psz_type );
@@ -2088,7 +2087,7 @@ static decoder_t *decoder_New( vlc_object_t *p_parent, const es_format_t *fmt,
{
DecoderUnsupportedCodec( p_dec, fmt, !p_sout );
- DeleteDecoder( p_dec );
+ DeleteDecoder( p_owner );
return NULL;
}
@@ -2118,11 +2117,11 @@ static decoder_t *decoder_New( vlc_object_t *p_parent, const es_format_t *fmt,
if( vlc_clone( &p_owner->thread, DecoderThread, p_owner, i_priority ) )
{
msg_Err( p_dec, "cannot spawn decoder thread" );
- DeleteDecoder( p_dec );
+ DeleteDecoder( p_owner );
return NULL;
}
- return p_dec;
+ return p_owner;
}
@@ -2133,11 +2132,12 @@ static decoder_t *decoder_New( vlc_object_t *p_parent, const es_format_t *fmt,
* \param p_es the es descriptor
* \return the spawned decoder object
*/
-decoder_t *input_DecoderNew( vlc_object_t *parent, es_format_t *fmt,
- vlc_clock_t *p_clock, input_resource_t *resource,
- sout_instance_t *p_sout, bool thumbnailing,
- const struct input_decoder_callbacks *cbs,
- void *cbs_userdata)
+vlc_input_decoder_t *
+input_DecoderNew( vlc_object_t *parent, es_format_t *fmt,
+ vlc_clock_t *p_clock, input_resource_t *resource,
+ sout_instance_t *p_sout, bool thumbnailing,
+ const struct input_decoder_callbacks *cbs,
+ void *cbs_userdata)
{
return decoder_New( parent, fmt, p_clock, resource, p_sout, thumbnailing,
cbs, cbs_userdata );
@@ -2146,8 +2146,9 @@ decoder_t *input_DecoderNew( vlc_object_t *parent, es_format_t *fmt,
/**
* Spawn a decoder thread outside of the input thread.
*/
-decoder_t *input_DecoderCreate( vlc_object_t *p_parent, const es_format_t *fmt,
- input_resource_t *p_resource )
+vlc_input_decoder_t *
+input_DecoderCreate( vlc_object_t *p_parent, const es_format_t *fmt,
+ input_resource_t *p_resource )
{
return decoder_New( p_parent, fmt, NULL, p_resource, NULL, false, NULL,
NULL );
@@ -2161,9 +2162,9 @@ decoder_t *input_DecoderCreate( vlc_object_t *p_parent, const es_format_t *fmt,
* \param p_es the es descriptor
* \return nothing
*/
-void input_DecoderDelete( decoder_t *p_dec )
+void input_DecoderDelete( vlc_input_decoder_t *p_owner )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
+ decoder_t *p_dec = &p_owner->dec;
vlc_fifo_Lock( p_owner->p_fifo );
p_owner->aborting = true;
@@ -2196,11 +2197,11 @@ void input_DecoderDelete( decoder_t *p_dec )
if( p_owner->cc.b_supported )
{
for( int i = 0; i < MAX_CC_DECODERS; i++ )
- input_DecoderSetCcState( p_dec, VLC_CODEC_CEA608, i, false );
+ input_DecoderSetCcState( p_owner, VLC_CODEC_CEA608, i, false );
}
/* Delete decoder */
- DeleteDecoder( p_dec );
+ DeleteDecoder( p_owner );
}
/**
@@ -2210,10 +2211,8 @@ void input_DecoderDelete( decoder_t *p_dec )
* \param p_dec the decoder object
* \param p_block the data block
*/
-void input_DecoderDecode( decoder_t *p_dec, block_t *p_block, bool b_do_pace )
+void input_DecoderDecode( vlc_input_decoder_t *p_owner, block_t *p_block, bool b_do_pace )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
vlc_fifo_Lock( p_owner->p_fifo );
if( !b_do_pace )
{
@@ -2222,7 +2221,7 @@ void input_DecoderDecode( decoder_t *p_dec, block_t *p_block, bool b_do_pace )
/* 400 MiB, i.e. ~ 50mb/s for 60s */
if( vlc_fifo_GetBytes( p_owner->p_fifo ) > 400*1024*1024 )
{
- msg_Warn( p_dec, "decoder/packetizer fifo full (data not "
+ msg_Warn( &p_owner->dec, "decoder/packetizer fifo full (data not "
"consumed quickly enough), resetting fifo!" );
block_ChainRelease( vlc_fifo_DequeueAllUnlocked( p_owner->p_fifo ) );
p_block->i_flags |= BLOCK_FLAG_DISCONTINUITY;
@@ -2241,10 +2240,8 @@ void input_DecoderDecode( decoder_t *p_dec, block_t *p_block, bool b_do_pace )
vlc_fifo_Unlock( p_owner->p_fifo );
}
-bool input_DecoderIsEmpty( decoder_t * p_dec )
+bool input_DecoderIsEmpty( vlc_input_decoder_t * p_owner )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
assert( !p_owner->b_waiting );
vlc_fifo_Lock( p_owner->p_fifo );
@@ -2282,10 +2279,8 @@ bool input_DecoderIsEmpty( decoder_t * p_dec )
* @note The function does not actually wait for draining. It just signals that
* draining should be performed once the decoder has emptied FIFO.
*/
-void input_DecoderDrain( decoder_t *p_dec )
+void input_DecoderDrain( vlc_input_decoder_t *p_owner )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
vlc_fifo_Lock( p_owner->p_fifo );
p_owner->b_draining = true;
vlc_fifo_Signal( p_owner->p_fifo );
@@ -2296,10 +2291,8 @@ void input_DecoderDrain( decoder_t *p_dec )
* Requests that the decoder immediately discard all pending buffers.
* This is useful when seeking or when deselecting a stream.
*/
-void input_DecoderFlush( decoder_t *p_dec )
+void input_DecoderFlush( vlc_input_decoder_t *p_owner )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
vlc_fifo_Lock( p_owner->p_fifo );
/* Empty the fifo */
@@ -2336,23 +2329,21 @@ void input_DecoderFlush( decoder_t *p_dec )
* after being unstuck. */
vlc_mutex_lock( &p_owner->lock );
- if( p_dec->fmt_out.i_cat == VIDEO_ES
+ if( p_owner->dec.fmt_out.i_cat == VIDEO_ES
&& p_owner->p_vout && p_owner->vout_thread_started )
vout_FlushAll( p_owner->p_vout );
vlc_mutex_unlock( &p_owner->lock );
}
}
-void input_DecoderGetCcDesc( decoder_t *p_dec, decoder_cc_desc_t *p_desc )
+void input_DecoderGetCcDesc( vlc_input_decoder_t *p_owner, decoder_cc_desc_t *p_desc )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
vlc_mutex_lock( &p_owner->lock );
*p_desc = p_owner->cc.desc;
vlc_mutex_unlock( &p_owner->lock );
}
-static bool input_DecoderHasCCChanFlag( struct decoder_owner *p_owner,
+static bool input_DecoderHasCCChanFlag( vlc_input_decoder_t *p_owner,
vlc_fourcc_t codec, int i_channel )
{
int i_max_channels;
@@ -2373,11 +2364,10 @@ static bool input_DecoderHasCCChanFlag( struct decoder_owner *p_owner,
( i_bitmap & ((uint64_t)1 << i_channel) ) );
}
-int input_DecoderSetCcState( decoder_t *p_dec, vlc_fourcc_t codec,
+int input_DecoderSetCcState( vlc_input_decoder_t *p_owner, vlc_fourcc_t codec,
int i_channel, bool b_decode )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
+ decoder_t *p_dec = &p_owner->dec;
//msg_Warn( p_dec, "input_DecoderSetCcState: %d @%x", b_decode, i_channel );
if( !input_DecoderHasCCChanFlag( p_owner, codec, i_channel ) )
@@ -2385,16 +2375,16 @@ int input_DecoderSetCcState( decoder_t *p_dec, vlc_fourcc_t codec,
if( b_decode )
{
- decoder_t *p_cc;
+ vlc_input_decoder_t *p_ccowner;
es_format_t fmt;
es_format_Init( &fmt, SPU_ES, codec );
fmt.subs.cc.i_channel = i_channel;
fmt.subs.cc.i_reorder_depth = p_owner->cc.desc.i_reorder_depth;
- p_cc = input_DecoderNew( VLC_OBJECT(p_dec), &fmt, p_owner->p_clock,
- p_owner->p_resource, p_owner->p_sout, false,
- NULL, NULL );
- if( !p_cc )
+ p_ccowner = input_DecoderNew( VLC_OBJECT(p_dec), &fmt, p_owner->p_clock,
+ p_owner->p_resource, p_owner->p_sout, false,
+ NULL, NULL );
+ if( !p_ccowner )
{
msg_Err( p_dec, "could not create decoder" );
vlc_dialog_display_error( p_dec,
@@ -2402,22 +2392,21 @@ int input_DecoderSetCcState( decoder_t *p_dec, vlc_fourcc_t codec,
_("VLC could not open the decoder module.") );
return VLC_EGENERIC;
}
- else if( !p_cc->p_module )
+ else if( !p_ccowner->dec.p_module )
{
DecoderUnsupportedCodec( p_dec, &fmt, true );
- input_DecoderDelete(p_cc);
+ input_DecoderDelete(p_ccowner);
return VLC_EGENERIC;
}
- struct decoder_owner *p_ccowner = dec_get_owner( p_cc );
p_ccowner->p_clock = p_owner->p_clock;
vlc_mutex_lock( &p_owner->lock );
- p_owner->cc.pp_decoder[i_channel] = p_cc;
+ p_owner->cc.pp_decoder[i_channel] = p_ccowner;
vlc_mutex_unlock( &p_owner->lock );
}
else
{
- decoder_t *p_cc;
+ vlc_input_decoder_t *p_cc;
vlc_mutex_lock( &p_owner->lock );
p_cc = p_owner->cc.pp_decoder[i_channel];
@@ -2430,11 +2419,9 @@ int input_DecoderSetCcState( decoder_t *p_dec, vlc_fourcc_t codec,
return VLC_SUCCESS;
}
-int input_DecoderGetCcState( decoder_t *p_dec, vlc_fourcc_t codec,
+int input_DecoderGetCcState( vlc_input_decoder_t *p_owner, vlc_fourcc_t codec,
int i_channel, bool *pb_decode )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
if( !input_DecoderHasCCChanFlag( p_owner, codec, i_channel ) )
return VLC_EGENERIC;
@@ -2444,10 +2431,8 @@ int input_DecoderGetCcState( decoder_t *p_dec, vlc_fourcc_t codec,
return VLC_SUCCESS;
}
-void input_DecoderChangePause( decoder_t *p_dec, bool b_paused, vlc_tick_t i_date )
+void input_DecoderChangePause( vlc_input_decoder_t *p_owner, bool b_paused, vlc_tick_t i_date )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
/* Normally, p_owner->b_paused != b_paused here. But if a track is added
* while the input is paused (e.g. add sub file), then b_paused is
* (incorrectly) false. FIXME: This is a bug in the decoder owner. */
@@ -2459,28 +2444,22 @@ void input_DecoderChangePause( decoder_t *p_dec, bool b_paused, vlc_tick_t i_dat
vlc_fifo_Unlock( p_owner->p_fifo );
}
-void input_DecoderChangeRate( decoder_t *dec, float rate )
+void input_DecoderChangeRate( vlc_input_decoder_t *owner, float rate )
{
- struct decoder_owner *owner = dec_get_owner( dec );
-
vlc_fifo_Lock( owner->p_fifo );
owner->request_rate = rate;
vlc_fifo_Unlock( owner->p_fifo );
}
-void input_DecoderChangeDelay( decoder_t *dec, vlc_tick_t delay )
+void input_DecoderChangeDelay( vlc_input_decoder_t *owner, vlc_tick_t delay )
{
- struct decoder_owner *owner = dec_get_owner( dec );
-
vlc_fifo_Lock( owner->p_fifo );
owner->delay = delay;
vlc_fifo_Unlock( owner->p_fifo );
}
-void input_DecoderStartWait( decoder_t *p_dec )
+void input_DecoderStartWait( vlc_input_decoder_t *p_owner )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
assert( !p_owner->b_waiting );
vlc_mutex_lock( &p_owner->lock );
@@ -2491,10 +2470,8 @@ void input_DecoderStartWait( decoder_t *p_dec )
vlc_mutex_unlock( &p_owner->lock );
}
-void input_DecoderStopWait( decoder_t *p_dec )
+void input_DecoderStopWait( vlc_input_decoder_t *p_owner )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
assert( p_owner->b_waiting );
vlc_mutex_lock( &p_owner->lock );
@@ -2503,10 +2480,8 @@ void input_DecoderStopWait( decoder_t *p_dec )
vlc_mutex_unlock( &p_owner->lock );
}
-void input_DecoderWait( decoder_t *p_dec )
+void input_DecoderWait( vlc_input_decoder_t *p_owner )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
assert( p_owner->b_waiting );
vlc_mutex_lock( &p_owner->lock );
@@ -2519,7 +2494,7 @@ void input_DecoderWait( decoder_t *p_dec )
vlc_fifo_Lock( p_owner->p_fifo );
if( p_owner->b_idle && vlc_fifo_IsEmpty( p_owner->p_fifo ) )
{
- msg_Err( p_dec, "buffer deadlock prevented" );
+ msg_Err( &p_owner->dec, "buffer deadlock prevented" );
vlc_fifo_Unlock( p_owner->p_fifo );
break;
}
@@ -2529,10 +2504,8 @@ void input_DecoderWait( decoder_t *p_dec )
vlc_mutex_unlock( &p_owner->lock );
}
-void input_DecoderFrameNext( decoder_t *p_dec, vlc_tick_t *pi_duration )
+void input_DecoderFrameNext( vlc_input_decoder_t *p_owner, vlc_tick_t *pi_duration )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
assert( p_owner->paused );
*pi_duration = 0;
@@ -2550,10 +2523,8 @@ void input_DecoderFrameNext( decoder_t *p_dec, vlc_tick_t *pi_duration )
vlc_mutex_unlock( &p_owner->lock );
}
-bool input_DecoderHasFormatChanged( decoder_t *p_dec, es_format_t *p_fmt, vlc_meta_t **pp_meta )
+bool input_DecoderHasFormatChanged( vlc_input_decoder_t *p_owner, es_format_t *p_fmt, vlc_meta_t **pp_meta )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
if( !atomic_exchange_explicit( &p_owner->b_fmt_description, false,
memory_order_acquire ) )
return false;
@@ -2576,10 +2547,8 @@ bool input_DecoderHasFormatChanged( decoder_t *p_dec, es_format_t *p_fmt, vlc_me
return true;
}
-size_t input_DecoderGetFifoSize( decoder_t *p_dec )
+size_t input_DecoderGetFifoSize( vlc_input_decoder_t *p_owner )
{
- struct decoder_owner *p_owner = dec_get_owner( p_dec );
-
return block_FifoSize( p_owner->p_fifo );
}
@@ -2589,33 +2558,36 @@ static bool DecoderHasVbi( decoder_t *dec )
&& var_Type( dec, "vbi-page" ) == VLC_VAR_INTEGER;
}
-int input_DecoderGetVbiPage( decoder_t *dec, bool *opaque )
+int input_DecoderGetVbiPage( vlc_input_decoder_t *owner, bool *opaque )
{
+ decoder_t *dec = &owner->dec;
if( !DecoderHasVbi( dec ) )
return -1;
*opaque = var_GetBool( dec, "vbi-opaque" );
return var_GetInteger( dec, "vbi-page" );
}
-int input_DecoderSetVbiPage( decoder_t *dec, unsigned page )
+int input_DecoderSetVbiPage( vlc_input_decoder_t *owner, unsigned page )
{
+ decoder_t *dec = &owner->dec;
if( !DecoderHasVbi( dec ) )
return VLC_EGENERIC;
return var_SetInteger( dec, "vbi-page", page );
}
-int input_DecoderSetVbiOpaque( decoder_t *dec, bool opaque )
+int input_DecoderSetVbiOpaque( vlc_input_decoder_t *owner, bool opaque )
{
+ decoder_t *dec = &owner->dec;
if( !DecoderHasVbi( dec ) )
return VLC_EGENERIC;
return var_SetBool( dec, "vbi-opaque", opaque );
}
-void input_DecoderSetVoutMouseEvent( decoder_t *dec, vlc_mouse_event mouse_event,
- void *user_data )
+void input_DecoderSetVoutMouseEvent( vlc_input_decoder_t *owner,
+ vlc_mouse_event mouse_event,
+ void *user_data )
{
- struct decoder_owner *owner = dec_get_owner( dec );
- assert( dec->fmt_in.i_cat == VIDEO_ES );
+ assert( owner->dec.fmt_in.i_cat == VIDEO_ES );
vlc_mutex_lock( &owner->mouse_lock );
@@ -2625,11 +2597,10 @@ void input_DecoderSetVoutMouseEvent( decoder_t *dec, vlc_mouse_event mouse_event
vlc_mutex_unlock( &owner->mouse_lock );
}
-int input_DecoderAddVoutOverlay( decoder_t *dec, subpicture_t *sub,
+int input_DecoderAddVoutOverlay( vlc_input_decoder_t *owner, subpicture_t *sub,
size_t *channel )
{
- struct decoder_owner *owner = dec_get_owner( dec );
- assert( dec->fmt_in.i_cat == VIDEO_ES );
+ assert( owner->dec.fmt_in.i_cat == VIDEO_ES );
assert( sub && channel );
vlc_mutex_lock( &owner->lock );
@@ -2656,10 +2627,9 @@ int input_DecoderAddVoutOverlay( decoder_t *dec, subpicture_t *sub,
return VLC_SUCCESS;
}
-int input_DecoderDelVoutOverlay( decoder_t *dec, size_t channel )
+int input_DecoderDelVoutOverlay( vlc_input_decoder_t *owner, size_t channel )
{
- struct decoder_owner *owner = dec_get_owner( dec );
- assert( dec->fmt_in.i_cat == VIDEO_ES );
+ assert( owner->dec.fmt_in.i_cat == VIDEO_ES );
vlc_mutex_lock( &owner->lock );
@@ -2674,11 +2644,10 @@ int input_DecoderDelVoutOverlay( decoder_t *dec, size_t channel )
return VLC_SUCCESS;
}
-int input_DecoderSetSpuHighlight( decoder_t *dec,
+int input_DecoderSetSpuHighlight( vlc_input_decoder_t *p_owner,
const vlc_spu_highlight_t *spu_hl )
{
- struct decoder_owner *p_owner = dec_get_owner( dec );
- assert( dec->fmt_in.i_cat == SPU_ES );
+ assert( p_owner->dec.fmt_in.i_cat == SPU_ES );
#ifdef ENABLE_SOUT
if( p_owner->p_sout_input )
diff --git a/src/input/decoder.h b/src/input/decoder.h
index 216d02b053..6ef0dc95f6 100644
--- a/src/input/decoder.h
+++ b/src/input/decoder.h
@@ -30,38 +30,38 @@
struct input_decoder_callbacks {
/* notifications */
- void (*on_vout_started)(decoder_t *decoder, vout_thread_t *vout,
- enum vlc_vout_order vout_order,
- void *userdata);
- void (*on_vout_stopped)(decoder_t *decoder, vout_thread_t *vout,
+ void (*on_vout_started)(vlc_input_decoder_t *decoder, vout_thread_t *vout,
+ enum vlc_vout_order vout_order,
void *userdata);
- void (*on_thumbnail_ready)(decoder_t *decoder, picture_t *pic,
+ void (*on_vout_stopped)(vlc_input_decoder_t *decoder, vout_thread_t *vout,
+ void *userdata);
+ void (*on_thumbnail_ready)(vlc_input_decoder_t *decoder, picture_t *pic,
void *userdata);
- void (*on_new_video_stats)(decoder_t *decoder, unsigned decoded,
+ void (*on_new_video_stats)(vlc_input_decoder_t *decoder, unsigned decoded,
unsigned lost, unsigned displayed,
void *userdata);
- void (*on_new_audio_stats)(decoder_t *decoder, unsigned decoded,
+ void (*on_new_audio_stats)(vlc_input_decoder_t *decoder, unsigned decoded,
unsigned lost, unsigned played, void *userdata);
/* requests */
- int (*get_attachments)(decoder_t *decoder,
+ int (*get_attachments)(vlc_input_decoder_t *decoder,
input_attachment_t ***ppp_attachment,
void *userdata);
};
-decoder_t *input_DecoderNew( vlc_object_t *parent, es_format_t *, vlc_clock_t *,
- input_resource_t *, sout_instance_t *,
- bool thumbnailing,
- const struct input_decoder_callbacks *cbs,
- void *userdata ) VLC_USED;
+vlc_input_decoder_t *
+input_DecoderNew( vlc_object_t *parent, es_format_t *, vlc_clock_t *,
+ input_resource_t *, sout_instance_t *, bool thumbnailing,
+ const struct input_decoder_callbacks *cbs,
+ void *userdata ) VLC_USED;
/**
* This function changes the pause state.
* The date parameter MUST hold the exact date at which the change has been
* done for proper vout/aout pausing.
*/
-void input_DecoderChangePause( decoder_t *, bool b_paused, vlc_tick_t i_date );
+void input_DecoderChangePause( vlc_input_decoder_t *, bool b_paused, vlc_tick_t i_date );
/**
* Changes the decoder rate.
@@ -70,54 +70,54 @@ void input_DecoderChangePause( decoder_t *, bool b_paused, vlc_tick_t i_date );
* \param dec decoder
* \param rate playback rate (default is 1)
*/
-void input_DecoderChangeRate( decoder_t *dec, float rate );
+void input_DecoderChangeRate( vlc_input_decoder_t *dec, float rate );
/**
* This function changes the delay.
*/
-void input_DecoderChangeDelay( decoder_t *, vlc_tick_t i_delay );
+void input_DecoderChangeDelay( vlc_input_decoder_t *, vlc_tick_t i_delay );
/**
* This function makes the decoder start waiting for a valid data block from its fifo.
*/
-void input_DecoderStartWait( decoder_t * );
+void input_DecoderStartWait( vlc_input_decoder_t * );
/**
* This function waits for the decoder to actually receive data.
*/
-void input_DecoderWait( decoder_t * );
+void input_DecoderWait( vlc_input_decoder_t * );
/**
* This function exits the waiting mode of the decoder.
*/
-void input_DecoderStopWait( decoder_t * );
+void input_DecoderStopWait( vlc_input_decoder_t * );
/**
* This function returns true if the decoder fifo is empty and false otherwise.
*/
-bool input_DecoderIsEmpty( decoder_t * );
+bool input_DecoderIsEmpty( vlc_input_decoder_t * );
/**
* This function activates the request closed caption channel.
*/
-int input_DecoderSetCcState( decoder_t *, vlc_fourcc_t, int i_channel, bool b_decode );
+int input_DecoderSetCcState( vlc_input_decoder_t *, vlc_fourcc_t, int i_channel, bool b_decode );
/**
* This function returns an error if the requested channel does not exist and
* set pb_decode to the channel status(active or not) otherwise.
*/
-int input_DecoderGetCcState( decoder_t *, vlc_fourcc_t, int i_channel, bool *pb_decode );
+int input_DecoderGetCcState( vlc_input_decoder_t *, vlc_fourcc_t, int i_channel, bool *pb_decode );
/**
* This function get cc channels descriptions
*/
-void input_DecoderGetCcDesc( decoder_t *, decoder_cc_desc_t * );
+void input_DecoderGetCcDesc( vlc_input_decoder_t *, decoder_cc_desc_t * );
/**
* This function force the display of the next picture and fills the stream
* time consumed.
*/
-void input_DecoderFrameNext( decoder_t *p_dec, vlc_tick_t *pi_duration );
+void input_DecoderFrameNext( vlc_input_decoder_t *p_dec, vlc_tick_t *pi_duration );
/**
* This function will return true if the ES format or meta data have changed since
@@ -127,19 +127,19 @@ void input_DecoderFrameNext( decoder_t *p_dec, vlc_tick_t *pi_duration );
* vlc_meta_Delete.
* Otherwise it will return false and will not initialize p_fmt and *pp_meta.
*/
-bool input_DecoderHasFormatChanged( decoder_t *p_dec, es_format_t *p_fmt, vlc_meta_t **pp_meta );
+bool input_DecoderHasFormatChanged( vlc_input_decoder_t *p_dec, es_format_t *p_fmt, vlc_meta_t **pp_meta );
/**
* This function returns the current size in bytes of the decoder fifo
*/
-size_t input_DecoderGetFifoSize( decoder_t *p_dec );
+size_t input_DecoderGetFifoSize( vlc_input_decoder_t *p_dec );
-int input_DecoderGetVbiPage( decoder_t *, bool *opaque );
-int input_DecoderSetVbiPage( decoder_t *, unsigned page );
-int input_DecoderSetVbiOpaque( decoder_t *, bool opaque );
+int input_DecoderGetVbiPage( vlc_input_decoder_t *, bool *opaque );
+int input_DecoderSetVbiPage( vlc_input_decoder_t *, unsigned page );
+int input_DecoderSetVbiOpaque( vlc_input_decoder_t *, bool opaque );
-void input_DecoderSetVoutMouseEvent( decoder_t *, vlc_mouse_event, void * );
-int input_DecoderAddVoutOverlay( decoder_t *, subpicture_t *, size_t * );
-int input_DecoderDelVoutOverlay( decoder_t *, size_t );
+void input_DecoderSetVoutMouseEvent( vlc_input_decoder_t *, vlc_mouse_event, void * );
+int input_DecoderAddVoutOverlay( vlc_input_decoder_t *, subpicture_t *, size_t * );
+int input_DecoderDelVoutOverlay( vlc_input_decoder_t *, size_t );
#endif
diff --git a/src/input/es_out.c b/src/input/es_out.c
index 3973e3e0fc..03a41c0b99 100644
--- a/src/input/es_out.c
+++ b/src/input/es_out.c
@@ -127,8 +127,8 @@ struct es_out_id_t
char *psz_title;
bool b_terminated;
- decoder_t *p_dec;
- decoder_t *p_dec_record;
+ vlc_input_decoder_t *p_dec;
+ vlc_input_decoder_t *p_dec_record;
vlc_clock_t *p_clock;
/* Used by vlc_clock_cbs, need to be const during the lifetime of the clock */
@@ -279,7 +279,7 @@ static inline int EsOutGetClosedCaptionsChannel( const es_format_t *p_fmt )
vlc_list_foreach( pos, (!fetes_i ? &p_sys->es : &p_sys->es_slaves), node )
static void
-decoder_on_vout_started(decoder_t *decoder, vout_thread_t *vout,
+decoder_on_vout_started(vlc_input_decoder_t *decoder, vout_thread_t *vout,
enum vlc_vout_order order, void *userdata)
{
(void) decoder;
@@ -302,7 +302,7 @@ decoder_on_vout_started(decoder_t *decoder, vout_thread_t *vout,
}
static void
-decoder_on_vout_stopped(decoder_t *decoder, vout_thread_t *vout, void *userdata)
+decoder_on_vout_stopped(vlc_input_decoder_t *decoder, vout_thread_t *vout, void *userdata)
{
(void) decoder;
@@ -324,7 +324,7 @@ decoder_on_vout_stopped(decoder_t *decoder, vout_thread_t *vout, void *userdata)
}
static void
-decoder_on_thumbnail_ready(decoder_t *decoder, picture_t *pic, void *userdata)
+decoder_on_thumbnail_ready(vlc_input_decoder_t *decoder, picture_t *pic, void *userdata)
{
(void) decoder;
@@ -344,7 +344,7 @@ decoder_on_thumbnail_ready(decoder_t *decoder, picture_t *pic, void *userdata)
}
static void
-decoder_on_new_video_stats(decoder_t *decoder, unsigned decoded, unsigned lost,
+decoder_on_new_video_stats(vlc_input_decoder_t *decoder, unsigned decoded, unsigned lost,
unsigned displayed, void *userdata)
{
(void) decoder;
@@ -369,7 +369,7 @@ decoder_on_new_video_stats(decoder_t *decoder, unsigned decoded, unsigned lost,
}
static void
-decoder_on_new_audio_stats(decoder_t *decoder, unsigned decoded, unsigned lost,
+decoder_on_new_audio_stats(vlc_input_decoder_t *decoder, unsigned decoded, unsigned lost,
unsigned played, void *userdata)
{
(void) decoder;
@@ -394,7 +394,7 @@ decoder_on_new_audio_stats(decoder_t *decoder, unsigned decoded, unsigned lost,
}
static int
-decoder_get_attachments(decoder_t *decoder,
+decoder_get_attachments(vlc_input_decoder_t *decoder,
input_attachment_t ***ppp_attachment,
void *userdata)
{
@@ -2146,7 +2146,7 @@ static void EsOutCreateDecoder( es_out_t *out, es_out_id_t *p_es )
{
es_out_sys_t *p_sys = container_of(out, es_out_sys_t, out);
input_thread_t *p_input = p_sys->p_input;
- decoder_t *dec;
+ vlc_input_decoder_t *dec;
static const struct vlc_clock_cbs clock_cbs = {
.on_update = ClockUpdate
--
2.20.1
More information about the vlc-devel
mailing list