[vlc-commits] decoder: rename input_Decoder*() to vlc_input_decoder_()
Thomas Guillem
git at videolan.org
Thu Mar 19 09:23:37 CET 2020
vlc | branch: master | Thomas Guillem <thomas at gllm.fr> | Wed Mar 18 15:09:20 2020 +0100| [3d275aded44fdee075faacf0ae24ca9b6da9ff28] | committer: Thomas Guillem
decoder: rename input_Decoder*() to vlc_input_decoder_()
In order to match with vlc_input_decoder_t.
> http://git.videolan.org/gitweb.cgi/vlc.git/?a=commit;h=3d275aded44fdee075faacf0ae24ca9b6da9ff28
---
include/vlc_decoder.h | 12 ++---
modules/stream_out/display.c | 9 ++--
src/input/decoder.c | 107 ++++++++++++++++++------------------
src/input/decoder.h | 48 ++++++++---------
src/input/es_out.c | 125 ++++++++++++++++++++++---------------------
src/libvlccore.sym | 12 ++---
6 files changed, 160 insertions(+), 153 deletions(-)
diff --git a/include/vlc_decoder.h b/include/vlc_decoder.h
index 4652fbb479..94cceda61a 100644
--- a/include/vlc_decoder.h
+++ b/include/vlc_decoder.h
@@ -40,12 +40,12 @@ typedef struct input_resource_t input_resource_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 * );
+vlc_input_decoder_Create( vlc_object_t *, const es_format_t *, input_resource_t * ) VLC_USED;
+VLC_API void vlc_input_decoder_Delete( vlc_input_decoder_t * );
+VLC_API void vlc_input_decoder_Decode( vlc_input_decoder_t *, block_t *, bool b_do_pace );
+VLC_API void vlc_input_decoder_Drain( vlc_input_decoder_t * );
+VLC_API void vlc_input_decoder_Flush( vlc_input_decoder_t * );
+VLC_API int vlc_input_decoder_SetSpuHighlight( 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 de78a2f34d..4f9abe980c 100644
--- a/modules/stream_out/display.c
+++ b/modules/stream_out/display.c
@@ -147,7 +147,8 @@ static void *Add( sout_stream_t *p_stream, const es_format_t *p_fmt )
}
vlc_input_decoder_t *p_dec =
- input_DecoderCreate( VLC_OBJECT(p_stream), p_fmt, p_sys->p_resource );
+ vlc_input_decoder_Create( 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 +161,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( id );
+ vlc_input_decoder_Delete( id );
}
static int Send( sout_stream_t *p_stream, void *id, block_t *p_buffer )
@@ -185,7 +186,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( id, p_buffer, false );
+ vlc_input_decoder_Decode( id, p_buffer, false );
}
p_buffer = p_next;
@@ -200,7 +201,7 @@ static int Control( sout_stream_t *p_stream, int i_query, va_list args )
{
vlc_input_decoder_t *p_dec = va_arg(args, void *);
void *spu_hl = va_arg(args, void *);
- return input_DecoderSetSpuHighlight( p_dec, spu_hl );
+ return vlc_input_decoder_SetSpuHighlight( p_dec, spu_hl );
}
(void) p_stream;
return VLC_EGENERIC;
diff --git a/src/input/decoder.c b/src/input/decoder.c
index 39546b93f8..0c216bfca4 100644
--- a/src/input/decoder.c
+++ b/src/input/decoder.c
@@ -68,7 +68,7 @@ struct vlc_input_decoder_t
input_resource_t*p_resource;
vlc_clock_t *p_clock;
- const struct input_decoder_callbacks *cbs;
+ const struct vlc_input_decoder_callbacks *cbs;
void *cbs_userdata;
ssize_t i_spu_channel;
@@ -1648,7 +1648,7 @@ static void *DecoderThread( void *p_data )
vlc_fifo_Lock( p_owner->p_fifo );
- /* Reset flushing after DecoderThread_ProcessInput in case input_DecoderFlush
+ /* Reset flushing after DecoderThread_ProcessInput in case vlc_input_decoder_Flush
* is called again. This will avoid a second useless flush (but
* harmless). */
p_owner->flushing = false;
@@ -1803,12 +1803,12 @@ static const struct decoder_owner_callbacks dec_spu_cbs =
* \param b_packetizer instead of a decoder
* \return the decoder object
*/
-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,
- const struct input_decoder_callbacks *cbs,
- void *cbs_userdata )
+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, const struct vlc_input_decoder_callbacks *cbs,
+ void *cbs_userdata )
{
decoder_t *p_dec;
vlc_input_decoder_t *p_owner;
@@ -2065,7 +2065,7 @@ 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 struct vlc_input_decoder_callbacks *cbs, void *userdata)
{
const char *psz_type = p_sout ? N_("packetizer") : N_("decoder");
int i_priority;
@@ -2133,10 +2133,10 @@ decoder_New( vlc_object_t *p_parent, const es_format_t *fmt,
* \return the spawned decoder object
*/
vlc_input_decoder_t *
-input_DecoderNew( vlc_object_t *parent, es_format_t *fmt,
+vlc_input_decoder_New( 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,
+ const struct vlc_input_decoder_callbacks *cbs,
void *cbs_userdata)
{
return decoder_New( parent, fmt, p_clock, resource, p_sout, thumbnailing,
@@ -2147,7 +2147,7 @@ input_DecoderNew( vlc_object_t *parent, es_format_t *fmt,
* Spawn a decoder thread outside of the input thread.
*/
vlc_input_decoder_t *
-input_DecoderCreate( vlc_object_t *p_parent, const es_format_t *fmt,
+vlc_input_decoder_Create( 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,
@@ -2162,7 +2162,7 @@ input_DecoderCreate( vlc_object_t *p_parent, const es_format_t *fmt,
* \param p_es the es descriptor
* \return nothing
*/
-void input_DecoderDelete( vlc_input_decoder_t *p_owner )
+void vlc_input_decoder_Delete( vlc_input_decoder_t *p_owner )
{
decoder_t *p_dec = &p_owner->dec;
@@ -2197,7 +2197,7 @@ void input_DecoderDelete( vlc_input_decoder_t *p_owner )
if( p_owner->cc.b_supported )
{
for( int i = 0; i < MAX_CC_DECODERS; i++ )
- input_DecoderSetCcState( p_owner, VLC_CODEC_CEA608, i, false );
+ vlc_input_decoder_SetCcState( p_owner, VLC_CODEC_CEA608, i, false );
}
/* Delete decoder */
@@ -2211,7 +2211,8 @@ void input_DecoderDelete( vlc_input_decoder_t *p_owner )
* \param p_dec the decoder object
* \param p_block the data block
*/
-void input_DecoderDecode( vlc_input_decoder_t *p_owner, block_t *p_block, bool b_do_pace )
+void vlc_input_decoder_Decode( vlc_input_decoder_t *p_owner, block_t *p_block,
+ bool b_do_pace )
{
vlc_fifo_Lock( p_owner->p_fifo );
if( !b_do_pace )
@@ -2240,7 +2241,7 @@ void input_DecoderDecode( vlc_input_decoder_t *p_owner, block_t *p_block, bool b
vlc_fifo_Unlock( p_owner->p_fifo );
}
-bool input_DecoderIsEmpty( vlc_input_decoder_t * p_owner )
+bool vlc_input_decoder_IsEmpty( vlc_input_decoder_t * p_owner )
{
assert( !p_owner->b_waiting );
@@ -2279,7 +2280,7 @@ bool input_DecoderIsEmpty( vlc_input_decoder_t * p_owner )
* @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( vlc_input_decoder_t *p_owner )
+void vlc_input_decoder_Drain( vlc_input_decoder_t *p_owner )
{
vlc_fifo_Lock( p_owner->p_fifo );
p_owner->b_draining = true;
@@ -2291,7 +2292,7 @@ void input_DecoderDrain( vlc_input_decoder_t *p_owner )
* Requests that the decoder immediately discard all pending buffers.
* This is useful when seeking or when deselecting a stream.
*/
-void input_DecoderFlush( vlc_input_decoder_t *p_owner )
+void vlc_input_decoder_Flush( vlc_input_decoder_t *p_owner )
{
vlc_fifo_Lock( p_owner->p_fifo );
@@ -2336,15 +2337,16 @@ void input_DecoderFlush( vlc_input_decoder_t *p_owner )
}
}
-void input_DecoderGetCcDesc( vlc_input_decoder_t *p_owner, decoder_cc_desc_t *p_desc )
+void vlc_input_decoder_GetCcDesc( vlc_input_decoder_t *p_owner,
+ decoder_cc_desc_t *p_desc )
{
vlc_mutex_lock( &p_owner->lock );
*p_desc = p_owner->cc.desc;
vlc_mutex_unlock( &p_owner->lock );
}
-static bool input_DecoderHasCCChanFlag( vlc_input_decoder_t *p_owner,
- vlc_fourcc_t codec, int i_channel )
+static bool vlc_input_decoder_HasCCChanFlag( vlc_input_decoder_t *p_owner,
+ vlc_fourcc_t codec, int i_channel )
{
int i_max_channels;
uint64_t i_bitmap;
@@ -2364,13 +2366,13 @@ static bool input_DecoderHasCCChanFlag( vlc_input_decoder_t *p_owner,
( i_bitmap & ((uint64_t)1 << i_channel) ) );
}
-int input_DecoderSetCcState( vlc_input_decoder_t *p_owner, vlc_fourcc_t codec,
- int i_channel, bool b_decode )
+int vlc_input_decoder_SetCcState( vlc_input_decoder_t *p_owner, vlc_fourcc_t codec,
+ int i_channel, bool b_decode )
{
decoder_t *p_dec = &p_owner->dec;
- //msg_Warn( p_dec, "input_DecoderSetCcState: %d @%x", b_decode, i_channel );
+ //msg_Warn( p_dec, "vlc_input_decoder_SetCcState: %d @%x", b_decode, i_channel );
- if( !input_DecoderHasCCChanFlag( p_owner, codec, i_channel ) )
+ if( !vlc_input_decoder_HasCCChanFlag( p_owner, codec, i_channel ) )
return VLC_EGENERIC;
if( b_decode )
@@ -2381,7 +2383,7 @@ int input_DecoderSetCcState( vlc_input_decoder_t *p_owner, vlc_fourcc_t codec,
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_ccowner = input_DecoderNew( VLC_OBJECT(p_dec), &fmt, p_owner->p_clock,
+ p_ccowner = vlc_input_decoder_New( VLC_OBJECT(p_dec), &fmt, p_owner->p_clock,
p_owner->p_resource, p_owner->p_sout, false,
NULL, NULL );
if( !p_ccowner )
@@ -2395,7 +2397,7 @@ int input_DecoderSetCcState( vlc_input_decoder_t *p_owner, vlc_fourcc_t codec,
else if( !p_ccowner->dec.p_module )
{
DecoderUnsupportedCodec( p_dec, &fmt, true );
- input_DecoderDelete(p_ccowner);
+ vlc_input_decoder_Delete(p_ccowner);
return VLC_EGENERIC;
}
p_ccowner->p_clock = p_owner->p_clock;
@@ -2414,15 +2416,15 @@ int input_DecoderSetCcState( vlc_input_decoder_t *p_owner, vlc_fourcc_t codec,
vlc_mutex_unlock( &p_owner->lock );
if( p_cc )
- input_DecoderDelete(p_cc);
+ vlc_input_decoder_Delete(p_cc);
}
return VLC_SUCCESS;
}
-int input_DecoderGetCcState( vlc_input_decoder_t *p_owner, vlc_fourcc_t codec,
- int i_channel, bool *pb_decode )
+int vlc_input_decoder_GetCcState( vlc_input_decoder_t *p_owner, vlc_fourcc_t codec,
+ int i_channel, bool *pb_decode )
{
- if( !input_DecoderHasCCChanFlag( p_owner, codec, i_channel ) )
+ if( !vlc_input_decoder_HasCCChanFlag( p_owner, codec, i_channel ) )
return VLC_EGENERIC;
vlc_mutex_lock( &p_owner->lock );
@@ -2431,7 +2433,8 @@ int input_DecoderGetCcState( vlc_input_decoder_t *p_owner, vlc_fourcc_t codec,
return VLC_SUCCESS;
}
-void input_DecoderChangePause( vlc_input_decoder_t *p_owner, bool b_paused, vlc_tick_t i_date )
+void vlc_input_decoder_ChangePause( vlc_input_decoder_t *p_owner,
+ bool b_paused, vlc_tick_t i_date )
{
/* 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
@@ -2444,21 +2447,21 @@ void input_DecoderChangePause( vlc_input_decoder_t *p_owner, bool b_paused, vlc_
vlc_fifo_Unlock( p_owner->p_fifo );
}
-void input_DecoderChangeRate( vlc_input_decoder_t *owner, float rate )
+void vlc_input_decoder_ChangeRate( vlc_input_decoder_t *owner, float rate )
{
vlc_fifo_Lock( owner->p_fifo );
owner->request_rate = rate;
vlc_fifo_Unlock( owner->p_fifo );
}
-void input_DecoderChangeDelay( vlc_input_decoder_t *owner, vlc_tick_t delay )
+void vlc_input_decoder_ChangeDelay( vlc_input_decoder_t *owner, vlc_tick_t delay )
{
vlc_fifo_Lock( owner->p_fifo );
owner->delay = delay;
vlc_fifo_Unlock( owner->p_fifo );
}
-void input_DecoderStartWait( vlc_input_decoder_t *p_owner )
+void vlc_input_decoder_StartWait( vlc_input_decoder_t *p_owner )
{
assert( !p_owner->b_waiting );
@@ -2470,7 +2473,7 @@ void input_DecoderStartWait( vlc_input_decoder_t *p_owner )
vlc_mutex_unlock( &p_owner->lock );
}
-void input_DecoderStopWait( vlc_input_decoder_t *p_owner )
+void vlc_input_decoder_StopWait( vlc_input_decoder_t *p_owner )
{
assert( p_owner->b_waiting );
@@ -2480,7 +2483,7 @@ void input_DecoderStopWait( vlc_input_decoder_t *p_owner )
vlc_mutex_unlock( &p_owner->lock );
}
-void input_DecoderWait( vlc_input_decoder_t *p_owner )
+void vlc_input_decoder_Wait( vlc_input_decoder_t *p_owner )
{
assert( p_owner->b_waiting );
@@ -2504,7 +2507,8 @@ void input_DecoderWait( vlc_input_decoder_t *p_owner )
vlc_mutex_unlock( &p_owner->lock );
}
-void input_DecoderFrameNext( vlc_input_decoder_t *p_owner, vlc_tick_t *pi_duration )
+void vlc_input_decoder_FrameNext( vlc_input_decoder_t *p_owner,
+ vlc_tick_t *pi_duration )
{
assert( p_owner->paused );
*pi_duration = 0;
@@ -2523,7 +2527,8 @@ void input_DecoderFrameNext( vlc_input_decoder_t *p_owner, vlc_tick_t *pi_durati
vlc_mutex_unlock( &p_owner->lock );
}
-bool input_DecoderHasFormatChanged( vlc_input_decoder_t *p_owner, es_format_t *p_fmt, vlc_meta_t **pp_meta )
+bool vlc_input_decoder_HasFormatChanged( vlc_input_decoder_t *p_owner,
+ es_format_t *p_fmt, vlc_meta_t **pp_meta )
{
if( !atomic_exchange_explicit( &p_owner->b_fmt_description, false,
memory_order_acquire ) )
@@ -2547,7 +2552,7 @@ bool input_DecoderHasFormatChanged( vlc_input_decoder_t *p_owner, es_format_t *p
return true;
}
-size_t input_DecoderGetFifoSize( vlc_input_decoder_t *p_owner )
+size_t vlc_input_decoder_GetFifoSize( vlc_input_decoder_t *p_owner )
{
return block_FifoSize( p_owner->p_fifo );
}
@@ -2558,7 +2563,7 @@ static bool DecoderHasVbi( decoder_t *dec )
&& var_Type( dec, "vbi-page" ) == VLC_VAR_INTEGER;
}
-int input_DecoderGetVbiPage( vlc_input_decoder_t *owner, bool *opaque )
+int vlc_input_decoder_GetVbiPage( vlc_input_decoder_t *owner, bool *opaque )
{
decoder_t *dec = &owner->dec;
if( !DecoderHasVbi( dec ) )
@@ -2567,7 +2572,7 @@ int input_DecoderGetVbiPage( vlc_input_decoder_t *owner, bool *opaque )
return var_GetInteger( dec, "vbi-page" );
}
-int input_DecoderSetVbiPage( vlc_input_decoder_t *owner, unsigned page )
+int vlc_input_decoder_SetVbiPage( vlc_input_decoder_t *owner, unsigned page )
{
decoder_t *dec = &owner->dec;
if( !DecoderHasVbi( dec ) )
@@ -2575,7 +2580,7 @@ int input_DecoderSetVbiPage( vlc_input_decoder_t *owner, unsigned page )
return var_SetInteger( dec, "vbi-page", page );
}
-int input_DecoderSetVbiOpaque( vlc_input_decoder_t *owner, bool opaque )
+int vlc_input_decoder_SetVbiOpaque( vlc_input_decoder_t *owner, bool opaque )
{
decoder_t *dec = &owner->dec;
if( !DecoderHasVbi( dec ) )
@@ -2583,9 +2588,9 @@ int input_DecoderSetVbiOpaque( vlc_input_decoder_t *owner, bool opaque )
return var_SetBool( dec, "vbi-opaque", opaque );
}
-void input_DecoderSetVoutMouseEvent( vlc_input_decoder_t *owner,
- vlc_mouse_event mouse_event,
- void *user_data )
+void vlc_input_decoder_SetVoutMouseEvent( vlc_input_decoder_t *owner,
+ vlc_mouse_event mouse_event,
+ void *user_data )
{
assert( owner->dec.fmt_in.i_cat == VIDEO_ES );
@@ -2597,8 +2602,8 @@ void input_DecoderSetVoutMouseEvent( vlc_input_decoder_t *owner,
vlc_mutex_unlock( &owner->mouse_lock );
}
-int input_DecoderAddVoutOverlay( vlc_input_decoder_t *owner, subpicture_t *sub,
- size_t *channel )
+int vlc_input_decoder_AddVoutOverlay( vlc_input_decoder_t *owner, subpicture_t *sub,
+ size_t *channel )
{
assert( owner->dec.fmt_in.i_cat == VIDEO_ES );
assert( sub && channel );
@@ -2627,7 +2632,7 @@ int input_DecoderAddVoutOverlay( vlc_input_decoder_t *owner, subpicture_t *sub,
return VLC_SUCCESS;
}
-int input_DecoderDelVoutOverlay( vlc_input_decoder_t *owner, size_t channel )
+int vlc_input_decoder_DelVoutOverlay( vlc_input_decoder_t *owner, size_t channel )
{
assert( owner->dec.fmt_in.i_cat == VIDEO_ES );
@@ -2644,8 +2649,8 @@ int input_DecoderDelVoutOverlay( vlc_input_decoder_t *owner, size_t channel )
return VLC_SUCCESS;
}
-int input_DecoderSetSpuHighlight( vlc_input_decoder_t *p_owner,
- const vlc_spu_highlight_t *spu_hl )
+int vlc_input_decoder_SetSpuHighlight( vlc_input_decoder_t *p_owner,
+ const vlc_spu_highlight_t *spu_hl )
{
assert( p_owner->dec.fmt_in.i_cat == SPU_ES );
diff --git a/src/input/decoder.h b/src/input/decoder.h
index 6ef0dc95f6..b5a05e232e 100644
--- a/src/input/decoder.h
+++ b/src/input/decoder.h
@@ -28,7 +28,7 @@
#include <vlc_codec.h>
#include <vlc_mouse.h>
-struct input_decoder_callbacks {
+struct vlc_input_decoder_callbacks {
/* notifications */
void (*on_vout_started)(vlc_input_decoder_t *decoder, vout_thread_t *vout,
enum vlc_vout_order vout_order,
@@ -51,17 +51,17 @@ struct input_decoder_callbacks {
};
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;
+vlc_input_decoder_New( vlc_object_t *parent, es_format_t *, vlc_clock_t *,
+ input_resource_t *, sout_instance_t *, bool thumbnailing,
+ const struct vlc_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( vlc_input_decoder_t *, bool b_paused, vlc_tick_t i_date );
+void vlc_input_decoder_ChangePause( vlc_input_decoder_t *, bool b_paused, vlc_tick_t i_date );
/**
* Changes the decoder rate.
@@ -70,54 +70,54 @@ void input_DecoderChangePause( vlc_input_decoder_t *, bool b_paused, vlc_tick_t
* \param dec decoder
* \param rate playback rate (default is 1)
*/
-void input_DecoderChangeRate( vlc_input_decoder_t *dec, float rate );
+void vlc_input_decoder_ChangeRate( vlc_input_decoder_t *dec, float rate );
/**
* This function changes the delay.
*/
-void input_DecoderChangeDelay( vlc_input_decoder_t *, vlc_tick_t i_delay );
+void vlc_input_decoder_ChangeDelay( 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( vlc_input_decoder_t * );
+void vlc_input_decoder_StartWait( vlc_input_decoder_t * );
/**
* This function waits for the decoder to actually receive data.
*/
-void input_DecoderWait( vlc_input_decoder_t * );
+void vlc_input_decoder_Wait( vlc_input_decoder_t * );
/**
* This function exits the waiting mode of the decoder.
*/
-void input_DecoderStopWait( vlc_input_decoder_t * );
+void vlc_input_decoder_StopWait( vlc_input_decoder_t * );
/**
* This function returns true if the decoder fifo is empty and false otherwise.
*/
-bool input_DecoderIsEmpty( vlc_input_decoder_t * );
+bool vlc_input_decoder_IsEmpty( vlc_input_decoder_t * );
/**
* This function activates the request closed caption channel.
*/
-int input_DecoderSetCcState( vlc_input_decoder_t *, vlc_fourcc_t, int i_channel, bool b_decode );
+int vlc_input_decoder_SetCcState( 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( vlc_input_decoder_t *, vlc_fourcc_t, int i_channel, bool *pb_decode );
+int vlc_input_decoder_GetCcState( vlc_input_decoder_t *, vlc_fourcc_t, int i_channel, bool *pb_decode );
/**
* This function get cc channels descriptions
*/
-void input_DecoderGetCcDesc( vlc_input_decoder_t *, decoder_cc_desc_t * );
+void vlc_input_decoder_GetCcDesc( 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( vlc_input_decoder_t *p_dec, vlc_tick_t *pi_duration );
+void vlc_input_decoder_FrameNext( 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( vlc_input_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( vlc_input_decoder_t *p_dec, es_format_t *p_fmt, vlc_meta_t **pp_meta );
+bool vlc_input_decoder_HasFormatChanged( 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( vlc_input_decoder_t *p_dec );
+size_t vlc_input_decoder_GetFifoSize( vlc_input_decoder_t *p_dec );
-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 );
+int vlc_input_decoder_GetVbiPage( vlc_input_decoder_t *, bool *opaque );
+int vlc_input_decoder_SetVbiPage( vlc_input_decoder_t *, unsigned page );
+int vlc_input_decoder_SetVbiOpaque( vlc_input_decoder_t *, bool opaque );
-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 );
+void vlc_input_decoder_SetVoutMouseEvent( vlc_input_decoder_t *, vlc_mouse_event, void * );
+int vlc_input_decoder_AddVoutOverlay( vlc_input_decoder_t *, subpicture_t *, size_t * );
+int vlc_input_decoder_DelVoutOverlay( vlc_input_decoder_t *, size_t );
#endif
diff --git a/src/input/es_out.c b/src/input/es_out.c
index 03a41c0b99..d6fa3e41e7 100644
--- a/src/input/es_out.c
+++ b/src/input/es_out.c
@@ -410,7 +410,7 @@ decoder_get_attachments(vlc_input_decoder_t *decoder,
return input_GetAttachments(p_sys->p_input, ppp_attachment);
}
-static const struct input_decoder_callbacks decoder_cbs = {
+static const struct vlc_input_decoder_callbacks decoder_cbs = {
.on_vout_started = decoder_on_vout_started,
.on_vout_stopped = decoder_on_vout_stopped,
.on_thumbnail_ready = decoder_on_thumbnail_ready,
@@ -637,7 +637,7 @@ static void EsOutTerminate( es_out_t *out )
foreach_es_then_es_slaves(es)
{
if (es->p_dec != NULL)
- input_DecoderDelete(es->p_dec);
+ vlc_input_decoder_Delete(es->p_dec);
EsTerminate(es);
EsRelease(es);
@@ -706,9 +706,9 @@ static bool EsOutDecodersIsEmpty( es_out_t *out )
foreach_es_then_es_slaves(es)
{
- if( es->p_dec && !input_DecoderIsEmpty( es->p_dec ) )
+ if( es->p_dec && !vlc_input_decoder_IsEmpty( es->p_dec ) )
return false;
- if( es->p_dec_record && !input_DecoderIsEmpty( es->p_dec_record ) )
+ if( es->p_dec_record && !vlc_input_decoder_IsEmpty( es->p_dec_record ) )
return false;
}
return true;
@@ -806,13 +806,13 @@ static int EsOutSetRecord( es_out_t *out, bool b_record )
continue;
p_es->p_dec_record =
- input_DecoderNew( VLC_OBJECT(p_input), &p_es->fmt, NULL,
- input_priv(p_input)->p_resource,
- p_sys->p_sout_record, false,
- &decoder_cbs, p_es );
+ vlc_input_decoder_New( VLC_OBJECT(p_input), &p_es->fmt, NULL,
+ input_priv(p_input)->p_resource,
+ p_sys->p_sout_record, false,
+ &decoder_cbs, p_es );
if( p_es->p_dec_record && p_sys->b_buffering )
- input_DecoderStartWait( p_es->p_dec_record );
+ vlc_input_decoder_StartWait( p_es->p_dec_record );
}
}
else
@@ -822,7 +822,7 @@ static int EsOutSetRecord( es_out_t *out, bool b_record )
if( !p_es->p_dec_record )
continue;
- input_DecoderDelete( p_es->p_dec_record );
+ vlc_input_decoder_Delete( p_es->p_dec_record );
p_es->p_dec_record = NULL;
}
#ifdef ENABLE_SOUT
@@ -884,7 +884,7 @@ static void EsOutChangeRate( es_out_t *out, float rate )
foreach_es_then_es_slaves(es)
if( es->p_dec != NULL )
- input_DecoderChangeRate( es->p_dec, rate );
+ vlc_input_decoder_ChangeRate( es->p_dec, rate );
}
static void EsOutChangePosition( es_out_t *out, bool b_flush )
@@ -898,12 +898,12 @@ static void EsOutChangePosition( es_out_t *out, bool b_flush )
if( p_es->p_dec != NULL )
{
if( b_flush )
- input_DecoderFlush( p_es->p_dec );
+ vlc_input_decoder_Flush( p_es->p_dec );
if( !p_sys->b_buffering )
{
- input_DecoderStartWait( p_es->p_dec );
+ vlc_input_decoder_StartWait( p_es->p_dec );
if( p_es->p_dec_record != NULL )
- input_DecoderStartWait( p_es->p_dec_record );
+ vlc_input_decoder_StartWait( p_es->p_dec_record );
}
}
@@ -992,9 +992,9 @@ static void EsOutDecodersStopBuffering( es_out_t *out, bool b_forced )
{
if( !p_es->p_dec || p_es->fmt.i_cat == SPU_ES )
continue;
- input_DecoderWait( p_es->p_dec );
+ vlc_input_decoder_Wait( p_es->p_dec );
if( p_es->p_dec_record )
- input_DecoderWait( p_es->p_dec_record );
+ vlc_input_decoder_Wait( p_es->p_dec_record );
}
msg_Dbg( p_sys->p_input, "Decoder wait done in %d ms",
@@ -1021,9 +1021,9 @@ static void EsOutDecodersStopBuffering( es_out_t *out, bool b_forced )
if( !p_es->p_dec )
continue;
- input_DecoderStopWait( p_es->p_dec );
+ vlc_input_decoder_StopWait( p_es->p_dec );
if( p_es->p_dec_record )
- input_DecoderStopWait( p_es->p_dec_record );
+ vlc_input_decoder_StopWait( p_es->p_dec_record );
}
}
static void EsOutDecodersChangePause( es_out_t *out, bool b_paused, vlc_tick_t i_date )
@@ -1035,9 +1035,10 @@ static void EsOutDecodersChangePause( es_out_t *out, bool b_paused, vlc_tick_t i
foreach_es_then_es_slaves(es)
if( es->p_dec )
{
- input_DecoderChangePause( es->p_dec, b_paused, i_date );
+ vlc_input_decoder_ChangePause( es->p_dec, b_paused, i_date );
if( es->p_dec_record )
- input_DecoderChangePause( es->p_dec_record, b_paused, i_date );
+ vlc_input_decoder_ChangePause( es->p_dec_record, b_paused,
+ i_date );
}
}
@@ -1050,9 +1051,9 @@ static bool EsOutIsExtraBufferingAllowed( es_out_t *out )
foreach_es_then_es_slaves(p_es)
{
if( p_es->p_dec )
- i_size += input_DecoderGetFifoSize( p_es->p_dec );
+ i_size += vlc_input_decoder_GetFifoSize( p_es->p_dec );
if( p_es->p_dec_record )
- i_size += input_DecoderGetFifoSize( p_es->p_dec_record );
+ i_size += vlc_input_decoder_GetFifoSize( p_es->p_dec_record );
}
//msg_Info( out, "----- EsOutIsExtraBufferingAllowed =% 5d KiB -- ", i_size / 1024 );
@@ -1092,9 +1093,9 @@ static void EsOutDecoderChangeDelay( es_out_t *out, es_out_id_t *p_es )
return;
if( p_es->p_dec )
- input_DecoderChangeDelay( p_es->p_dec, i_delay );
+ vlc_input_decoder_ChangeDelay( p_es->p_dec, i_delay );
if( p_es->p_dec_record )
- input_DecoderChangeDelay( p_es->p_dec_record, i_delay );
+ vlc_input_decoder_ChangeDelay( p_es->p_dec_record, i_delay );
}
static void EsOutProgramsChangeRate( es_out_t *out )
{
@@ -1132,7 +1133,7 @@ static void EsOutFrameNext( es_out_t *out )
}
vlc_tick_t i_duration;
- input_DecoderFrameNext( p_es_video->p_dec, &i_duration );
+ vlc_input_decoder_FrameNext( p_es_video->p_dec, &i_duration );
msg_Dbg( p_sys->p_input, "EsOutFrameNext consummed %d ms", (int)MS_FROM_VLC_TICK(i_duration) );
@@ -2120,8 +2121,8 @@ static bool EsIsSelected( es_out_id_t *es )
if( es->p_master->p_dec )
{
int i_channel = EsOutGetClosedCaptionsChannel( &es->fmt );
- input_DecoderGetCcState( es->p_master->p_dec, es->fmt.i_codec,
- i_channel, &b_decode );
+ vlc_input_decoder_GetCcState( es->p_master->p_dec, es->fmt.i_codec,
+ i_channel, &b_decode );
}
return b_decode;
}
@@ -2178,29 +2179,29 @@ static void EsOutCreateDecoder( es_out_t *out, es_out_id_t *p_es )
}
input_thread_private_t *priv = input_priv(p_input);
- dec = input_DecoderNew( VLC_OBJECT(p_input), &p_es->fmt, p_es->p_clock,
- priv->p_resource, priv->p_sout,
- priv->b_thumbnailing, &decoder_cbs, p_es );
+ dec = vlc_input_decoder_New( VLC_OBJECT(p_input), &p_es->fmt, p_es->p_clock,
+ priv->p_resource, priv->p_sout,
+ priv->b_thumbnailing, &decoder_cbs, p_es );
if( dec != NULL )
{
- input_DecoderChangeRate( dec, p_sys->rate );
+ vlc_input_decoder_ChangeRate( dec, p_sys->rate );
if( p_sys->b_buffering )
- input_DecoderStartWait( dec );
+ vlc_input_decoder_StartWait( dec );
if( !p_es->p_master && p_sys->p_sout_record )
{
p_es->p_dec_record =
- input_DecoderNew( VLC_OBJECT(p_input), &p_es->fmt, NULL,
- priv->p_resource, p_sys->p_sout_record, false,
- &decoder_cbs, p_es );
+ vlc_input_decoder_New( VLC_OBJECT(p_input), &p_es->fmt, NULL,
+ priv->p_resource, p_sys->p_sout_record,
+ false, &decoder_cbs, p_es );
if( p_es->p_dec_record && p_sys->b_buffering )
- input_DecoderStartWait( p_es->p_dec_record );
+ vlc_input_decoder_StartWait( p_es->p_dec_record );
}
if( p_es->mouse_event_cb && p_es->fmt.i_cat == VIDEO_ES )
- input_DecoderSetVoutMouseEvent( dec, p_es->mouse_event_cb,
- p_es->mouse_event_userdata );
+ vlc_input_decoder_SetVoutMouseEvent( dec, p_es->mouse_event_cb,
+ p_es->mouse_event_userdata );
}
else
{
@@ -2220,7 +2221,7 @@ static void EsOutDestroyDecoder( es_out_t *out, es_out_id_t *p_es )
assert( p_es->p_pgrm );
- input_DecoderDelete( p_es->p_dec );
+ vlc_input_decoder_Delete( p_es->p_dec );
p_es->p_dec = NULL;
if( p_es->p_pgrm->p_master_clock == p_es->p_clock )
p_es->p_pgrm->p_master_clock = NULL;
@@ -2229,7 +2230,7 @@ static void EsOutDestroyDecoder( es_out_t *out, es_out_id_t *p_es )
if( p_es->p_dec_record )
{
- input_DecoderDelete( p_es->p_dec_record );
+ vlc_input_decoder_Delete( p_es->p_dec_record );
p_es->p_dec_record = NULL;
}
@@ -2260,8 +2261,8 @@ static void EsOutSelectEs( es_out_t *out, es_out_id_t *es, bool b_force )
i_channel = EsOutGetClosedCaptionsChannel( &es->fmt );
if( i_channel == -1 ||
- input_DecoderSetCcState( es->p_master->p_dec, es->fmt.i_codec,
- i_channel, true ) )
+ vlc_input_decoder_SetCcState( es->p_master->p_dec, es->fmt.i_codec,
+ i_channel, true ) )
return;
}
else
@@ -2316,7 +2317,7 @@ static void EsOutSelectEs( es_out_t *out, es_out_id_t *es, bool b_force )
if( !es->p_master )
{
bool vbi_opaque;
- int vbi_page = input_DecoderGetVbiPage( es->p_dec, &vbi_opaque );
+ int vbi_page = vlc_input_decoder_GetVbiPage( es->p_dec, &vbi_opaque );
if( vbi_page >= 0 )
{
input_SendEventVbiPage( p_input, vbi_page );
@@ -2334,7 +2335,7 @@ static void EsOutDrainCCChannels( es_out_id_t *parent )
if( (i_bitmap & 1) == 0 || !parent->cc.pp_es[i] ||
!parent->cc.pp_es[i]->p_dec )
continue;
- input_DecoderDrain( parent->cc.pp_es[i]->p_dec );
+ vlc_input_decoder_Drain( parent->cc.pp_es[i]->p_dec );
}
}
@@ -2382,8 +2383,8 @@ static void EsOutUnselectEs( es_out_t *out, es_out_id_t *es, bool b_update )
{
int i_channel = EsOutGetClosedCaptionsChannel( &es->fmt );
if( i_channel != -1 )
- input_DecoderSetCcState( es->p_master->p_dec, es->fmt.i_codec,
- i_channel, false );
+ vlc_input_decoder_SetCcState( es->p_master->p_dec, es->fmt.i_codec,
+ i_channel, false );
}
}
else
@@ -2771,15 +2772,15 @@ static int EsOutSend( es_out_t *out, es_out_id_t *es, block_t *p_block )
{
block_t *p_dup = block_Duplicate( p_block );
if( p_dup )
- input_DecoderDecode( es->p_dec_record, p_dup,
- input_priv(p_input)->b_out_pace_control );
+ vlc_input_decoder_Decode( es->p_dec_record, p_dup,
+ input_priv(p_input)->b_out_pace_control );
}
- input_DecoderDecode( es->p_dec, p_block,
- input_priv(p_input)->b_out_pace_control );
+ vlc_input_decoder_Decode( es->p_dec, p_block,
+ input_priv(p_input)->b_out_pace_control );
es_format_t fmt_dsc;
vlc_meta_t *p_meta_dsc;
- if( input_DecoderHasFormatChanged( es->p_dec, &fmt_dsc, &p_meta_dsc ) )
+ if( vlc_input_decoder_HasFormatChanged( es->p_dec, &fmt_dsc, &p_meta_dsc ) )
{
if (EsOutEsUpdateFmt( out, es, &fmt_dsc) == VLC_SUCCESS)
EsOutSendEsEvent(out, es, VLC_INPUT_ES_UPDATED, false);
@@ -2794,7 +2795,7 @@ static int EsOutSend( es_out_t *out, es_out_id_t *es, block_t *p_block )
/* Check CC status */
decoder_cc_desc_t desc;
- input_DecoderGetCcDesc( es->p_dec, &desc );
+ vlc_input_decoder_GetCcDesc( es->p_dec, &desc );
if( var_InheritInteger( p_input, "captions" ) == 708 )
EsOutCreateCCChannels( out, VLC_CODEC_CEA708, desc.i_708_channels,
_("DTVCC Closed captions %u"), es );
@@ -2815,12 +2816,12 @@ EsOutDrainDecoder( es_out_t *out, es_out_id_t *es )
/* FIXME: This might hold the ES output caller (i.e. the demux), and
* the corresponding thread (typically the input thread), for a little
* bit too long if the ES is deleted in the middle of a stream. */
- input_DecoderDrain( es->p_dec );
+ vlc_input_decoder_Drain( es->p_dec );
EsOutDrainCCChannels( es );
while( !input_Stopped(p_sys->p_input) && !p_sys->b_buffering )
{
- if( input_DecoderIsEmpty( es->p_dec ) &&
- ( !es->p_dec_record || input_DecoderIsEmpty( es->p_dec_record ) ))
+ if( vlc_input_decoder_IsEmpty( es->p_dec ) &&
+ ( !es->p_dec_record || vlc_input_decoder_IsEmpty( es->p_dec_record ) ))
break;
/* FIXME there should be a way to have auto deleted es, but there will be
* a problem when another codec of the same type is created (mainly video) */
@@ -3406,7 +3407,7 @@ static int EsOutVaControlLocked( es_out_t *out, input_source_t *source,
p_es->mouse_event_userdata = va_arg( args, void * );
if( p_es->p_dec )
- input_DecoderSetVoutMouseEvent( p_es->p_dec,
+ vlc_input_decoder_SetVoutMouseEvent( p_es->p_dec,
p_es->mouse_event_cb, p_es->mouse_event_userdata );
return VLC_SUCCESS;
@@ -3417,7 +3418,7 @@ static int EsOutVaControlLocked( es_out_t *out, input_source_t *source,
subpicture_t *sub = va_arg( args, subpicture_t * );
size_t *channel = va_arg( args, size_t * );
if( p_es && p_es->fmt.i_cat == VIDEO_ES && p_es->p_dec )
- return input_DecoderAddVoutOverlay( p_es->p_dec, sub, channel );
+ return vlc_input_decoder_AddVoutOverlay( p_es->p_dec, sub, channel );
return VLC_EGENERIC;
}
case ES_OUT_VOUT_DEL_OVERLAY:
@@ -3425,7 +3426,7 @@ static int EsOutVaControlLocked( es_out_t *out, input_source_t *source,
es_out_id_t *p_es = va_arg( args, es_out_id_t * );
size_t channel = va_arg( args, size_t );
if( p_es && p_es->fmt.i_cat == VIDEO_ES && p_es->p_dec )
- return input_DecoderDelVoutOverlay( p_es->p_dec, channel );
+ return vlc_input_decoder_DelVoutOverlay( p_es->p_dec, channel );
return VLC_EGENERIC;
}
case ES_OUT_SPU_SET_HIGHLIGHT:
@@ -3434,7 +3435,7 @@ static int EsOutVaControlLocked( es_out_t *out, input_source_t *source,
const vlc_spu_highlight_t *spu_hl =
va_arg( args, const vlc_spu_highlight_t * );
if( p_es && p_es->fmt.i_cat == SPU_ES && p_es->p_dec )
- return input_DecoderSetSpuHighlight( p_es->p_dec, spu_hl );
+ return vlc_input_decoder_SetSpuHighlight( p_es->p_dec, spu_hl );
return VLC_EGENERIC;
}
default: vlc_assert_unreachable();
@@ -3710,7 +3711,7 @@ static int EsOutVaPrivControlLocked( es_out_t *out, int query, va_list args )
es_out_id_t *id;
foreach_es_then_es_slaves(id)
if (id->p_dec != NULL)
- input_DecoderDrain(id->p_dec);
+ vlc_input_decoder_Drain(id->p_dec);
return VLC_SUCCESS;
}
case ES_OUT_PRIV_SET_VBI_PAGE:
@@ -3726,14 +3727,14 @@ static int EsOutVaPrivControlLocked( es_out_t *out, int query, va_list args )
if( query == ES_OUT_PRIV_SET_VBI_PAGE )
{
unsigned page = va_arg( args, unsigned );
- ret = input_DecoderSetVbiPage( es->p_dec, page );
+ ret = vlc_input_decoder_SetVbiPage( es->p_dec, page );
if( ret == VLC_SUCCESS )
input_SendEventVbiPage( p_sys->p_input, page );
}
else
{
bool opaque = va_arg( args, int );
- ret = input_DecoderSetVbiOpaque( es->p_dec, opaque );
+ ret = vlc_input_decoder_SetVbiOpaque( es->p_dec, opaque );
if( ret == VLC_SUCCESS )
input_SendEventVbiTransparency( p_sys->p_input, opaque );
}
diff --git a/src/libvlccore.sym b/src/libvlccore.sym
index caf4287842..66ae6f3ecd 100644
--- a/src/libvlccore.sym
+++ b/src/libvlccore.sym
@@ -164,12 +164,12 @@ image_HandlerDelete
image_Mime2Fourcc
image_Type2Fourcc
InitMD5
-input_DecoderCreate
-input_DecoderDelete
-input_DecoderDecode
-input_DecoderDrain
-input_DecoderFlush
-input_DecoderSetSpuHighlight
+vlc_input_decoder_Create
+vlc_input_decoder_Delete
+vlc_input_decoder_Decode
+vlc_input_decoder_Drain
+vlc_input_decoder_Flush
+vlc_input_decoder_SetSpuHighlight
input_item_AddInfo
input_item_AddOption
input_item_AddOptions
More information about the vlc-commits
mailing list