Browse Source

rename mtime_t to vlc_tick_t

Keep a copy of vlc_tick_tfor backward compatibility.
pull/73/head
Steve Lhomme 8 years ago
parent
commit
ff56c92a5e
  1. 2
      extras/analyser/vlc.vim
  2. 10
      include/vlc_aout.h
  3. 14
      include/vlc_block.h
  4. 4
      include/vlc_codec.h
  5. 3
      include/vlc_common.h
  6. 2
      include/vlc_demux.h
  7. 14
      include/vlc_es_out.h
  8. 2
      include/vlc_events.h
  9. 4
      include/vlc_filter.h
  10. 10
      include/vlc_input.h
  11. 8
      include/vlc_input_item.h
  12. 4
      include/vlc_interrupt.h
  13. 2
      include/vlc_media_library.h
  14. 10
      include/vlc_mtime.h
  15. 2
      include/vlc_picture.h
  16. 4
      include/vlc_picture_fifo.h
  17. 2
      include/vlc_playlist.h
  18. 4
      include/vlc_sout.h
  19. 2
      include/vlc_spu.h
  20. 10
      include/vlc_subpicture.h
  21. 18
      include/vlc_threads.h
  22. 2
      include/vlc_vout.h
  23. 2
      include/vlc_vout_display.h
  24. 2
      include/vlc_vout_osd.h
  25. 2
      include/vlc_vout_wrapper.h
  26. 4
      lib/libvlc_internal.h
  27. 6
      modules/access/alsa.c
  28. 18
      modules/access/avcapture.m
  29. 6
      modules/access/bluray.c
  30. 10
      modules/access/cdda.c
  31. 4
      modules/access/dcp/dcp.cpp
  32. 2
      modules/access/dshow/access.h
  33. 2
      modules/access/dshow/filter.cpp
  34. 2
      modules/access/dshow/filter.h
  35. 2
      modules/access/dtv/bdagraph.cpp
  36. 6
      modules/access/dtv/en50221.c
  37. 6
      modules/access/dvb/access.c
  38. 4
      modules/access/dvb/scan.c
  39. 4
      modules/access/dvdnav.c
  40. 20
      modules/access/dvdread.c
  41. 18
      modules/access/idummy.c
  42. 6
      modules/access/imem.c
  43. 4
      modules/access/linsys/linsys_hdsdi.c
  44. 6
      modules/access/linsys/linsys_sdi.c
  45. 6
      modules/access/live555.cpp
  46. 6
      modules/access/oss.c
  47. 4
      modules/access/pulse.c
  48. 10
      modules/access/qtsound.m
  49. 4
      modules/access/rdp.c
  50. 6
      modules/access/rtp/input.c
  51. 4
      modules/access/rtp/rtp.h
  52. 12
      modules/access/rtp/session.c
  53. 4
      modules/access/satip.c
  54. 4
      modules/access/screen/screen.h
  55. 2
      modules/access/screen/wayland.c
  56. 2
      modules/access/screen/xcb.c
  57. 2
      modules/access/shm.c
  58. 6
      modules/access/timecode.c
  59. 2
      modules/access/v4l2/demux.c
  60. 2
      modules/access/v4l2/radio.c
  61. 2
      modules/access/v4l2/v4l2.h
  62. 4
      modules/access/v4l2/video.c
  63. 4
      modules/access/vnc.c
  64. 8
      modules/access/wasapi.c
  65. 10
      modules/access_output/livehttp.c
  66. 12
      modules/access_output/udp.c
  67. 4
      modules/audio_filter/audiobargraph_a.c
  68. 6
      modules/audio_filter/channel_mixer/spatialaudio.cpp
  69. 4
      modules/audio_filter/resampler/soxr.c
  70. 4
      modules/audio_output/adummy.c
  71. 16
      modules/audio_output/alsa.c
  72. 4
      modules/audio_output/amem.c
  73. 42
      modules/audio_output/audiotrack.c
  74. 4
      modules/audio_output/audiounit_ios.m
  75. 8
      modules/audio_output/auhal.c
  76. 18
      modules/audio_output/coreaudio_common.c
  77. 12
      modules/audio_output/coreaudio_common.h
  78. 10
      modules/audio_output/directsound.c
  79. 8
      modules/audio_output/file.c
  80. 16
      modules/audio_output/jack.c
  81. 12
      modules/audio_output/kai.c
  82. 6
      modules/audio_output/mmdevice.c
  83. 6
      modules/audio_output/mmdevice.h
  84. 8
      modules/audio_output/opensles_android.c
  85. 12
      modules/audio_output/oss.c
  86. 18
      modules/audio_output/pulse.c
  87. 10
      modules/audio_output/sndio.c
  88. 4
      modules/audio_output/tizen_audio.c
  89. 2
      modules/audio_output/vlcpulse.c
  90. 2
      modules/audio_output/vlcpulse.h
  91. 2
      modules/audio_output/wasapi.c
  92. 16
      modules/audio_output/waveout.c
  93. 6
      modules/audio_output/winstore.c
  94. 4
      modules/codec/aom.c
  95. 4
      modules/codec/arib/substext.h
  96. 12
      modules/codec/avcodec/encoder.c
  97. 4
      modules/codec/avcodec/subtitle.c
  98. 10
      modules/codec/avcodec/video.c
  99. 10
      modules/codec/cc.c
  100. 12
      modules/codec/cea708.c

2
extras/analyser/vlc.vim

@ -23,7 +23,7 @@ function VlcSyntax()
syn keyword cConstant VLC_ESTATUS VLC_EEXIT VLC_EMODULE VLC_EOBJECT
syn keyword cConstant VLC_ENOOBJ VLC_ENOMOD VLC_VAR_ADDRESS
" custom types
syn keyword cType vlc_fixed_t mtime_t byte_t dctelem_t ssize_t off_t
syn keyword cType vlc_fixed_t vlc_tick_t byte_t dctelem_t ssize_t off_t
syn keyword cType vlc_bool_t vlc_fourcc_t vlc_value_t
" Core custom structures
syn keyword cType vlc_t libvlc_t vlc_object_t vlc_error_t vlc_status_t

10
include/vlc_aout.h

@ -166,7 +166,7 @@ struct audio_output
* \note This callback needs not be reentrant.
*/
int (*time_get)(audio_output_t *, mtime_t *delay);
int (*time_get)(audio_output_t *, vlc_tick_t *delay);
/**< Estimates playback buffer latency (mandatory, cannot be NULL).
*
* This callback computes an estimation of the delay until the current
@ -185,7 +185,7 @@ struct audio_output
* \note This callback cannot be called in stopped state.
*/
void (*play)(audio_output_t *, block_t *block, mtime_t date);
void (*play)(audio_output_t *, block_t *block, vlc_tick_t date);
/**< Queues a block of samples for playback (mandatory, cannot be NULL).
*
* \param block block of audio samples
@ -194,7 +194,7 @@ struct audio_output
* \note This callback cannot be called in stopped state.
*/
void (*pause)( audio_output_t *, bool pause, mtime_t date);
void (*pause)( audio_output_t *, bool pause, vlc_tick_t date);
/**< Pauses or resumes playback (mandatory, cannot be NULL).
*
* This callback pauses or resumes audio playback as quickly as possible.
@ -438,7 +438,7 @@ static inline void aout_RestartRequest(audio_output_t *aout, unsigned mode)
* Default implementation for audio_output_t.time_get
*/
static inline int aout_TimeGetDefault(audio_output_t *aout,
mtime_t *restrict delay)
vlc_tick_t *restrict delay)
{
(void) aout; (void) delay;
return -1;
@ -452,7 +452,7 @@ static inline int aout_TimeGetDefault(audio_output_t *aout,
* Do not use this unless there are really no possible better alternatives.
*/
static inline void aout_PauseDefault(audio_output_t *aout, bool paused,
mtime_t date)
vlc_tick_t date)
{
if (paused && aout->flush != NULL)
aout->flush(aout, false);

14
include/vlc_block.h

@ -121,9 +121,9 @@ struct block_t
uint32_t i_flags;
unsigned i_nb_samples; /* Used for audio */
mtime_t i_pts;
mtime_t i_dts;
mtime_t i_length;
vlc_tick_t i_pts;
vlc_tick_t i_dts;
vlc_tick_t i_length;
/* Rudimentary support for overloading block (de)allocation. */
block_free_t pf_release;
@ -364,10 +364,10 @@ static size_t block_ChainExtract( block_t *p_list, void *p_data, size_t i_max )
return i_total;
}
static inline void block_ChainProperties( block_t *p_list, int *pi_count, size_t *pi_size, mtime_t *pi_length )
static inline void block_ChainProperties( block_t *p_list, int *pi_count, size_t *pi_size, vlc_tick_t *pi_length )
{
size_t i_size = 0;
mtime_t i_length = 0;
vlc_tick_t i_length = 0;
int i_count = 0;
while( p_list )
@ -390,7 +390,7 @@ static inline void block_ChainProperties( block_t *p_list, int *pi_count, size_t
static inline block_t *block_ChainGather( block_t *p_list )
{
size_t i_total = 0;
mtime_t i_length = 0;
vlc_tick_t i_length = 0;
block_t *g;
if( p_list->p_next == NULL )
@ -534,7 +534,7 @@ VLC_API void vlc_fifo_WaitCond(vlc_fifo_t *, vlc_cond_t *);
* Atomically unlocks the FIFO and waits until one thread signals the FIFO up
* to a certain date, then locks the FIFO again. See vlc_fifo_Wait().
*/
int vlc_fifo_TimedWaitCond(vlc_fifo_t *, vlc_cond_t *, mtime_t);
int vlc_fifo_TimedWaitCond(vlc_fifo_t *, vlc_cond_t *, vlc_tick_t);
/**
* Queues a linked-list of blocks into a locked FIFO.

4
include/vlc_codec.h

@ -61,7 +61,7 @@ struct decoder_owner_callbacks
/* Display date
* cf. decoder_GetDisplayDate */
mtime_t (*get_display_date)( decoder_t *, mtime_t );
vlc_tick_t (*get_display_date)( decoder_t *, vlc_tick_t );
/* Display rate
* cf. decoder_GetDisplayRate */
float (*get_display_rate)( decoder_t * );
@ -434,7 +434,7 @@ static inline int decoder_GetInputAttachments( decoder_t *dec,
* You MUST use it *only* for gathering statistics about speed.
*/
VLC_USED
static inline mtime_t decoder_GetDisplayDate( decoder_t *dec, mtime_t i_ts )
static inline vlc_tick_t decoder_GetDisplayDate( decoder_t *dec, vlc_tick_t i_ts )
{
assert( dec->fmt_in.i_cat == VIDEO_ES && dec->cbs != NULL );
if( !dec->cbs->video.get_display_date )

3
include/vlc_common.h

@ -286,7 +286,8 @@
* epoch). Note that date and time intervals can be manipulated using regular
* arithmetic operators, and that no special functions are required.
*/
typedef int64_t mtime_t;
typedef int64_t vlc_tick_t;
typedef vlc_tick_t mtime_t; /* deprecated, use vlc_tick_t */
/**
* The vlc_fourcc_t type.

2
include/vlc_demux.h

@ -205,7 +205,7 @@ enum demux_query_e
* XXX: not mandatory (except for subtitle demux) but will help a lot
* for multi-input
*/
DEMUX_SET_NEXT_DEMUX_TIME, /* arg1= mtime_t can fail */
DEMUX_SET_NEXT_DEMUX_TIME, /* arg1= vlc_tick_t can fail */
/* FPS for correct subtitles handling */
DEMUX_GET_FPS, /* arg1= double * res=can fail */

14
include/vlc_es_out.h

@ -60,8 +60,8 @@ enum es_out_query_e
* XXX: if you want PREROLL just call ES_OUT_SET_NEXT_DISPLAY_TIME and send
* as you would normally do.
*/
ES_OUT_SET_PCR, /* arg1=mtime_t i_pcr(microsecond!) (using default group 0)*/
ES_OUT_SET_GROUP_PCR, /* arg1= int i_group, arg2=mtime_t i_pcr(microsecond!)*/
ES_OUT_SET_PCR, /* arg1=vlc_tick_t i_pcr(microsecond!) (using default group 0)*/
ES_OUT_SET_GROUP_PCR, /* arg1= int i_group, arg2=vlc_tick_t i_pcr(microsecond!)*/
ES_OUT_RESET_PCR, /* no arg */
/* Try not to use this one as it is a bit hacky */
@ -93,8 +93,8 @@ enum es_out_query_e
ES_OUT_SET_META, /* arg1=const vlc_meta_t * */
/* PCR system clock manipulation for external clock synchronization */
ES_OUT_GET_PCR_SYSTEM, /* arg1=mtime_t *, arg2=mtime_t * res=can fail */
ES_OUT_MODIFY_PCR_SYSTEM, /* arg1=int is_absolute, arg2=mtime_t, res=can fail */
ES_OUT_GET_PCR_SYSTEM, /* arg1=vlc_tick_t *, arg2=vlc_tick_t * res=can fail */
ES_OUT_MODIFY_PCR_SYSTEM, /* arg1=int is_absolute, arg2=vlc_tick_t, res=can fail */
ES_OUT_POST_SUBNODE, /* arg1=input_item_node_t *, res=can fail */
@ -160,7 +160,7 @@ static inline void es_out_Delete( es_out_t *p_out )
p_out->cbs->destroy( p_out );
}
static inline int es_out_SetPCR( es_out_t *out, mtime_t pcr )
static inline int es_out_SetPCR( es_out_t *out, vlc_tick_t pcr )
{
return es_out_Control( out, ES_OUT_SET_PCR, pcr );
}
@ -170,11 +170,11 @@ static inline int es_out_ControlSetMeta( es_out_t *out, const vlc_meta_t *p_meta
return es_out_Control( out, ES_OUT_SET_META, p_meta );
}
static inline int es_out_ControlGetPcrSystem( es_out_t *out, mtime_t *pi_system, mtime_t *pi_delay )
static inline int es_out_ControlGetPcrSystem( es_out_t *out, vlc_tick_t *pi_system, vlc_tick_t *pi_delay )
{
return es_out_Control( out, ES_OUT_GET_PCR_SYSTEM, pi_system, pi_delay );
}
static inline int es_out_ControlModifyPcrSystem( es_out_t *out, bool b_absolute, mtime_t i_system )
static inline int es_out_ControlModifyPcrSystem( es_out_t *out, bool b_absolute, vlc_tick_t i_system )
{
return es_out_Control( out, ES_OUT_MODIFY_PCR_SYSTEM, b_absolute, i_system );
}

2
include/vlc_events.h

@ -142,7 +142,7 @@ typedef struct vlc_event_t
} input_item_subitem_tree_added;
struct vlc_input_item_duration_changed
{
mtime_t new_duration;
vlc_tick_t new_duration;
} input_item_duration_changed;
struct vlc_input_item_preparsed_changed
{

4
include/vlc_filter.h

@ -98,7 +98,7 @@ struct filter_t
int, int, int );
/** Generate a subpicture (sub source) */
subpicture_t *(*pf_sub_source)( filter_t *, mtime_t );
subpicture_t *(*pf_sub_source)( filter_t *, vlc_tick_t );
/** Filter a subpicture (sub filter) */
subpicture_t *(*pf_sub_filter)( filter_t *, subpicture_t * );
@ -434,7 +434,7 @@ VLC_API void filter_chain_VideoFlush( filter_chain_t * );
* \param display_date of subpictures
*/
void filter_chain_SubSource(filter_chain_t *chain, spu_t *,
mtime_t display_date);
vlc_tick_t display_date);
/**
* Apply filter chain to subpictures.

10
include/vlc_input.h

@ -93,7 +93,7 @@ typedef struct input_title_t
{
char *psz_name;
mtime_t i_length; /* Length(microsecond) if known, else 0 */
vlc_tick_t i_length; /* Length(microsecond) if known, else 0 */
unsigned i_flags; /* Is it a menu or a normal entry */
@ -486,8 +486,8 @@ enum input_query_e
INPUT_SET_RENDERER, /* arg1=vlc_renderer_item_t* */
/* External clock managments */
INPUT_GET_PCR_SYSTEM, /* arg1=mtime_t *, arg2=mtime_t * res=can fail */
INPUT_MODIFY_PCR_SYSTEM,/* arg1=int absolute, arg2=mtime_t res=can fail */
INPUT_GET_PCR_SYSTEM, /* arg1=vlc_tick_t *, arg2=vlc_tick_t * res=can fail */
INPUT_MODIFY_PCR_SYSTEM,/* arg1=int absolute, arg2=vlc_tick_t res=can fail */
};
/** @}*/
@ -632,14 +632,14 @@ static inline int input_GetEsObjects( input_thread_t *p_input, int i_id,
/**
* \see input_clock_GetSystemOrigin
*/
static inline int input_GetPcrSystem( input_thread_t *p_input, mtime_t *pi_system, mtime_t *pi_delay )
static inline int input_GetPcrSystem( input_thread_t *p_input, vlc_tick_t *pi_system, vlc_tick_t *pi_delay )
{
return input_Control( p_input, INPUT_GET_PCR_SYSTEM, pi_system, pi_delay );
}
/**
* \see input_clock_ChangeSystemOrigin
*/
static inline int input_ModifyPcrSystem( input_thread_t *p_input, bool b_absolute, mtime_t i_system )
static inline int input_ModifyPcrSystem( input_thread_t *p_input, bool b_absolute, vlc_tick_t i_system )
{
return input_Control( p_input, INPUT_MODIFY_PCR_SYSTEM, b_absolute, i_system );
}

8
include/vlc_input_item.h

@ -69,7 +69,7 @@ struct input_item_t
unsigned optflagc;
input_item_opaque_t *opaques; /**< List of opaque pointer values */
mtime_t i_duration; /**< Duration in microseconds */
vlc_tick_t i_duration; /**< Duration in microseconds */
int i_categories; /**< Number of info categories */
@ -268,8 +268,8 @@ VLC_API char * input_item_GetTitleFbName( input_item_t * p_i ) VLC_USED;
VLC_API char * input_item_GetURI( input_item_t * p_i ) VLC_USED;
VLC_API char * input_item_GetNowPlayingFb( input_item_t *p_item ) VLC_USED;
VLC_API void input_item_SetURI( input_item_t * p_i, const char *psz_uri );
VLC_API mtime_t input_item_GetDuration( input_item_t * p_i );
VLC_API void input_item_SetDuration( input_item_t * p_i, mtime_t i_duration );
VLC_API vlc_tick_t input_item_GetDuration( input_item_t * p_i );
VLC_API void input_item_SetDuration( input_item_t * p_i, vlc_tick_t i_duration );
VLC_API bool input_item_IsPreparsed( input_item_t *p_i );
VLC_API bool input_item_IsArtFetched( input_item_t *p_i );
@ -330,7 +330,7 @@ VLC_API void input_item_MergeInfos( input_item_t *, info_category_t * );
*/
VLC_API input_item_t * input_item_NewExt( const char *psz_uri,
const char *psz_name,
mtime_t i_duration, int i_type,
vlc_tick_t i_duration, int i_type,
enum input_item_net_type i_net ) VLC_USED;
#define input_item_New( psz_uri, psz_name ) \

4
include/vlc_interrupt.h

@ -69,7 +69,7 @@ VLC_API int vlc_sem_wait_i11e(vlc_sem_t *);
* @return EINTR if an interruption occurred, otherwise 0 once the timestamp is
* reached.
*/
VLC_API int vlc_mwait_i11e(mtime_t);
VLC_API int vlc_mwait_i11e(vlc_tick_t);
/**
* Interruptible variant of msleep().
@ -82,7 +82,7 @@ VLC_API int vlc_mwait_i11e(mtime_t);
* @return EINTR if an interruption occurred, otherwise 0 once the timeout
* expired.
*/
static inline int vlc_msleep_i11e(mtime_t delay)
static inline int vlc_msleep_i11e(vlc_tick_t delay)
{
return vlc_mwait_i11e(mdate() + delay);
}

2
include/vlc_media_library.h

@ -116,7 +116,7 @@ typedef enum
typedef enum {
ML_TYPE_INT, /**< Object is an int */
ML_TYPE_PSZ, /**< A string char* */
ML_TYPE_TIME, /**< A timestamp mtime_t */
ML_TYPE_TIME, /**< A timestamp vlc_tick_t */
ML_TYPE_MEDIA, /**< A pointer to a media ml_media_t* */
} ml_result_type_e;

10
include/vlc_mtime.h

@ -58,7 +58,7 @@ VLC_API char * secstotimestr( char *psz_buffer, int32_t secs );
*/
struct date_t
{
mtime_t date;
vlc_tick_t date;
uint32_t i_divider_num;
uint32_t i_divider_den;
uint32_t i_remainder;
@ -88,7 +88,7 @@ VLC_API void date_Change(date_t *restrict date, uint32_t num, uint32_t den);
* \param date date to set the timestamp into
* \param value date value
*/
static inline void date_Set(date_t *restrict date, mtime_t value)
static inline void date_Set(date_t *restrict date, vlc_tick_t value)
{
date->date = value;
date->i_remainder = 0;
@ -100,7 +100,7 @@ static inline void date_Set(date_t *restrict date, mtime_t value)
* \param date date to fetch the timestamp from
* \return date value
*/
VLC_USED static inline mtime_t date_Get(const date_t *restrict date)
VLC_USED static inline vlc_tick_t date_Get(const date_t *restrict date)
{
return date->date;
}
@ -114,7 +114,7 @@ VLC_USED static inline mtime_t date_Get(const date_t *restrict date)
* \param count number of samples
* \return timestamp value after incrementing
*/
VLC_API mtime_t date_Increment(date_t *restrict date, uint32_t count);
VLC_API vlc_tick_t date_Increment(date_t *restrict date, uint32_t count);
/**
* Decrements a date.
@ -125,7 +125,7 @@ VLC_API mtime_t date_Increment(date_t *restrict date, uint32_t count);
* \param count number of samples
* \return date value
*/
VLC_API mtime_t date_Decrement(date_t *restrict date, uint32_t count);
VLC_API vlc_tick_t date_Decrement(date_t *restrict date, uint32_t count);
/** @} */

2
include/vlc_picture.h

@ -81,7 +81,7 @@ struct picture_t
* These properties can be modified using the video output thread API,
* but should never be written directly */
/**@{*/
mtime_t date; /**< display date */
vlc_tick_t date; /**< display date */
bool b_force;
/**@}*/

4
include/vlc_picture_fifo.h

@ -77,12 +77,12 @@ VLC_API void picture_fifo_Push( picture_fifo_t *, picture_t * );
*
* All pictures inside the fifo will be released by picture_Release.
*/
VLC_API void picture_fifo_Flush( picture_fifo_t *, mtime_t date, bool flush_before );
VLC_API void picture_fifo_Flush( picture_fifo_t *, vlc_tick_t date, bool flush_before );
/**
* It applies a delta on all the picture timestamp.
*/
VLC_API void picture_fifo_OffsetDate( picture_fifo_t *, mtime_t delta );
VLC_API void picture_fifo_OffsetDate( picture_fifo_t *, vlc_tick_t delta );
#endif /* VLC_PICTURE_FIFO_H */

2
include/vlc_playlist.h

@ -317,7 +317,7 @@ VLC_API input_thread_t *playlist_CurrentInputLocked( playlist_t *p_playlist ) VL
/** Get the duration of all items in a node.
*/
VLC_API mtime_t playlist_GetNodeDuration( playlist_item_t * );
VLC_API vlc_tick_t playlist_GetNodeDuration( playlist_item_t * );
/** Clear the playlist
* \param b_locked TRUE if playlist is locked when entering this function

4
include/vlc_sout.h

@ -143,7 +143,7 @@ struct sout_mux_t
bool b_add_stream_any_time;
bool b_waiting_stream;
/* we wait 1.5 second after first stream added */
mtime_t i_add_stream_start;
vlc_tick_t i_add_stream_start;
};
enum sout_mux_query_e
@ -169,7 +169,7 @@ VLC_API sout_input_t *sout_MuxAddStream( sout_mux_t *, const es_format_t * ) VLC
VLC_API void sout_MuxDeleteStream( sout_mux_t *, sout_input_t * );
VLC_API void sout_MuxDelete( sout_mux_t * );
VLC_API int sout_MuxSendBuffer( sout_mux_t *, sout_input_t *, block_t * );
VLC_API int sout_MuxGetStream(sout_mux_t *, unsigned, mtime_t *);
VLC_API int sout_MuxGetStream(sout_mux_t *, unsigned, vlc_tick_t *);
VLC_API void sout_MuxFlush( sout_mux_t *, sout_input_t * );
static inline int sout_MuxControl( sout_mux_t *p_mux, int i_query, ... )

2
include/vlc_spu.h

@ -73,7 +73,7 @@ VLC_API void spu_PutSubpicture( spu_t *, subpicture_t * );
*
* The returned value if non NULL must be released by subpicture_Delete().
*/
VLC_API subpicture_t * spu_Render( spu_t *, const vlc_fourcc_t *p_chroma_list, const video_format_t *p_fmt_dst, const video_format_t *p_fmt_src, mtime_t render_subtitle_date, mtime_t render_osd_date, bool ignore_osd );
VLC_API subpicture_t * spu_Render( spu_t *, const vlc_fourcc_t *p_chroma_list, const video_format_t *p_fmt_dst, const video_format_t *p_fmt_src, vlc_tick_t render_subtitle_date, vlc_tick_t render_osd_date, bool ignore_osd );
/**
* It registers a new SPU channel.

10
include/vlc_subpicture.h

@ -126,14 +126,14 @@ typedef struct
int (*pf_validate)( subpicture_t *,
bool has_src_changed, const video_format_t *p_fmt_src,
bool has_dst_changed, const video_format_t *p_fmt_dst,
mtime_t);
vlc_tick_t);
/** Mandatory callback called after pf_validate and doing
* the main job of creating the subpicture regions for the
* current video_format */
void (*pf_update) ( subpicture_t *,
const video_format_t *p_fmt_src,
const video_format_t *p_fmt_dst,
mtime_t );
vlc_tick_t );
/** Optional callback for subpicture private data cleanup */
void (*pf_destroy) ( subpicture_t * );
void *p_sys;
@ -167,8 +167,8 @@ struct subpicture_t
/** \name Date properties */
/**@{*/
mtime_t i_start; /**< beginning of display date */
mtime_t i_stop; /**< end of display date */
vlc_tick_t i_start; /**< beginning of display date */
vlc_tick_t i_stop; /**< end of display date */
bool b_ephemer; /**< If this flag is set to true the subtitle
will be displayed until the next one appear */
bool b_fade; /**< enable fading */
@ -217,7 +217,7 @@ VLC_API subpicture_t * subpicture_NewFromPicture( vlc_object_t *, picture_t *, v
* This function will update the content of a subpicture created with
* a non NULL subpicture_updater_t.
*/
VLC_API void subpicture_Update( subpicture_t *, const video_format_t *src, const video_format_t *, mtime_t );
VLC_API void subpicture_Update( subpicture_t *, const video_format_t *src, const video_format_t *, vlc_tick_t );
/**
* This function will blend a given subpicture onto a picture.

18
include/vlc_threads.h

@ -539,7 +539,7 @@ VLC_API void vlc_cond_wait(vlc_cond_t *cond, vlc_mutex_t *mutex);
* \return 0 if the condition was signaled, an error code in case of timeout.
*/
VLC_API int vlc_cond_timedwait(vlc_cond_t *cond, vlc_mutex_t *mutex,
mtime_t deadline);
vlc_tick_t deadline);
int vlc_cond_timedwait_daytime(vlc_cond_t *, vlc_mutex_t *, time_t);
@ -690,7 +690,7 @@ void vlc_addr_wait(void *addr, unsigned val);
* \return true if the function was woken up before the time-out,
* false if the time-out elapsed.
*/
bool vlc_addr_timedwait(void *addr, unsigned val, mtime_t delay);
bool vlc_addr_timedwait(void *addr, unsigned val, vlc_tick_t delay);
/**
* Wakes up one thread on an address.
@ -842,7 +842,7 @@ VLC_API unsigned long vlc_thread_id(void) VLC_USED;
*
* \return a timestamp in microseconds.
*/
VLC_API mtime_t mdate(void);
VLC_API vlc_tick_t mdate(void);
/**
* Waits until a deadline.
@ -852,7 +852,7 @@ VLC_API mtime_t mdate(void);
* \note The deadline may be exceeded due to OS scheduling.
* \note This function is a cancellation point.
*/
VLC_API void mwait(mtime_t deadline);
VLC_API void mwait(vlc_tick_t deadline);
/**
* Waits for an interval of time.
@ -862,7 +862,7 @@ VLC_API void mwait(mtime_t deadline);
* \note The delay may be exceeded due to OS scheduling.
* \note This function is a cancellation point.
*/
VLC_API void msleep(mtime_t delay);
VLC_API void msleep(vlc_tick_t delay);
#define VLC_HARD_MIN_SLEEP (CLOCK_FREQ/100) /* 10 milliseconds = 1 tick at 100Hz */
#define VLC_SOFT_MIN_SLEEP (9*CLOCK_FREQ) /* 9 seconds */
@ -877,7 +877,7 @@ static
__attribute__((unused))
__attribute__((noinline))
__attribute__((error("sorry, cannot sleep for such short a time")))
mtime_t impossible_delay( mtime_t delay )
vlc_tick_t impossible_delay( vlc_tick_t delay )
{
(void) delay;
return VLC_HARD_MIN_SLEEP;
@ -887,7 +887,7 @@ static
__attribute__((unused))
__attribute__((noinline))
__attribute__((warning("use proper event handling instead of short delay")))
mtime_t harmful_delay( mtime_t delay )
vlc_tick_t harmful_delay( vlc_tick_t delay )
{
return delay;
}
@ -905,7 +905,7 @@ static
__attribute__((unused))
__attribute__((noinline))
__attribute__((error("deadlines can not be constant")))
mtime_t impossible_deadline( mtime_t deadline )
vlc_tick_t impossible_deadline( vlc_tick_t deadline )
{
return deadline;
}
@ -967,7 +967,7 @@ VLC_API void vlc_timer_destroy(vlc_timer_t timer);
* repetition interval.
*/
VLC_API void vlc_timer_schedule(vlc_timer_t timer, bool absolute,
mtime_t value, mtime_t interval);
vlc_tick_t value, vlc_tick_t interval);
/**
* Fetches and resets the overrun counter for a timer.

2
include/vlc_vout.h

@ -94,7 +94,7 @@ struct vout_thread_t {
VLC_API int vout_GetSnapshot( vout_thread_t *p_vout,
block_t **pp_image, picture_t **pp_picture,
video_format_t *p_fmt,
const char *psz_format, mtime_t i_timeout );
const char *psz_format, vlc_tick_t i_timeout );
VLC_API void vout_ChangeAspectRatio( vout_thread_t *p_vout,
unsigned int i_num, unsigned int i_den );

2
include/vlc_vout_display.h

@ -268,7 +268,7 @@ struct vout_display_t {
* subpicture_t.
*/
void (*prepare)(vout_display_t *, picture_t *, subpicture_t *,
mtime_t date);
vlc_tick_t date);
/* Display a picture and an optional subpicture (mandatory).
*

2
include/vlc_vout_osd.h

@ -63,7 +63,7 @@ VLC_API int vout_OSDEpg( vout_thread_t *, input_item_t * );
* \param duration Duration of the text being displayed
* \param text Text to be displayed
*/
VLC_API void vout_OSDText( vout_thread_t *vout, int channel, int position, mtime_t duration, const char *text );
VLC_API void vout_OSDText( vout_thread_t *vout, int channel, int position, vlc_tick_t duration, const char *text );
/**
* \brief Write an informative message at the default location,

2
include/vlc_vout_wrapper.h

@ -42,7 +42,7 @@ static inline picture_pool_t *vout_display_Pool(vout_display_t *vd, unsigned cou
static inline void vout_display_Prepare(vout_display_t *vd,
picture_t *picture,
subpicture_t *subpicture,
mtime_t date)
vlc_tick_t date)
{
if (vd->prepare)
vd->prepare(vd, picture, subpicture, date);

4
lib/libvlc_internal.h

@ -99,12 +99,12 @@ void libvlc_event_send(
libvlc_event_manager_t * p_em,
libvlc_event_t * p_event );
static inline libvlc_time_t from_mtime(mtime_t time)
static inline libvlc_time_t from_mtime(vlc_tick_t time)
{
return (time + 500ULL)/ 1000ULL;
}
static inline mtime_t to_mtime(libvlc_time_t time)
static inline vlc_tick_t to_mtime(libvlc_time_t time)
{
return time * 1000ULL;
}

6
modules/access/alsa.c

@ -128,8 +128,8 @@ typedef struct
es_out_id_t *es;
vlc_thread_t thread;
mtime_t start;
mtime_t caching;
vlc_tick_t start;
vlc_tick_t caching;
snd_pcm_uframes_t period_size;
unsigned rate;
} demux_sys_t;
@ -179,7 +179,7 @@ static void *Thread (void *data)
/* Read data */
snd_pcm_sframes_t frames, delay;
mtime_t pts;
vlc_tick_t pts;
frames = snd_pcm_readi (pcm, block->p_buffer, sys->period_size);
pts = mdate ();

18
modules/access/avcapture.m

@ -73,8 +73,8 @@ vlc_module_end ()
CVImageBufferRef currentImageBuffer;
mtime_t currentPts;
mtime_t previousPts;
vlc_tick_t currentPts;
vlc_tick_t previousPts;
size_t bytesPerRow;
long timeScale;
@ -87,9 +87,9 @@ vlc_module_end ()
- (int)width;
- (int)height;
- (void)getVideoDimensions:(CMSampleBufferRef)sampleBuffer;
- (mtime_t)currentPts;
- (vlc_tick_t)currentPts;
- (void)captureOutput:(AVCaptureOutput *)captureOutput didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection;
- (mtime_t)copyCurrentFrameToBuffer:(void *)buffer;
- (vlc_tick_t)copyCurrentFrameToBuffer:(void *)buffer;
@end
@implementation VLCAVDecompressedVideoOutput : AVCaptureVideoDataOutput
@ -152,9 +152,9 @@ vlc_module_end ()
}
}
-(mtime_t)currentPts
-(vlc_tick_t)currentPts
{
mtime_t pts;
vlc_tick_t pts;
if ( !currentImageBuffer || currentPts == previousPts )
return 0;
@ -181,7 +181,7 @@ didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
@synchronized (self) {
imageBufferToRelease = currentImageBuffer;
currentImageBuffer = videoFrame;
currentPts = (mtime_t)presentationtimestamp.value;
currentPts = (vlc_tick_t)presentationtimestamp.value;
timeScale = (long)presentationtimestamp.timescale;
}
@ -189,10 +189,10 @@ didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer
}
}
- (mtime_t)copyCurrentFrameToBuffer:(void *)buffer
- (vlc_tick_t)copyCurrentFrameToBuffer:(void *)buffer
{
CVImageBufferRef imageBuffer;
mtime_t pts;
vlc_tick_t pts;
void *pixels;

6
modules/access/bluray.c

@ -177,7 +177,7 @@ typedef struct
bool b_menu;
bool b_menu_open;
bool b_popup_available;
mtime_t i_still_end_time;
vlc_tick_t i_still_end_time;
vlc_mutex_t bdj_overlay_lock; /* used to lock BD-J overlay open/close while overlays are being sent to vout */
@ -1159,7 +1159,7 @@ static void updater_unlock_overlay(bluray_spu_updater_sys_t *p_upd_sys)
static int subpictureUpdaterValidate(subpicture_t *p_subpic,
bool b_fmt_src, const video_format_t *p_fmt_src,
bool b_fmt_dst, const video_format_t *p_fmt_dst,
mtime_t i_ts)
vlc_tick_t i_ts)
{
VLC_UNUSED(b_fmt_src);
VLC_UNUSED(b_fmt_dst);
@ -1184,7 +1184,7 @@ static int subpictureUpdaterValidate(subpicture_t *p_subpic,
static void subpictureUpdaterUpdate(subpicture_t *p_subpic,
const video_format_t *p_fmt_src,
const video_format_t *p_fmt_dst,
mtime_t i_ts)
vlc_tick_t i_ts)
{
VLC_UNUSED(p_fmt_src);
VLC_UNUSED(p_fmt_dst);

10
modules/access/cdda.c

@ -197,13 +197,13 @@ static int DemuxControl(demux_t *demux, int query, va_list args)
break;
case DEMUX_GET_LENGTH:
*va_arg(args, mtime_t *) = (INT64_C(40000) * sys->length) / 3;
*va_arg(args, vlc_tick_t *) = (INT64_C(40000) * sys->length) / 3;
break;
case DEMUX_GET_TIME:
*va_arg(args, mtime_t *) = (INT64_C(40000) * sys->position) / 3;
*va_arg(args, vlc_tick_t *) = (INT64_C(40000) * sys->position) / 3;
break;
case DEMUX_SET_TIME:
sys->position = (va_arg(args, mtime_t) * 3) / INT64_C(40000);
sys->position = (va_arg(args, vlc_tick_t) * 3) / INT64_C(40000);
break;
default:
@ -467,8 +467,8 @@ static int ReadDir(stream_t *access, input_item_node_t *node)
name = NULL;
/* Create playlist items */
const mtime_t duration =
(mtime_t)(sys->p_sectors[i + 1] - sys->p_sectors[i])
const vlc_tick_t duration =
(vlc_tick_t)(sys->p_sectors[i + 1] - sys->p_sectors[i])
* CDDA_DATA_SIZE * CLOCK_FREQ / 44100 / 2 / 2;
input_item_t *item = input_item_NewDisc(access->psz_url,

4
modules/access/dcp/dcp.cpp

@ -162,7 +162,7 @@ class demux_sys_t
uint8_t pi_chan_table[AOUT_CHAN_MAX];
uint8_t i_channels;
mtime_t i_pts;
vlc_tick_t i_pts;
demux_sys_t():
PictureEssType ( ESS_UNKNOWN ),
@ -826,7 +826,7 @@ static int Control( demux_t *p_demux, int query, va_list args )
p_sys->frame_no = i64 * p_sys->frame_rate_num / ( CLOCK_FREQ * p_sys->frame_rate_denom );
p_sys->i_pts= i64;
es_out_SetPCR(p_demux->out, p_sys->i_pts);
es_out_Control( p_demux->out, ES_OUT_SET_NEXT_DISPLAY_TIME, ( mtime_t ) i64 );
es_out_Control( p_demux->out, ES_OUT_SET_NEXT_DISPLAY_TIME, ( vlc_tick_t ) i64 );
break;
case DEMUX_GET_PTS_DELAY:
pi64 = va_arg( args, int64_t * );

2
modules/access/dshow/access.h

@ -79,6 +79,6 @@ struct access_sys_t
int i_width;
int i_height;
int i_chroma;
mtime_t i_start;
vlc_tick_t i_start;
};

2
modules/access/dshow/filter.cpp

@ -638,7 +638,7 @@ STDMETHODIMP CapturePin::Receive( IMediaSample *pSample )
msg_Dbg( p_input, "CapturePin::Receive" );
#endif
mtime_t i_timestamp = mdate() * 10;
vlc_tick_t i_timestamp = mdate() * 10;
VLCMediaSample vlc_sample = {pSample, i_timestamp};
vlc_mutex_lock( &p_sys->lock );

2
modules/access/dshow/filter.h

@ -31,7 +31,7 @@
struct VLCMediaSample
{
ComPtr<IMediaSample> p_sample;
mtime_t i_timestamp;
vlc_tick_t i_timestamp;
};
/* */

2
modules/access/dtv/bdagraph.cpp

@ -340,7 +340,7 @@ ssize_t BDAOutput::Pop(void *buf, size_t len, int ms)
vlc_mutex_locker l( &lock );
mtime_t i_deadline = mdate() + ms * 1000;
vlc_tick_t i_deadline = mdate() + ms * 1000;
while( !p_first )
{
if( vlc_cond_timedwait( &wait, &lock, i_deadline ) )

6
modules/access/dtv/en50221.c

@ -120,7 +120,7 @@ struct cam
vlc_object_t *obj;
int fd;
int i_ca_type;
mtime_t i_timeout, i_next_event;
vlc_tick_t i_timeout, i_next_event;
unsigned i_nb_slots;
bool pb_active_slot[MAX_CI_SLOTS];
@ -1404,7 +1404,7 @@ static void ConditionalAccessOpen( cam_t * p_cam, unsigned i_session_id )
typedef struct
{
int i_interval;
mtime_t i_last;
vlc_tick_t i_last;
} date_time_t;
/*****************************************************************************
@ -1488,7 +1488,7 @@ static void DateTimeManage( cam_t * p_cam, int i_session_id )
(date_time_t *)p_cam->p_sessions[i_session_id - 1].p_sys;
if ( p_date->i_interval
&& mdate() > p_date->i_last + (mtime_t)p_date->i_interval * CLOCK_FREQ )
&& mdate() > p_date->i_last + (vlc_tick_t)p_date->i_interval * CLOCK_FREQ )
{
DateTimeSend( p_cam, i_session_id );
}

6
modules/access/dvb/access.c

@ -292,19 +292,19 @@ static int ScanReadCallback( scan_t *p_scan, void *p_privdata,
FrontendGetStatus( &p_sys->dvb, &status );
bool b_has_lock = status.b_has_lock;
mtime_t i_scan_start = mdate();
vlc_tick_t i_scan_start = mdate();
for( ; *pi_count == 0; )
{
/* Find if some data is available */
int i_ret;
mtime_t i_timeout = b_has_lock ? i_probe_timeout:
vlc_tick_t i_timeout = b_has_lock ? i_probe_timeout:
DVB_SCAN_MAX_LOCK_TIME;
do
{
mtime_t i_poll_timeout = i_scan_start - mdate() + i_timeout;
vlc_tick_t i_poll_timeout = i_scan_start - mdate() + i_timeout;
i_ret = 0;

4
modules/access/dvb/scan.c

@ -812,7 +812,7 @@ static int scan_Next( scan_t *p_scan, scan_tuner_config_t *p_cfg )
//while( !scan_tuner_config_ParametersValidate( &p_scan->parameter, p_cfg ) );
const size_t i_total_services = scan_CountServices( p_scan );
const mtime_t i_eta = f_position > 0.005 ? (mdate() - p_scan->i_time_start) * ( 1.0 / f_position - 1.0 ) : -1;
const vlc_tick_t i_eta = f_position > 0.005 ? (mdate() - p_scan->i_time_start) * ( 1.0 / f_position - 1.0 ) : -1;
char psz_eta[MSTRTIME_MAX_SIZE];
const char *psz_fmt = _("%.1f MHz (%d services)\n~%s remaining");
@ -876,7 +876,7 @@ int scan_Run( scan_t *p_scan )
for( ;; )
{
unsigned i_timeout = scan_session_GetTablesTimeout( session );
mtime_t i_remaining = mdate() - i_scan_start;
vlc_tick_t i_remaining = mdate() - i_scan_start;
if( i_remaining > i_timeout )
break;

4
modules/access/dvdnav.c

@ -162,7 +162,7 @@ typedef struct
unsigned updates;
/* length of program group chain */
mtime_t i_pgc_length;
vlc_tick_t i_pgc_length;
int i_vobu_index;
int i_vobu_flush;
} demux_sys_t;
@ -871,7 +871,7 @@ static int Demux( demux_t *p_demux )
if( event->length != 0xff && p_sys->still.b_created )
{
mtime_t delay = event->length * CLOCK_FREQ;
vlc_tick_t delay = event->length * CLOCK_FREQ;
vlc_timer_schedule( p_sys->still.timer, false, delay, 0 );
}

20
modules/access/dvdread.c

@ -124,14 +124,14 @@ typedef struct
int i_title_end_block;
int i_title_blocks;
int i_title_offset;
mtime_t i_title_cur_time;
vlc_tick_t i_title_cur_time;
int i_title_start_cell;
int i_title_end_cell;
int i_cur_cell;
int i_next_cell;
mtime_t i_cell_cur_time;
mtime_t i_cell_duration;
vlc_tick_t i_cell_cur_time;
vlc_tick_t i_cell_duration;
/* Track */
ps_track_t tk[PS_TK_COUNT];
@ -229,9 +229,9 @@ static int Open( vlc_object_t *p_this )
ps_track_init( p_sys->tk );
p_sys->i_sar_num = 0;
p_sys->i_sar_den = 0;
p_sys->i_title_cur_time = (mtime_t) 0;
p_sys->i_cell_cur_time = (mtime_t) 0;
p_sys->i_cell_duration = (mtime_t) 0;
p_sys->i_title_cur_time = (vlc_tick_t) 0;
p_sys->i_cell_cur_time = (vlc_tick_t) 0;
p_sys->i_cell_duration = (vlc_tick_t) 0;
p_sys->p_dvdread = p_dvdread;
p_sys->p_vmg_file = p_vmg_file;
@ -1186,8 +1186,8 @@ static void DvdReadHandleDSI( demux_t *p_demux, uint8_t *p_data )
/*
* Store the timecodes so we can get the current time
*/
p_sys->i_title_cur_time = (mtime_t) p_sys->dsi_pack.dsi_gi.nv_pck_scr / 90 * 1000;
p_sys->i_cell_cur_time = (mtime_t) dvdtime_to_time( &p_sys->dsi_pack.dsi_gi.c_eltm, 0 );
p_sys->i_title_cur_time = (vlc_tick_t) p_sys->dsi_pack.dsi_gi.nv_pck_scr / 90 * 1000;
p_sys->i_cell_cur_time = (vlc_tick_t) dvdtime_to_time( &p_sys->dsi_pack.dsi_gi.c_eltm, 0 );
/*
* If we're not at the end of this cell, we can determine the next
@ -1256,7 +1256,7 @@ static void DvdReadHandleDSI( demux_t *p_demux, uint8_t *p_data )
p_sys->i_next_vobu =
p_sys->p_cur_pgc->cell_playback[p_sys->i_cur_cell].first_sector;
p_sys->i_cell_duration = (mtime_t)dvdtime_to_time( &p_sys->p_cur_pgc->cell_playback[p_sys->i_cur_cell].playback_time, 0 );
p_sys->i_cell_duration = (vlc_tick_t)dvdtime_to_time( &p_sys->p_cur_pgc->cell_playback[p_sys->i_cur_cell].playback_time, 0 );
}
@ -1270,7 +1270,7 @@ static void DvdReadHandleDSI( demux_t *p_demux, uint8_t *p_data )
dvdtime_to_time( &p_sys->dsi_pack.dsi_gi.c_eltm, 0 ) );
msg_Dbg( p_demux, "cell duration: %lld",
(mtime_t)dvdtime_to_time( &p_sys->p_cur_pgc->cell_playback[p_sys->i_cur_cell].playback_time, 0 ) );
(vlc_tick_t)dvdtime_to_time( &p_sys->p_cur_pgc->cell_playback[p_sys->i_cur_cell].playback_time, 0 ) );
msg_Dbg( p_demux, "cat 0x%02x ilvu_ea %d ilvu_sa %d size %d",
p_sys->dsi_pack.sml_pbi.category,

18
modules/access/idummy.c

@ -62,14 +62,14 @@ static int DemuxHold( demux_t *demux )
typedef struct
{
mtime_t end;
mtime_t length;
vlc_tick_t end;
vlc_tick_t length;
} demux_sys_t;
static int DemuxPause( demux_t *demux )
{
demux_sys_t *p_sys = demux->p_sys;
mtime_t now = mdate();
vlc_tick_t now = mdate();
if( now >= p_sys->end )
return 0;
@ -88,7 +88,7 @@ static int ControlPause( demux_t *demux, int query, va_list args )
{
double *ppos = va_arg( args, double * );
double pos;
mtime_t now = mdate();
vlc_tick_t now = mdate();
pos = 1. + ((double)(now - p_sys->end) / (double)p_sys->length);
*ppos = (pos <= 1.) ? pos : 1.;
@ -98,7 +98,7 @@ static int ControlPause( demux_t *demux, int query, va_list args )
case DEMUX_SET_POSITION:
{
double pos = va_arg( args, double );
mtime_t now = mdate();
vlc_tick_t now = mdate();
p_sys->end = now + (p_sys->length * (1. - pos));
break;
@ -106,21 +106,21 @@ static int ControlPause( demux_t *demux, int query, va_list args )
case DEMUX_GET_LENGTH:
{
mtime_t *plen = va_arg( args, mtime_t * );
vlc_tick_t *plen = va_arg( args, vlc_tick_t * );
*plen = p_sys->length;
break;
}
case DEMUX_GET_TIME:
{
mtime_t *ppos = va_arg( args, mtime_t * );
vlc_tick_t *ppos = va_arg( args, vlc_tick_t * );
*ppos = mdate() + p_sys->length - p_sys->end;
break;
}
case DEMUX_SET_TIME:
{
mtime_t pos = va_arg( args, mtime_t );
vlc_tick_t pos = va_arg( args, vlc_tick_t );
p_sys->end = mdate() + p_sys->length - pos;
break;
}
@ -178,7 +178,7 @@ nop:
if( !strncasecmp( psz_name, "pause:", 6 ) )
{
double f = us_atof( psz_name + 6 );
mtime_t length = f * CLOCK_FREQ;
vlc_tick_t length = f * CLOCK_FREQ;
msg_Info( p_demux, "command `pause %f'", f );
if( length == 0 )

6
modules/access/imem.c

@ -217,9 +217,9 @@ typedef struct {
es_out_id_t *es;
mtime_t dts;
vlc_tick_t dts;
mtime_t deadline;
vlc_tick_t deadline;
} imem_sys_t;
static void ParseMRL(vlc_object_t *, const char *);
@ -549,7 +549,7 @@ static int ControlDemux(demux_t *demux, int i_query, va_list args)
return VLC_SUCCESS;
}
case DEMUX_SET_NEXT_DEMUX_TIME:
sys->deadline = va_arg(args, mtime_t);
sys->deadline = va_arg(args, vlc_tick_t);
return VLC_SUCCESS;
/* */

4
modules/access/linsys/linsys_hdsdi.c

@ -147,7 +147,7 @@ typedef struct
unsigned int i_frame_rate, i_frame_rate_base;
unsigned int i_width, i_height, i_aspect, i_forced_aspect;
unsigned int i_vblock_size, i_ablock_size;
mtime_t i_next_vdate, i_next_adate;
vlc_tick_t i_next_vdate, i_next_adate;
int i_incr, i_aincr;
/* ES stuff */
@ -631,7 +631,7 @@ static int HandleAudio( demux_t *p_demux, const uint8_t *p_buffer )
p_audio->i_channel * 2, p_sys->i_max_channel + 1 );
p_block->i_dts = p_block->i_pts
= p_sys->i_next_adate + (mtime_t)p_audio->i_delay
= p_sys->i_next_adate + (vlc_tick_t)p_audio->i_delay
* CLOCK_FREQ / p_sys->i_sample_rate;
p_block->i_length = p_sys->i_aincr;
es_out_Send( p_demux->out, p_audio->p_es, p_block );

6
modules/access/linsys/linsys_sdi.c

@ -157,7 +157,7 @@ typedef struct
/* SDI sync */
int i_state;
mtime_t i_last_state_change;
vlc_tick_t i_last_state_change;
unsigned int i_anc_size, i_active_size, i_picture_size;
unsigned int i_line_offset, i_nb_lines;
@ -178,7 +178,7 @@ typedef struct
char *psz_telx, *psz_telx_lang;
bool b_hd, b_vbi;
vbi_raw_decoder rd_wss, rd_telx;
mtime_t i_next_date;
vlc_tick_t i_next_date;
int i_incr;
/* ES stuff */
@ -931,7 +931,7 @@ static int DecodeAudio( demux_t *p_demux, sdi_audio_t *p_audio )
if( unlikely( !p_block ) )
return VLC_ENOMEM;
p_block->i_dts = p_block->i_pts = p_sys->i_next_date
+ (mtime_t)p_audio->i_delay * CLOCK_FREQ / p_audio->i_rate;
+ (vlc_tick_t)p_audio->i_delay * CLOCK_FREQ / p_audio->i_rate;
p_output = (int16_t *)p_block->p_buffer;
if ( p_audio->i_left_samples == p_audio->i_nb_samples &&

6
modules/access/live555.cpp

@ -215,7 +215,7 @@ struct demux_sys_t
bool b_real;
/* */
mtime_t i_pcr; /* The clock */
vlc_tick_t i_pcr; /* The clock */
bool b_rtcp_sync; /* At least one track received sync */
double f_npt;
double f_npt_length;
@ -1267,7 +1267,7 @@ static int Play( demux_t *p_demux )
timeout = 60; /* default value from RFC2326 */
msg_Dbg( p_demux, "We have a timeout of %d seconds", timeout );
mtime_t interval = (timeout - 2) * CLOCK_FREQ;
vlc_tick_t interval = (timeout - 2) * CLOCK_FREQ;
vlc_timer_schedule( p_sys->timer, false, interval, interval);
}
p_sys->i_pcr = VLC_TS_INVALID;
@ -1419,7 +1419,7 @@ static int Demux( demux_t *p_demux )
if( b_send_pcr )
{
mtime_t i_minpcr = VLC_TS_INVALID;
vlc_tick_t i_minpcr = VLC_TS_INVALID;
bool b_need_flush = false;
/* Check for gap in pts value */

6
modules/access/oss.c

@ -121,7 +121,7 @@ typedef struct
block_t *p_block;
es_out_id_t *p_es;
mtime_t i_next_demux_date; /* Used to handle oss:// as input-slave properly */
vlc_tick_t i_next_demux_date; /* Used to handle oss:// as input-slave properly */
} demux_sys_t;
static int FindMainDevice( demux_t *p_demux )
@ -228,7 +228,7 @@ static int DemuxControl( demux_t *p_demux, int i_query, va_list args )
return VLC_SUCCESS;
case DEMUX_SET_NEXT_DEMUX_TIME:
p_sys->i_next_demux_date = va_arg( args, mtime_t );
p_sys->i_next_demux_date = va_arg( args, vlc_tick_t );
return VLC_SUCCESS;
/* TODO implement others */
@ -320,7 +320,7 @@ static block_t* GrabAudio( demux_t *p_demux )
/* Timestamp */
p_block->i_pts = p_block->i_dts =
mdate() - CLOCK_FREQ * (mtime_t)i_correct /
mdate() - CLOCK_FREQ * (vlc_tick_t)i_correct /
2 / ( p_sys->b_stereo ? 2 : 1) / p_sys->i_sample_rate;
return p_block;

4
modules/access/pulse.c

@ -59,7 +59,7 @@ typedef struct
es_out_id_t *es;
bool discontinuity; /**< The next block will not follow the last one */
unsigned framesize; /**< Byte size of a sample */
mtime_t caching; /**< Caching value */
vlc_tick_t caching; /**< Caching value */
} demux_sys_t;
/* Stream helpers */
@ -161,7 +161,7 @@ static void stream_read_cb(pa_stream *s, size_t length, void *userdata)
return;
}
mtime_t pts = mdate();
vlc_tick_t pts = mdate();
pa_usec_t latency;
int negative;

10
modules/access/qtsound.m

@ -76,14 +76,14 @@ vlc_module_end ()
void *rawAudioData;
UInt32 numberOfSamples;
date_t date;
mtime_t currentPts;
mtime_t previousPts;
vlc_tick_t currentPts;
vlc_tick_t previousPts;
}
- (id)initWithDemux:(demux_t *)p_demux;
- (void)outputAudioSampleBuffer:(QTSampleBuffer *)sampleBuffer fromConnection:(QTCaptureConnection *)connection;
- (BOOL)checkCurrentAudioBuffer;
- (void)freeAudioMem;
- (mtime_t)getCurrentPts;
- (vlc_tick_t)getCurrentPts;
- (void *)getCurrentAudioBufferData;
- (UInt32)getCurrentTotalDataSize;
- (UInt32)getNumberOfSamples;
@ -184,10 +184,10 @@ vlc_module_end ()
FREENULL(rawAudioData);
}
- (mtime_t)getCurrentPts
- (vlc_tick_t)getCurrentPts
{
/* FIXME: can this getter be minimized? */
mtime_t pts;
vlc_tick_t pts;
if(!currentAudioBuffer || currentPts == previousPts)
return 0;

4
modules/access/rdp.c

@ -112,7 +112,7 @@ typedef struct
float f_fps;
int i_frame_interval;
mtime_t i_starttime;
vlc_tick_t i_starttime;
es_out_id_t *es;
@ -340,7 +340,7 @@ static void *DemuxThread( void *p_data )
demux_t *p_demux = (demux_t *) p_data;
demux_sys_t *p_sys = p_demux->p_sys;
p_sys->i_starttime = mdate();
mtime_t i_next_frame_date = mdate() + p_sys->i_frame_interval;
vlc_tick_t i_next_frame_date = mdate() + p_sys->i_frame_interval;
int i_ret;
for(;;)

6
modules/access/rtp/input.c

@ -85,12 +85,12 @@ drop:
block_Release (block);
}
static int rtp_timeout (mtime_t deadline)
static int rtp_timeout (vlc_tick_t deadline)
{
if (deadline == VLC_TS_INVALID)
return -1; /* infinite */
mtime_t t = mdate ();
vlc_tick_t t = mdate ();
if (t >= deadline)
return 0;
@ -107,7 +107,7 @@ void *rtp_dgram_thread (void *opaque)
{
demux_t *demux = opaque;
demux_sys_t *sys = demux->p_sys;
mtime_t deadline = VLC_TS_INVALID;
vlc_tick_t deadline = VLC_TS_INVALID;
int rtp_fd = sys->fd;
struct iovec iov =
{

4
modules/access/rtp/rtp.h

@ -54,7 +54,7 @@ void xiph_decode (demux_t *demux, void *data, block_t *block);
rtp_session_t *rtp_session_create (demux_t *);
void rtp_session_destroy (demux_t *, rtp_session_t *);
void rtp_queue (demux_t *, rtp_session_t *, block_t *);
bool rtp_dequeue (demux_t *, const rtp_session_t *, mtime_t *);
bool rtp_dequeue (demux_t *, const rtp_session_t *, vlc_tick_t *);
void rtp_dequeue_force (demux_t *, const rtp_session_t *);
int rtp_add_type (demux_t *demux, rtp_session_t *ses, const rtp_pt_t *pt);
@ -73,7 +73,7 @@ typedef struct
int rtcp_fd;
vlc_thread_t thread;
mtime_t timeout;
vlc_tick_t timeout;
uint16_t max_dropout; /**< Max packet forward misordering */
uint16_t max_misorder; /**< Max packet backward misordering */
uint8_t max_src; /**< Max simultaneous RTP sources */

12
modules/access/rtp/session.c

@ -139,11 +139,11 @@ struct rtp_source_t
{
uint32_t ssrc;
uint32_t jitter; /* interarrival delay jitter estimate */
mtime_t last_rx; /* last received packet local timestamp */
vlc_tick_t last_rx; /* last received packet local timestamp */
uint32_t last_ts; /* last received packet RTP timestamp */
uint32_t ref_rtp; /* sender RTP timestamp reference */
mtime_t ref_ntp; /* sender NTP timestamp reference */
vlc_tick_t ref_ntp; /* sender NTP timestamp reference */
uint16_t bad_seq; /* tentatively next expected sequence for resync */
uint16_t max_seq; /* next expected sequence */
@ -256,7 +256,7 @@ rtp_queue (demux_t *demux, rtp_session_t *session, block_t *block)
block->i_buffer -= padding;
}
mtime_t now = mdate ();
vlc_tick_t now = mdate ();
rtp_source_t *src = NULL;
const uint16_t seq = rtp_seq (block);
const uint32_t ssrc = GetDWBE (block->p_buffer + 8);
@ -391,9 +391,9 @@ static void rtp_decode (demux_t *, const rtp_session_t *, rtp_source_t *);
* In the later case, *deadlinep is undefined.
*/
bool rtp_dequeue (demux_t *demux, const rtp_session_t *session,
mtime_t *restrict deadlinep)
vlc_tick_t *restrict deadlinep)
{
mtime_t now = mdate ();
vlc_tick_t now = mdate ();
bool pending = false;
*deadlinep = INT64_MAX;
@ -430,7 +430,7 @@ bool rtp_dequeue (demux_t *demux, const rtp_session_t *session,
/* Wait for 3 times the inter-arrival delay variance (about 99.7%
* match for random gaussian jitter).
*/
mtime_t deadline;
vlc_tick_t deadline;
const rtp_pt_t *pt = rtp_find_ptype (session, src, block, NULL);
if (pt)
deadline = CLOCK_FREQ * 3 * src->jitter / pt->frequency;

4
modules/access/satip.c

@ -425,9 +425,9 @@ static void *satip_thread(void *data) {
stream_t *access = data;
access_sys_t *sys = access->p_sys;
int sock = sys->udp_sock;
mtime_t last_recv = mdate();
vlc_tick_t last_recv = mdate();
ssize_t len;
mtime_t next_keepalive = mdate() + sys->keepalive_interval * 1000 * 1000;
vlc_tick_t next_keepalive = mdate() + sys->keepalive_interval * 1000 * 1000;
#ifdef HAVE_RECVMMSG
struct mmsghdr msgs[VLEN];
struct iovec iovecs[VLEN];

4
modules/access/screen/screen.h

@ -45,10 +45,10 @@ typedef struct
es_out_id_t *es;
float f_fps;
mtime_t i_next_date;
vlc_tick_t i_next_date;
int i_incr;
mtime_t i_start;
vlc_tick_t i_start;
#ifdef SCREEN_SUBSCREEN
bool b_follow_mouse;

2
modules/access/screen/wayland.c

@ -59,7 +59,7 @@ typedef struct
int32_t height; /*< Actual height */
bool done;
mtime_t start;
vlc_tick_t start;
vlc_thread_t thread;
} demux_sys_t;

2
modules/access/screen/xcb.c

@ -237,7 +237,7 @@ static int Open (vlc_object_t *obj)
if (!p_sys->rate)
goto error;
mtime_t interval = (float)CLOCK_FREQ / p_sys->rate;
vlc_tick_t interval = (float)CLOCK_FREQ / p_sys->rate;
if (!interval)
goto error;

2
modules/access/shm.c

@ -226,7 +226,7 @@ static int Open (vlc_object_t *obj)
if (rate <= 0.f)
goto error;
mtime_t interval = llroundf((float)CLOCK_FREQ / rate);
vlc_tick_t interval = llroundf((float)CLOCK_FREQ / rate);
if (!interval)
goto error;

6
modules/access/timecode.c

@ -55,13 +55,13 @@ typedef struct
{
es_out_id_t *es;
date_t date;
mtime_t next_time;
vlc_tick_t next_time;
} demux_sys_t;
static int DemuxOnce (demux_t *demux, bool master)
{
demux_sys_t *sys = demux->p_sys;
mtime_t pts = date_Get (&sys->date);
vlc_tick_t pts = date_Get (&sys->date);
lldiv_t d;
unsigned h, m, s, f;
@ -134,7 +134,7 @@ static int Control (demux_t *demux, int query, va_list args)
case DEMUX_SET_NEXT_DEMUX_TIME:
{
const mtime_t pts = va_arg (args, mtime_t );
const vlc_tick_t pts = va_arg (args, vlc_tick_t );
if (sys->next_time == VLC_TS_INVALID) /* first invocation? */
{

2
modules/access/v4l2/demux.c

@ -57,7 +57,7 @@ typedef struct
es_out_id_t *es;
vlc_v4l2_ctrl_t *controls;
mtime_t start;
vlc_tick_t start;
#ifdef ZVBI_COMPILED
vlc_v4l2_vbi_t *vbi;

2
modules/access/v4l2/radio.c

@ -34,7 +34,7 @@ typedef struct
{
int fd;
vlc_v4l2_ctrl_t *controls;
mtime_t start;
vlc_tick_t start;
} demux_sys_t;
static int RadioControl (demux_t *demux, int query, va_list args)

2
modules/access/v4l2/v4l2.h

@ -55,7 +55,7 @@ int StartUserPtr (vlc_object_t *, int);
struct buffer_t *StartMmap (vlc_object_t *, int, uint32_t *);
void StopMmap (int, struct buffer_t *, uint32_t);
mtime_t GetBufferPTS (const struct v4l2_buffer *);
vlc_tick_t GetBufferPTS (const struct v4l2_buffer *);
block_t* GrabVideo (vlc_object_t *, int, const struct buffer_t *);
#ifdef ZVBI_COMPILED

4
modules/access/v4l2/video.c

@ -560,9 +560,9 @@ int SetupFormat (vlc_object_t *obj, int fd, uint32_t fourcc,
return 0;
}
mtime_t GetBufferPTS (const struct v4l2_buffer *buf)
vlc_tick_t GetBufferPTS (const struct v4l2_buffer *buf)
{
mtime_t pts;
vlc_tick_t pts;
switch (buf->flags & V4L2_BUF_FLAG_TIMESTAMP_MASK)
{

4
modules/access/vnc.c

@ -122,7 +122,7 @@ typedef struct
float f_fps;
int i_frame_interval;
mtime_t i_starttime;
vlc_tick_t i_starttime;
es_out_id_t *es;
} demux_sys_t;
@ -337,7 +337,7 @@ static void *DemuxThread( void *p_data )
{
demux_t *p_demux = (demux_t *) p_data;
demux_sys_t *p_sys = p_demux->p_sys;
mtime_t i_next_frame_date = mdate() + p_sys->i_frame_interval;
vlc_tick_t i_next_frame_date = mdate() + p_sys->i_frame_interval;
int i_status;
for(;;)

8
modules/access/wasapi.c

@ -223,7 +223,7 @@ static int vlc_FromWave(const WAVEFORMATEX *restrict wf,
}
static es_out_id_t *CreateES(demux_t *demux, IAudioClient *client, bool loop,
mtime_t caching, size_t *restrict frame_size)
vlc_tick_t caching, size_t *restrict frame_size)
{
es_format_t fmt;
WAVEFORMATEX *pwf;
@ -273,8 +273,8 @@ typedef struct
es_out_id_t *es;
size_t frame_size;
mtime_t caching;
mtime_t start_time;
vlc_tick_t caching;
vlc_tick_t start_time;
HANDLE events[2];
union {
@ -318,7 +318,7 @@ static unsigned __stdcall Thread(void *data)
UINT32 frames;
DWORD flags;
UINT64 qpc;
mtime_t pts;
vlc_tick_t pts;
hr = IAudioCaptureClient_GetBuffer(capture, &data, &frames, &flags,
NULL, &qpc);

10
modules/access_output/livehttp.c

@ -179,10 +179,10 @@ typedef struct
char *psz_indexPath;
char *psz_indexUrl;
char *psz_keyfile;
mtime_t i_keyfile_modification;
mtime_t i_opendts;
mtime_t i_dts_offset;
mtime_t i_seglenm;
vlc_tick_t i_keyfile_modification;
vlc_tick_t i_opendts;
vlc_tick_t i_dts_offset;
vlc_tick_t i_seglenm;
uint32_t i_segment;
size_t i_seglen;
float f_seglen;
@ -947,7 +947,7 @@ static ssize_t writeSegment( sout_access_out_t *p_access )
msg_Dbg( p_access, "Writing all full segments" );
block_t *output = p_sys->full_segments;
mtime_t output_last_length = 0;
vlc_tick_t output_last_length = 0;
if( output )
output_last_length = output->i_length;
if( *p_sys->full_segments_end )

12
modules/access_output/udp.c

@ -107,11 +107,11 @@ static ssize_t Write ( sout_access_out_t *, block_t * );
static int Control( sout_access_out_t *, int, va_list );
static void* ThreadWrite( void * );
static block_t *NewUDPPacket( sout_access_out_t *, mtime_t );
static block_t *NewUDPPacket( sout_access_out_t *, vlc_tick_t );
typedef struct
{
mtime_t i_caching;
vlc_tick_t i_caching;
int i_handle;
bool b_mtu_warning;
size_t i_mtu;
@ -277,7 +277,7 @@ static ssize_t Write( sout_access_out_t *p_access, block_t *p_buffer )
{
block_t *p_next;
int i_packets = 0;
mtime_t now = mdate();
vlc_tick_t now = mdate();
if( !p_sys->b_mtu_warning && p_buffer->i_buffer > p_sys->i_mtu )
{
@ -352,7 +352,7 @@ static ssize_t Write( sout_access_out_t *p_access, block_t *p_buffer )
/*****************************************************************************
* NewUDPPacket: allocate a new UDP packet of size p_sys->i_mtu
*****************************************************************************/
static block_t *NewUDPPacket( sout_access_out_t *p_access, mtime_t i_dts)
static block_t *NewUDPPacket( sout_access_out_t *p_access, vlc_tick_t i_dts)
{
sout_access_out_sys_t *p_sys = p_access->p_sys;
block_t *p_buffer;
@ -387,7 +387,7 @@ static void* ThreadWrite( void *data )
{
sout_access_out_t *p_access = data;
sout_access_out_sys_t *p_sys = p_access->p_sys;
mtime_t i_date_last = -1;
vlc_tick_t i_date_last = -1;
const unsigned i_group = var_GetInteger( p_access,
SOUT_CFG_PREFIX "group" );
int i_to_send = i_group;
@ -396,7 +396,7 @@ static void* ThreadWrite( void *data )
for (;;)
{
block_t *p_pk = block_FifoGet( p_sys->p_fifo );
mtime_t i_date, i_sent;
vlc_tick_t i_date, i_sent;
i_date = p_sys->i_caching + p_pk->i_dts;
if( i_date_last > 0 )

4
modules/audio_filter/audiobargraph_a.c

@ -88,7 +88,7 @@ vlc_module_end ()
typedef struct ValueDate_t {
float value;
mtime_t date;
vlc_tick_t date;
struct ValueDate_t* next;
} ValueDate_t;
@ -104,7 +104,7 @@ typedef struct
ValueDate_t* first;
ValueDate_t* last;
int started;
mtime_t lastAlarm;
vlc_tick_t lastAlarm;
} filter_sys_t;
/*****************************************************************************

6
modules/audio_filter/channel_mixer/spatialaudio.cpp

@ -122,8 +122,8 @@ struct filter_spatialaudio
CAmbisonicSpeaker *speakers;
std::vector<float> inputSamples;
mtime_t i_inputPTS;
mtime_t i_last_input_pts;
vlc_tick_t i_inputPTS;
vlc_tick_t i_last_input_pts;
unsigned i_order;
unsigned i_nondiegetic;
unsigned i_lr_channels; // number of physical left/right channel pairs
@ -169,7 +169,7 @@ static block_t *Mix( filter_t *p_filter, block_t *p_buf )
filter_spatialaudio *p_sys = reinterpret_cast<filter_spatialaudio *>(p_filter->p_sys);
/* Detect discontinuity due to a pause */
static const mtime_t rounding_error = 10;
static const vlc_tick_t rounding_error = 10;
if( p_sys->i_inputPTS != 0
&& p_buf->i_pts - p_sys->i_last_input_pts > rounding_error )
Flush( p_filter );

4
modules/audio_filter/resampler/soxr.c

@ -87,7 +87,7 @@ typedef struct
soxr_t last_soxr;
double f_fixed_ratio;
size_t i_last_olen;
mtime_t i_last_pts;
vlc_tick_t i_last_pts;
} filter_sys_t;
static block_t *Resample( filter_t *, block_t * );
@ -290,7 +290,7 @@ static block_t *
Resample( filter_t *p_filter, block_t *p_in )
{
filter_sys_t *p_sys = p_filter->p_sys;
const mtime_t i_pts = p_in->i_pts;
const vlc_tick_t i_pts = p_in->i_pts;
if( p_sys->vr_soxr )
{

4
modules/audio_output/adummy.c

@ -42,13 +42,13 @@ vlc_module_end ()
#define A52_FRAME_NB 1536
static void Play(audio_output_t *aout, block_t *block, mtime_t date)
static void Play(audio_output_t *aout, block_t *block, vlc_tick_t date)
{
block_Release( block );
(void) aout; (void) date;
}
static void Pause(audio_output_t *aout, bool paused, mtime_t date)
static void Pause(audio_output_t *aout, bool paused, vlc_tick_t date)
{
(void) aout; (void) paused; (void) date;
}

16
modules/audio_output/alsa.c

@ -290,10 +290,10 @@ out:
# define SetupChannels(obj, pcm, mask, tab) (0)
#endif
static int TimeGet (audio_output_t *aout, mtime_t *);
static void Play(audio_output_t *, block_t *, mtime_t);
static void Pause (audio_output_t *, bool, mtime_t);
static void PauseDummy (audio_output_t *, bool, mtime_t);
static int TimeGet (audio_output_t *aout, vlc_tick_t *);
static void Play(audio_output_t *, block_t *, vlc_tick_t);
static void Pause (audio_output_t *, bool, vlc_tick_t);
static void PauseDummy (audio_output_t *, bool, vlc_tick_t);
static void Flush (audio_output_t *, bool);
/** Initializes an ALSA playback stream */
@ -629,7 +629,7 @@ error:
return VLC_EGENERIC;
}
static int TimeGet (audio_output_t *aout, mtime_t *restrict delay)
static int TimeGet (audio_output_t *aout, vlc_tick_t *restrict delay)
{
aout_sys_t *sys = aout->sys;
snd_pcm_sframes_t frames;
@ -647,7 +647,7 @@ static int TimeGet (audio_output_t *aout, mtime_t *restrict delay)
/**
* Queues one audio buffer to the hardware.
*/
static void Play(audio_output_t *aout, block_t *block, mtime_t date)
static void Play(audio_output_t *aout, block_t *block, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
@ -693,7 +693,7 @@ static void Play(audio_output_t *aout, block_t *block, mtime_t date)
/**
* Pauses/resumes the audio playback.
*/
static void Pause (audio_output_t *aout, bool pause, mtime_t date)
static void Pause (audio_output_t *aout, bool pause, vlc_tick_t date)
{
aout_sys_t *p_sys = aout->sys;
snd_pcm_t *pcm = p_sys->pcm;
@ -703,7 +703,7 @@ static void Pause (audio_output_t *aout, bool pause, mtime_t date)
PauseDummy (aout, pause, date);
}
static void PauseDummy (audio_output_t *aout, bool pause, mtime_t date)
static void PauseDummy (audio_output_t *aout, bool pause, vlc_tick_t date)
{
aout_sys_t *p_sys = aout->sys;
snd_pcm_t *pcm = p_sys->pcm;

4
modules/audio_output/amem.c

@ -81,7 +81,7 @@ typedef struct
vlc_mutex_t lock;
} aout_sys_t;
static void Play(audio_output_t *aout, block_t *block, mtime_t date)
static void Play(audio_output_t *aout, block_t *block, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
@ -91,7 +91,7 @@ static void Play(audio_output_t *aout, block_t *block, mtime_t date)
block_Release (block);
}
static void Pause (audio_output_t *aout, bool paused, mtime_t date)
static void Pause (audio_output_t *aout, bool paused, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
void (*cb) (void *, int64_t) = paused ? sys->pause : sys->resume;

42
modules/audio_output/audiotrack.c

@ -109,18 +109,18 @@ typedef struct
jobject p_obj; /* AudioTimestamp ref */
jlong i_frame_us;
jlong i_frame_pos;
mtime_t i_play_time; /* time when play was called */
mtime_t i_last_time;
vlc_tick_t i_play_time; /* time when play was called */
vlc_tick_t i_last_time;
} timestamp;
/* Used by AudioTrack_GetSmoothPositionUs */
struct {
uint32_t i_idx;
uint32_t i_count;
mtime_t p_us[SMOOTHPOS_SAMPLE_COUNT];
mtime_t i_us;
mtime_t i_last_time;
mtime_t i_latency_us;
vlc_tick_t p_us[SMOOTHPOS_SAMPLE_COUNT];
vlc_tick_t i_us;
vlc_tick_t i_last_time;
vlc_tick_t i_latency_us;
} smoothpos;
uint32_t i_max_audiotrack_samples;
@ -499,7 +499,7 @@ check_exception( JNIEnv *env, audio_output_t *p_aout,
#define JNI_AUDIOTIMESTAMP_GET_LONG( field ) JNI_CALL( GetLongField, p_sys->timestamp.p_obj, jfields.AudioTimestamp.field )
static inline mtime_t
static inline vlc_tick_t
frames_to_us( aout_sys_t *p_sys, uint64_t i_nb_frames )
{
return i_nb_frames * CLOCK_FREQ / p_sys->fmt.i_rate;
@ -608,12 +608,12 @@ AudioTrack_Reset( JNIEnv *env, audio_output_t *p_aout )
* This function smooth out the AudioTrack position since it has a very bad
* precision (+/- 20ms on old devices).
*/
static mtime_t
static vlc_tick_t
AudioTrack_GetSmoothPositionUs( JNIEnv *env, audio_output_t *p_aout )
{
aout_sys_t *p_sys = p_aout->sys;
uint64_t i_audiotrack_us;
mtime_t i_now = mdate();
vlc_tick_t i_now = mdate();
/* Fetch an AudioTrack position every SMOOTHPOS_INTERVAL_US (30ms) */
if( i_now - p_sys->smoothpos.i_last_time >= SMOOTHPOS_INTERVAL_US )
@ -652,11 +652,11 @@ AudioTrack_GetSmoothPositionUs( JNIEnv *env, audio_output_t *p_aout )
return 0;
}
static mtime_t
static vlc_tick_t
AudioTrack_GetTimestampPositionUs( JNIEnv *env, audio_output_t *p_aout )
{
aout_sys_t *p_sys = p_aout->sys;
mtime_t i_now;
vlc_tick_t i_now;
if( !p_sys->timestamp.p_obj )
return 0;
@ -712,10 +712,10 @@ AudioTrack_GetTimestampPositionUs( JNIEnv *env, audio_output_t *p_aout )
}
static int
TimeGet( audio_output_t *p_aout, mtime_t *restrict p_delay )
TimeGet( audio_output_t *p_aout, vlc_tick_t *restrict p_delay )
{
aout_sys_t *p_sys = p_aout->sys;
mtime_t i_audiotrack_us;
vlc_tick_t i_audiotrack_us;
JNIEnv *env;
if( p_sys->b_passthrough )
@ -734,9 +734,9 @@ TimeGet( audio_output_t *p_aout, mtime_t *restrict p_delay )
/* Debug log for both delays */
#if 0
{
mtime_t i_written_us = FRAMES_TO_US( p_sys->i_samples_written );
mtime_t i_ts_us = AudioTrack_GetTimestampPositionUs( env, p_aout );
mtime_t i_smooth_us = 0;
vlc_tick_t i_written_us = FRAMES_TO_US( p_sys->i_samples_written );
vlc_tick_t i_ts_us = AudioTrack_GetTimestampPositionUs( env, p_aout );
vlc_tick_t i_smooth_us = 0;
if( i_ts_us > 0 )
i_smooth_us = AudioTrack_GetSmoothPositionUs(env, p_aout );
@ -754,7 +754,7 @@ TimeGet( audio_output_t *p_aout, mtime_t *restrict p_delay )
if( i_audiotrack_us > 0 )
{
/* AudioTrack delay */
mtime_t i_delay = FRAMES_TO_US( p_sys->i_samples_written )
vlc_tick_t i_delay = FRAMES_TO_US( p_sys->i_samples_written )
- i_audiotrack_us;
if( i_delay >= 0 )
{
@ -1631,8 +1631,8 @@ AudioTrack_Thread( void *p_data )
audio_output_t *p_aout = p_data;
aout_sys_t *p_sys = p_aout->sys;
JNIEnv *env = GET_ENV();
mtime_t i_play_deadline = 0;
mtime_t i_last_time_blocked = 0;
vlc_tick_t i_play_deadline = 0;
vlc_tick_t i_last_time_blocked = 0;
if( !env )
return NULL;
@ -1727,7 +1727,7 @@ AudioTrack_Thread( void *p_data )
}
static void
Play( audio_output_t *p_aout, block_t *p_buffer, mtime_t i_date )
Play( audio_output_t *p_aout, block_t *p_buffer, vlc_tick_t i_date )
{
JNIEnv *env = NULL;
size_t i_buffer_offset = 0;
@ -1807,7 +1807,7 @@ bailout:
}
static void
Pause( audio_output_t *p_aout, bool b_pause, mtime_t i_date )
Pause( audio_output_t *p_aout, bool b_pause, vlc_tick_t i_date )
{
aout_sys_t *p_sys = p_aout->sys;
JNIEnv *env;

4
modules/audio_output/audiounit_ios.m

@ -364,7 +364,7 @@ avas_SetActive(audio_output_t *p_aout, bool active, NSUInteger options)
#pragma mark actual playback
static void
Pause (audio_output_t *p_aout, bool pause, mtime_t date)
Pause (audio_output_t *p_aout, bool pause, vlc_tick_t date)
{
aout_sys_t * p_sys = p_aout->sys;
@ -429,7 +429,7 @@ MuteSet(audio_output_t *p_aout, bool mute)
}
static void
Play(audio_output_t * p_aout, block_t * p_block, mtime_t date)
Play(audio_output_t * p_aout, block_t * p_block, vlc_tick_t date)
{
aout_sys_t * p_sys = p_aout->sys;

8
modules/audio_output/auhal.c

@ -842,7 +842,7 @@ AudioStreamChangeFormat(audio_output_t *p_aout, AudioStreamID i_stream_id,
* set. */
if (i > 0)
{
mtime_t timeout = mdate() + CLOCK_FREQ/2;
vlc_tick_t timeout = mdate() + CLOCK_FREQ/2;
if (vlc_cond_timedwait(&w.cond, &w.lock, timeout))
msg_Dbg(p_aout, "reached timeout");
}
@ -1064,7 +1064,7 @@ WarnConfiguration(audio_output_t *p_aout)
*/
static int
StartAnalog(audio_output_t *p_aout, audio_sample_format_t *fmt,
mtime_t i_latency_us)
vlc_tick_t i_latency_us)
{
aout_sys_t *p_sys = p_aout->sys;
OSStatus err = noErr;
@ -1152,7 +1152,7 @@ error:
*/
static int
StartSPDIF(audio_output_t * p_aout, audio_sample_format_t *fmt,
mtime_t i_latency_us)
vlc_tick_t i_latency_us)
{
aout_sys_t *p_sys = p_aout->sys;
int ret;
@ -1609,7 +1609,7 @@ Start(audio_output_t *p_aout, audio_sample_format_t *restrict fmt)
UInt32 i_latency_samples;
AO_GET1PROP(p_sys->i_selected_dev, UInt32, &i_latency_samples,
kAudioDevicePropertyLatency, kAudioObjectPropertyScopeOutput);
mtime_t i_latency_us = i_latency_samples * CLOCK_FREQ / fmt->i_rate;
vlc_tick_t i_latency_us = i_latency_samples * CLOCK_FREQ / fmt->i_rate;
/* Check for Digital mode or Analog output mode */
if (do_spdif)

18
modules/audio_output/coreaudio_common.c

@ -42,7 +42,7 @@ BytesToFrames(struct aout_sys_common *p_sys, size_t i_bytes)
return i_bytes * p_sys->i_frame_length / p_sys->i_bytes_per_frame;
}
static inline mtime_t
static inline vlc_tick_t
FramesToUs(struct aout_sys_common *p_sys, uint64_t i_nb_frames)
{
return i_nb_frames * CLOCK_FREQ / p_sys->i_rate;
@ -202,7 +202,7 @@ drop:
}
int
ca_TimeGet(audio_output_t *p_aout, mtime_t *delay)
ca_TimeGet(audio_output_t *p_aout, vlc_tick_t *delay)
{
struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
@ -211,7 +211,7 @@ ca_TimeGet(audio_output_t *p_aout, mtime_t *delay)
lock_lock(p_sys);
mtime_t i_render_delay;
vlc_tick_t i_render_delay;
if (likely(p_sys->i_render_host_time != 0))
{
const uint64_t i_render_time_us = p_sys->i_render_host_time
@ -247,7 +247,7 @@ ca_Flush(audio_output_t *p_aout, bool wait)
/* Calculate the duration of the circular buffer, in order to wait
* for the render thread to play it all */
const mtime_t i_frame_us =
const vlc_tick_t i_frame_us =
FramesToUs(p_sys, BytesToFrames(p_sys, p_sys->i_out_size)) + 10000;
lock_unlock(p_sys);
msleep(i_frame_us);
@ -274,7 +274,7 @@ ca_Flush(audio_output_t *p_aout, bool wait)
}
void
ca_Pause(audio_output_t * p_aout, bool pause, mtime_t date)
ca_Pause(audio_output_t * p_aout, bool pause, vlc_tick_t date)
{
struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
VLC_UNUSED(date);
@ -285,7 +285,7 @@ ca_Pause(audio_output_t * p_aout, bool pause, mtime_t date)
}
void
ca_Play(audio_output_t * p_aout, block_t * p_block, mtime_t date)
ca_Play(audio_output_t * p_aout, block_t * p_block, vlc_tick_t date)
{
struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
@ -331,7 +331,7 @@ ca_Play(audio_output_t * p_aout, block_t * p_block, mtime_t date)
return;
}
const mtime_t i_frame_us =
const vlc_tick_t i_frame_us =
FramesToUs(p_sys, BytesToFrames(p_sys, p_block->i_buffer));
/* Wait for the render buffer to play the remaining data */
@ -360,7 +360,7 @@ ca_Play(audio_output_t * p_aout, block_t * p_block, mtime_t date)
int
ca_Initialize(audio_output_t *p_aout, const audio_sample_format_t *fmt,
mtime_t i_dev_latency_us)
vlc_tick_t i_dev_latency_us)
{
struct aout_sys_common *p_sys = (struct aout_sys_common *) p_aout->sys;
@ -808,7 +808,7 @@ SetupInputLayout(audio_output_t *p_aout, const audio_sample_format_t *fmt,
int
au_Initialize(audio_output_t *p_aout, AudioUnit au, audio_sample_format_t *fmt,
const AudioChannelLayout *outlayout, mtime_t i_dev_latency_us,
const AudioChannelLayout *outlayout, vlc_tick_t i_dev_latency_us,
bool *warn_configuration)
{
int ret;

12
modules/audio_output/coreaudio_common.h

@ -77,7 +77,7 @@ struct aout_sys_common
uint8_t chans_to_reorder;
uint8_t chan_table[AOUT_CHAN_MAX];
/* ca_TimeGet extra latency, in micro-seconds */
mtime_t i_dev_latency_us;
vlc_tick_t i_dev_latency_us;
};
void ca_Open(audio_output_t *p_aout);
@ -87,16 +87,16 @@ void ca_Close(audio_output_t *p_aout);
void ca_Render(audio_output_t *p_aout, uint32_t i_nb_samples, uint64_t i_host_time,
uint8_t *p_output, size_t i_requested);
int ca_TimeGet(audio_output_t *p_aout, mtime_t *delay);
int ca_TimeGet(audio_output_t *p_aout, vlc_tick_t *delay);
void ca_Flush(audio_output_t *p_aout, bool wait);
void ca_Pause(audio_output_t * p_aout, bool pause, mtime_t date);
void ca_Pause(audio_output_t * p_aout, bool pause, vlc_tick_t date);
void ca_Play(audio_output_t * p_aout, block_t * p_block, mtime_t date);
void ca_Play(audio_output_t * p_aout, block_t * p_block, vlc_tick_t date);
int ca_Initialize(audio_output_t *p_aout, const audio_sample_format_t *fmt,
mtime_t i_dev_latency_us);
vlc_tick_t i_dev_latency_us);
void ca_Uninitialize(audio_output_t *p_aout);
@ -106,7 +106,7 @@ AudioUnit au_NewOutputInstance(audio_output_t *p_aout, OSType comp_sub_type);
int au_Initialize(audio_output_t *p_aout, AudioUnit au,
audio_sample_format_t *fmt,
const AudioChannelLayout *outlayout, mtime_t i_dev_latency_us,
const AudioChannelLayout *outlayout, vlc_tick_t i_dev_latency_us,
bool *warn_configuration);
void au_Uninitialize(audio_output_t *p_aout, AudioUnit au);

10
modules/audio_output/directsound.c

@ -139,7 +139,7 @@ typedef struct
} aout_sys_t;
static HRESULT Flush( aout_stream_sys_t *sys, bool drain);
static HRESULT TimeGet( aout_stream_sys_t *sys, mtime_t *delay )
static HRESULT TimeGet( aout_stream_sys_t *sys, vlc_tick_t *delay )
{
DWORD read, status;
HRESULT hr;
@ -176,12 +176,12 @@ static HRESULT TimeGet( aout_stream_sys_t *sys, mtime_t *delay )
return DS_OK;
}
static HRESULT StreamTimeGet( aout_stream_t *s, mtime_t *delay )
static HRESULT StreamTimeGet( aout_stream_t *s, vlc_tick_t *delay )
{
return TimeGet( s->sys, delay );
}
static int OutputTimeGet( audio_output_t *aout, mtime_t *delay )
static int OutputTimeGet( audio_output_t *aout, vlc_tick_t *delay )
{
aout_sys_t *sys = aout->sys;
return (TimeGet( &sys->s, delay ) == DS_OK) ? 0 : -1;
@ -303,7 +303,7 @@ static HRESULT StreamPlay( aout_stream_t *s, block_t *block )
return Play( VLC_OBJECT(s), s->sys, block );
}
static void OutputPlay( audio_output_t *aout, block_t *block, mtime_t date )
static void OutputPlay( audio_output_t *aout, block_t *block, vlc_tick_t date )
{
aout_sys_t *sys = aout->sys;
Play( VLC_OBJECT(aout), &sys->s, block );
@ -334,7 +334,7 @@ static HRESULT StreamPause( aout_stream_t *s, bool pause )
return Pause( s->sys, pause );
}
static void OutputPause( audio_output_t *aout, bool pause, mtime_t date )
static void OutputPause( audio_output_t *aout, bool pause, vlc_tick_t date )
{
aout_sys_t *sys = aout->sys;
Pause( &sys->s, pause );

8
modules/audio_output/file.c

@ -74,8 +74,8 @@ static const int pi_channels_maps[CHANNELS_MAX+1] =
* Local prototypes.
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Play ( audio_output_t *, block_t *, mtime_t );
static void Pause ( audio_output_t *, bool, mtime_t );
static void Play ( audio_output_t *, block_t *, vlc_tick_t );
static void Pause ( audio_output_t *, bool, vlc_tick_t );
static void Flush ( audio_output_t *, bool );
/*****************************************************************************
@ -316,7 +316,7 @@ static void Stop( audio_output_t *p_aout )
/*****************************************************************************
* Play: pretend to play a sound
*****************************************************************************/
static void Play( audio_output_t * p_aout, block_t *p_buffer, mtime_t date )
static void Play( audio_output_t * p_aout, block_t *p_buffer, vlc_tick_t date )
{
aout_sys_t *p_sys = p_aout->sys;
if( fwrite( p_buffer->p_buffer, p_buffer->i_buffer, 1,
@ -335,7 +335,7 @@ static void Play( audio_output_t * p_aout, block_t *p_buffer, mtime_t date )
(void) date;
}
static void Pause( audio_output_t *aout, bool paused, mtime_t date )
static void Pause( audio_output_t *aout, bool paused, vlc_tick_t date )
{
(void) aout; (void) paused; (void) date;
}

16
modules/audio_output/jack.c

@ -62,7 +62,7 @@ typedef struct
jack_nframes_t latency;
float soft_gain;
bool soft_mute;
mtime_t paused; /**< Time when (last) paused */
vlc_tick_t paused; /**< Time when (last) paused */
} aout_sys_t;
/*****************************************************************************
@ -70,10 +70,10 @@ typedef struct
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
static void Play ( audio_output_t * p_aout, block_t *, mtime_t );
static void Pause ( audio_output_t *aout, bool paused, mtime_t date );
static void Play ( audio_output_t * p_aout, block_t *, vlc_tick_t );
static void Pause ( audio_output_t *aout, bool paused, vlc_tick_t date );
static void Flush ( audio_output_t *p_aout, bool wait );
static int TimeGet ( audio_output_t *, mtime_t * );
static int TimeGet ( audio_output_t *, vlc_tick_t * );
static int Process ( jack_nframes_t i_frames, void *p_arg );
static int GraphChange ( void *p_arg );
@ -283,7 +283,7 @@ error_out:
return status;
}
static void Play(audio_output_t * p_aout, block_t * p_block, mtime_t date)
static void Play(audio_output_t * p_aout, block_t * p_block, vlc_tick_t date)
{
aout_sys_t *p_sys = p_aout->sys;
jack_ringbuffer_t *rb = p_sys->p_jack_ringbuffer;
@ -316,7 +316,7 @@ static void Play(audio_output_t * p_aout, block_t * p_block, mtime_t date)
/**
* Pause or unpause playback
*/
static void Pause(audio_output_t *aout, bool paused, mtime_t date)
static void Pause(audio_output_t *aout, bool paused, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
@ -337,7 +337,7 @@ static void Flush(audio_output_t *p_aout, bool wait)
/* Sleep if wait was requested */
if( wait )
{
mtime_t delay;
vlc_tick_t delay;
if (!TimeGet(p_aout, &delay))
msleep(delay);
}
@ -346,7 +346,7 @@ static void Flush(audio_output_t *p_aout, bool wait)
jack_ringbuffer_reset(rb);
}
static int TimeGet(audio_output_t *p_aout, mtime_t *delay)
static int TimeGet(audio_output_t *p_aout, vlc_tick_t *delay)
{
aout_sys_t * p_sys = p_aout->sys;
jack_ringbuffer_t *rb = p_sys->p_jack_ringbuffer;

12
modules/audio_output/kai.c

@ -72,10 +72,10 @@ typedef struct
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
static void Play ( audio_output_t *_p_aout, block_t *block, mtime_t );
static void Pause ( audio_output_t *, bool, mtime_t );
static void Play ( audio_output_t *_p_aout, block_t *block, vlc_tick_t );
static void Pause ( audio_output_t *, bool, vlc_tick_t );
static void Flush ( audio_output_t *, bool );
static int TimeGet ( audio_output_t *, mtime_t *restrict );
static int TimeGet ( audio_output_t *, vlc_tick_t *restrict );
static ULONG APIENTRY KaiCallback ( PVOID, PVOID, ULONG );
@ -233,7 +233,7 @@ exit_kai_done :
/*****************************************************************************
* Play: play a sound samples buffer
*****************************************************************************/
static void Play(audio_output_t *p_aout, block_t *block, mtime_t date)
static void Play(audio_output_t *p_aout, block_t *block, vlc_tick_t date)
{
aout_sys_t *p_sys = p_aout->sys;
@ -298,7 +298,7 @@ static void Close( vlc_object_t *obj )
free(sys);
}
static void Pause( audio_output_t *aout, bool pause, mtime_t date )
static void Pause( audio_output_t *aout, bool pause, vlc_tick_t date )
{
VLC_UNUSED( date );
@ -331,7 +331,7 @@ static void Flush( audio_output_t *aout, bool drain )
vlc_mutex_unlock( &buffer->mutex );
}
static int TimeGet( audio_output_t *aout, mtime_t *restrict delay )
static int TimeGet( audio_output_t *aout, vlc_tick_t *restrict delay )
{
aout_sys_t *sys = aout->sys;
audio_sample_format_t *format = &sys->format;

6
modules/audio_output/mmdevice.c

@ -124,7 +124,7 @@ static int vlc_FromHR(audio_output_t *aout, HRESULT hr)
}
/*** VLC audio output callbacks ***/
static int TimeGet(audio_output_t *aout, mtime_t *restrict delay)
static int TimeGet(audio_output_t *aout, vlc_tick_t *restrict delay)
{
aout_sys_t *sys = aout->sys;
HRESULT hr;
@ -136,7 +136,7 @@ static int TimeGet(audio_output_t *aout, mtime_t *restrict delay)
return SUCCEEDED(hr) ? 0 : -1;
}
static void Play(audio_output_t *aout, block_t *block, mtime_t date)
static void Play(audio_output_t *aout, block_t *block, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
HRESULT hr;
@ -149,7 +149,7 @@ static void Play(audio_output_t *aout, block_t *block, mtime_t date)
(void) date;
}
static void Pause(audio_output_t *aout, bool paused, mtime_t date)
static void Pause(audio_output_t *aout, bool paused, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
HRESULT hr;

6
modules/audio_output/mmdevice.h

@ -36,7 +36,7 @@ struct aout_stream
struct vlc_common_members obj;
void *sys;
HRESULT (*time_get)(aout_stream_t *, mtime_t *);
HRESULT (*time_get)(aout_stream_t *, vlc_tick_t *);
HRESULT (*play)(aout_stream_t *, block_t *);
HRESULT (*pause)(aout_stream_t *, bool);
HRESULT (*flush)(aout_stream_t *);
@ -62,7 +62,7 @@ typedef HRESULT (*aout_stream_start_t)(aout_stream_t *s,
*/
typedef HRESULT (*aout_stream_stop_t)(aout_stream_t *);
static inline HRESULT aout_stream_TimeGet(aout_stream_t *s, mtime_t *delay)
static inline HRESULT aout_stream_TimeGet(aout_stream_t *s, vlc_tick_t *delay)
{
return (s->time_get)(s, delay);
}
@ -81,7 +81,7 @@ static inline HRESULT aout_stream_Flush(aout_stream_t *s, bool wait)
{
if (wait)
{ /* Loosy drain emulation */
mtime_t delay;
vlc_tick_t delay;
if (SUCCEEDED(aout_stream_TimeGet(s, &delay))
&& delay <= INT64_C(5000000))

8
modules/audio_output/opensles_android.c

@ -150,7 +150,7 @@ static inline int bytesPerSample(void)
return 2 /* S16 */ * 2 /* stereo */;
}
static int TimeGet(audio_output_t* aout, mtime_t* restrict drift)
static int TimeGet(audio_output_t* aout, vlc_tick_t* restrict drift)
{
aout_sys_t *sys = aout->sys;
@ -182,7 +182,7 @@ static void Flush(audio_output_t *aout, bool drain)
aout_sys_t *sys = aout->sys;
if (drain) {
mtime_t delay;
vlc_tick_t delay;
if (!TimeGet(aout, &delay))
msleep(delay);
} else {
@ -233,7 +233,7 @@ static int MuteSet(audio_output_t *aout, bool mute)
return (r == SL_RESULT_SUCCESS) ? 0 : -1;
}
static void Pause(audio_output_t *aout, bool pause, mtime_t date)
static void Pause(audio_output_t *aout, bool pause, vlc_tick_t date)
{
(void)date;
aout_sys_t *sys = aout->sys;
@ -323,7 +323,7 @@ static int WriteBuffer(audio_output_t *aout)
/*****************************************************************************
* Play: play a sound
*****************************************************************************/
static void Play(audio_output_t *aout, block_t *p_buffer, mtime_t date)
static void Play(audio_output_t *aout, block_t *p_buffer, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;

12
modules/audio_output/oss.c

@ -87,9 +87,9 @@ vlc_module_begin ()
set_callbacks (Open, Close)
vlc_module_end ()
static int TimeGet (audio_output_t *, mtime_t *);
static void Play(audio_output_t *, block_t *, mtime_t);
static void Pause (audio_output_t *, bool, mtime_t);
static int TimeGet (audio_output_t *, vlc_tick_t *);
static void Play(audio_output_t *, block_t *, vlc_tick_t);
static void Pause (audio_output_t *, bool, vlc_tick_t);
static void Flush (audio_output_t *, bool);
static int Start (audio_output_t *aout, audio_sample_format_t *restrict fmt)
@ -250,7 +250,7 @@ error:
return VLC_EGENERIC;
}
static int TimeGet (audio_output_t *aout, mtime_t *restrict pts)
static int TimeGet (audio_output_t *aout, vlc_tick_t *restrict pts)
{
aout_sys_t *sys = aout->sys;
int delay;
@ -269,7 +269,7 @@ static int TimeGet (audio_output_t *aout, mtime_t *restrict pts)
/**
* Queues one audio buffer to the hardware.
*/
static void Play(audio_output_t *aout, block_t *block, mtime_t date)
static void Play(audio_output_t *aout, block_t *block, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
int fd = sys->fd;
@ -292,7 +292,7 @@ static void Play(audio_output_t *aout, block_t *block, mtime_t date)
/**
* Pauses/resumes the audio playback.
*/
static void Pause (audio_output_t *aout, bool pause, mtime_t date)
static void Pause (audio_output_t *aout, bool pause, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
int fd = sys->fd;

18
modules/audio_output/pulse.c

@ -68,8 +68,8 @@ typedef struct
pa_threaded_mainloop *mainloop; /**< PulseAudio thread */
pa_time_event *trigger; /**< Deferred stream trigger */
pa_cvolume cvolume; /**< actual sink input volume */
mtime_t first_pts; /**< Play stream timestamp of buffer start */
mtime_t first_date; /**< Play system timestamp of buffer start */
vlc_tick_t first_pts; /**< Play stream timestamp of buffer start */
vlc_tick_t first_date; /**< Play system timestamp of buffer start */
pa_volume_t volume_force; /**< Forced volume (stream must be NULL) */
pa_stream_flags_t flags_force; /**< Forced flags (stream must be NULL) */
@ -222,10 +222,10 @@ static void stream_trigger_cb(pa_mainloop_api *api, pa_time_event *e,
* in order to minimize desync and resampling during early playback.
* @note PulseAudio lock required.
*/
static void stream_start(pa_stream *s, audio_output_t *aout, mtime_t date)
static void stream_start(pa_stream *s, audio_output_t *aout, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
mtime_t delta;
vlc_tick_t delta;
assert (sys->first_pts != VLC_TS_INVALID);
@ -439,7 +439,7 @@ static void context_cb(pa_context *ctx, pa_subscription_event_type_t type,
/*** VLC audio output callbacks ***/
static int TimeGet(audio_output_t *aout, mtime_t *restrict delay)
static int TimeGet(audio_output_t *aout, vlc_tick_t *restrict delay)
{
aout_sys_t *sys = aout->sys;
pa_stream *s = sys->stream;
@ -448,7 +448,7 @@ static int TimeGet(audio_output_t *aout, mtime_t *restrict delay)
pa_threaded_mainloop_lock(sys->mainloop);
if (pa_stream_is_corked(s) <= 0)
{ /* latency is relevant only if not corked */
mtime_t delta = vlc_pa_get_latency(aout, sys->context, s);
vlc_tick_t delta = vlc_pa_get_latency(aout, sys->context, s);
if (delta != VLC_TS_INVALID)
{
*delay = delta;
@ -486,7 +486,7 @@ static void *data_convert(block_t **pp)
/**
* Queue one audio frame to the playback stream
*/
static void Play(audio_output_t *aout, block_t *block, mtime_t date)
static void Play(audio_output_t *aout, block_t *block, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
pa_stream *s = sys->stream;
@ -531,7 +531,7 @@ static void Play(audio_output_t *aout, block_t *block, mtime_t date)
/**
* Cork or uncork the playback stream
*/
static void Pause(audio_output_t *aout, bool paused, mtime_t date)
static void Pause(audio_output_t *aout, bool paused, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
pa_stream *s = sys->stream;
@ -568,7 +568,7 @@ static void Flush(audio_output_t *aout, bool wait)
/* XXX: Loosy drain emulation.
* See #18141: drain callback is never received */
mtime_t delay;
vlc_tick_t delay;
if (TimeGet(aout, &delay) == 0 && delay <= INT64_C(5000000))
msleep(delay);
}

10
modules/audio_output/sndio.c

@ -43,8 +43,8 @@ vlc_module_begin ()
set_callbacks (Open, Close)
vlc_module_end ()
static int TimeGet (audio_output_t *, mtime_t *);
static void Play(audio_output_t *, block_t *, mtime_t);
static int TimeGet (audio_output_t *, vlc_tick_t *);
static void Play(audio_output_t *, block_t *, vlc_tick_t);
static void Flush (audio_output_t *, bool);
static int VolumeSet (audio_output_t *, float);
static int MuteSet (audio_output_t *, bool);
@ -220,17 +220,17 @@ static void PositionChanged (void *arg, int delta)
sys->started = 1;
}
static int TimeGet (audio_output_t *aout, mtime_t *restrict delay)
static int TimeGet (audio_output_t *aout, vlc_tick_t *restrict delay)
{
aout_sys_t *sys = aout->sys;
if (!sys->started)
return -1;
*delay = (mtime_t)sys->delay * CLOCK_FREQ / sys->rate;
*delay = (vlc_tick_t)sys->delay * CLOCK_FREQ / sys->rate;
return 0;
}
static void Play(audio_output_t *aout, block_t *block, mtime_t date)
static void Play(audio_output_t *aout, block_t *block, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;

4
modules/audio_output/tizen_audio.c

@ -265,7 +265,7 @@ Stop( audio_output_t *p_aout )
}
static void
Play( audio_output_t *p_aout, block_t *p_block, mtime_t date )
Play( audio_output_t *p_aout, block_t *p_block, vlc_tick_t date )
{
aout_sys_t *p_sys = p_aout->sys;
@ -299,7 +299,7 @@ Play( audio_output_t *p_aout, block_t *p_block, mtime_t date )
}
static void
Pause( audio_output_t *p_aout, bool b_pause, mtime_t i_date )
Pause( audio_output_t *p_aout, bool b_pause, vlc_tick_t i_date )
{
aout_sys_t *p_sys = p_aout->sys;
(void) i_date;

2
modules/audio_output/vlcpulse.c

@ -252,7 +252,7 @@ void vlc_pa_rttime_free (pa_threaded_mainloop *mainloop, pa_time_event *e)
* Gets latency of a PulseAudio stream.
* \return the latency or VLC_TS_INVALID on error.
*/
mtime_t vlc_pa_get_latency(vlc_object_t *obj, pa_context *ctx, pa_stream *s)
vlc_tick_t vlc_pa_get_latency(vlc_object_t *obj, pa_context *ctx, pa_stream *s)
{
/* NOTE: pa_stream_get_latency() will report 0 rather than negative latency
* when the write index of a playback stream is behind its read index.

2
modules/audio_output/vlcpulse.h

@ -34,7 +34,7 @@ VLC_API void vlc_pa_disconnect (vlc_object_t *obj, pa_context *ctx,
VLC_API void vlc_pa_error (vlc_object_t *, const char *msg, pa_context *);
#define vlc_pa_error(o, m, c) vlc_pa_error(VLC_OBJECT(o), m, c)
VLC_API mtime_t vlc_pa_get_latency (vlc_object_t *, pa_context *, pa_stream *);
VLC_API vlc_tick_t vlc_pa_get_latency (vlc_object_t *, pa_context *, pa_stream *);
#define vlc_pa_get_latency(o, c, s) vlc_pa_get_latency(VLC_OBJECT(o), c, s)
VLC_API void vlc_pa_rttime_free (pa_threaded_mainloop *, pa_time_event *);

2
modules/audio_output/wasapi.c

@ -98,7 +98,7 @@ typedef struct aout_stream_sys
/*** VLC audio output callbacks ***/
static HRESULT TimeGet(aout_stream_t *s, mtime_t *restrict delay)
static HRESULT TimeGet(aout_stream_t *s, vlc_tick_t *restrict delay)
{
aout_stream_sys_t *sys = s->sys;
void *pv;

16
modules/audio_output/waveout.c

@ -49,7 +49,7 @@
*****************************************************************************/
static int Open ( vlc_object_t * );
static void Close ( vlc_object_t * );
static void Play ( audio_output_t *, block_t *, mtime_t );
static void Play ( audio_output_t *, block_t *, vlc_tick_t );
/*****************************************************************************
* notification_thread_t: waveOut event thread
@ -79,9 +79,9 @@ static void WaveOutClearBuffer( HWAVEOUT, WAVEHDR *);
static int ReloadWaveoutDevices( const char *, char ***, char *** );
static uint32_t findDeviceID(char *);
static int WaveOutTimeGet(audio_output_t * , mtime_t *);
static int WaveOutTimeGet(audio_output_t * , vlc_tick_t *);
static void WaveOutFlush( audio_output_t *, bool);
static void WaveOutPause( audio_output_t *, bool, mtime_t);
static void WaveOutPause( audio_output_t *, bool, vlc_tick_t);
static int WaveoutVolumeSet(audio_output_t * p_aout, float volume);
static int WaveoutMuteSet(audio_output_t * p_aout, bool mute);
@ -122,7 +122,7 @@ struct aout_sys_t
uint8_t chan_table[AOUT_CHAN_MAX];
vlc_fourcc_t format;
mtime_t i_played_length;
vlc_tick_t i_played_length;
struct lkwavehdr * p_free_list;
@ -343,7 +343,7 @@ static int Start( audio_output_t *p_aout, audio_sample_format_t *restrict fmt )
* This doesn't actually play the buffer. This just stores the buffer so it
* can be played by the callback thread.
*****************************************************************************/
static void Play( audio_output_t *p_aout, block_t *block, mtime_t date )
static void Play( audio_output_t *p_aout, block_t *block, vlc_tick_t date )
{
aout_sys_t *sys = p_aout->sys;
@ -849,7 +849,7 @@ static void Close(vlc_object_t *obj)
free(sys);
}
static int WaveOutTimeGet(audio_output_t * p_aout, mtime_t *delay)
static int WaveOutTimeGet(audio_output_t * p_aout, vlc_tick_t *delay)
{
MMTIME mmtime;
mmtime.wType = TIME_SAMPLES;
@ -865,7 +865,7 @@ static int WaveOutTimeGet(audio_output_t * p_aout, mtime_t *delay)
return -1;
}
mtime_t i_pos = (mtime_t) mmtime.u.sample * CLOCK_FREQ / sys->i_rate;
vlc_tick_t i_pos = (vlc_tick_t) mmtime.u.sample * CLOCK_FREQ / sys->i_rate;
*delay = sys->i_played_length - i_pos;
return 0;
}
@ -893,7 +893,7 @@ static void WaveOutFlush( audio_output_t *p_aout, bool wait)
}
}
static void WaveOutPause( audio_output_t * p_aout, bool pause, mtime_t date)
static void WaveOutPause( audio_output_t * p_aout, bool pause, vlc_tick_t date)
{
MMRESULT res;
(void) date;

6
modules/audio_output/winstore.c

@ -136,7 +136,7 @@ done:
return SUCCEEDED(hr) ? 0 : -1;
}
static int TimeGet(audio_output_t *aout, mtime_t *restrict delay)
static int TimeGet(audio_output_t *aout, vlc_tick_t *restrict delay)
{
aout_sys_t *sys = aout->sys;
if( unlikely( sys->client == NULL ) )
@ -150,7 +150,7 @@ static int TimeGet(audio_output_t *aout, mtime_t *restrict delay)
return SUCCEEDED(hr) ? 0 : -1;
}
static void Play(audio_output_t *aout, block_t *block, mtime_t date)
static void Play(audio_output_t *aout, block_t *block, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
if( unlikely( sys->client == NULL ) )
@ -164,7 +164,7 @@ static void Play(audio_output_t *aout, block_t *block, mtime_t date)
(void) date;
}
static void Pause(audio_output_t *aout, bool paused, mtime_t date)
static void Pause(audio_output_t *aout, bool paused, vlc_tick_t date)
{
aout_sys_t *sys = aout->sys;
if( unlikely( sys->client == NULL ) )

4
modules/codec/aom.c

@ -161,7 +161,7 @@ static int Decode(decoder_t *dec, block_t *block)
}
/* Associate packet PTS with decoded frame */
mtime_t *pkt_pts = malloc(sizeof(*pkt_pts));
vlc_tick_t *pkt_pts = malloc(sizeof(*pkt_pts));
if (!pkt_pts) {
block_Release(block);
return VLCDEC_SUCCESS;
@ -189,7 +189,7 @@ static int Decode(decoder_t *dec, block_t *block)
/* fetches back the PTS */
pkt_pts = img->user_priv;
mtime_t pts = *pkt_pts;
vlc_tick_t pts = *pkt_pts;
free(pkt_pts);
dec->fmt_out.i_codec = FindVlcChroma(img);

4
modules/codec/arib/substext.h

@ -48,7 +48,7 @@ typedef struct
static int SubpictureTextValidate(subpicture_t *subpic,
bool has_src_changed, const video_format_t *fmt_src,
bool has_dst_changed, const video_format_t *fmt_dst,
mtime_t ts)
vlc_tick_t ts)
{
arib_spu_updater_sys_t *sys = subpic->updater.p_sys;
VLC_UNUSED(fmt_src); VLC_UNUSED(fmt_dst); VLC_UNUSED(ts);
@ -63,7 +63,7 @@ static int SubpictureTextValidate(subpicture_t *subpic,
static void SubpictureTextUpdate(subpicture_t *subpic,
const video_format_t *fmt_src,
const video_format_t *fmt_dst,
mtime_t ts)
vlc_tick_t ts)
{
arib_spu_updater_sys_t *sys = subpic->updater.p_sys;
VLC_UNUSED(fmt_src); VLC_UNUSED(ts);

12
modules/codec/avcodec/encoder.c

@ -106,9 +106,9 @@ typedef struct
/*
* Video properties
*/
mtime_t i_last_ref_pts;
mtime_t i_buggy_pts_detect;
mtime_t i_last_pts;
vlc_tick_t i_last_ref_pts;
vlc_tick_t i_buggy_pts_detect;
vlc_tick_t i_last_pts;
bool b_inited;
/*
@ -119,7 +119,7 @@ typedef struct
size_t i_samples_delay; //How much samples in delay buffer
bool b_planar;
bool b_variable; //Encoder can be fed with any size frames not just frame_size
mtime_t i_pts;
vlc_tick_t i_pts;
date_t buffer_date;
/* Multichannel (>2) channel reordering */
@ -1069,7 +1069,7 @@ static void vlc_av_packet_Release(block_t *block)
free(b);
}
static block_t *vlc_av_packet_Wrap(AVPacket *packet, mtime_t i_length, AVCodecContext *context )
static block_t *vlc_av_packet_Wrap(AVPacket *packet, vlc_tick_t i_length, AVCodecContext *context )
{
if ( packet->data == NULL &&
packet->flags == 0 &&
@ -1103,7 +1103,7 @@ static block_t *vlc_av_packet_Wrap(AVPacket *packet, mtime_t i_length, AVCodecCo
static void check_hurry_up( encoder_sys_t *p_sys, AVFrame *frame, encoder_t *p_enc )
{
mtime_t current_date = mdate();
vlc_tick_t current_date = mdate();
if ( current_date + HURRY_UP_GUARD3 > frame->pts )
{

4
modules/codec/avcodec/subtitle.c

@ -45,7 +45,7 @@ typedef struct
bool b_need_ephemer; /* Does the format need the ephemer flag (no end time set) */
} decoder_sys_t;
static subpicture_t *ConvertSubtitle(decoder_t *, AVSubtitle *, mtime_t pts,
static subpicture_t *ConvertSubtitle(decoder_t *, AVSubtitle *, vlc_tick_t pts,
AVCodecContext *avctx);
static int DecodeSubtitle(decoder_t *, block_t *);
static void Flush(decoder_t *);
@ -311,7 +311,7 @@ static subpicture_region_t *ConvertRegionRGBA(AVSubtitleRect *ffregion)
/**
* Convert a libavcodec subtitle to our format.
*/
static subpicture_t *ConvertSubtitle(decoder_t *dec, AVSubtitle *ffsub, mtime_t pts,
static subpicture_t *ConvertSubtitle(decoder_t *dec, AVSubtitle *ffsub, vlc_tick_t pts,
AVCodecContext *avctx)
{
subpicture_t *spu = decoder_NewSubpicture(dec, NULL);

10
modules/codec/avcodec/video.c

@ -91,7 +91,7 @@ typedef struct
/* how many decoded frames are late */
int i_late_frames;
int64_t i_last_output_frame;
mtime_t i_last_late_delay;
vlc_tick_t i_last_late_delay;
/* for direct rendering */
bool b_direct_rendering;
@ -756,11 +756,11 @@ static void interpolate_next_pts( decoder_t *p_dec, AVFrame *frame )
}
static void update_late_frame_count( decoder_t *p_dec, block_t *p_block,
mtime_t current_time, mtime_t i_pts, int64_t i_fnum )
vlc_tick_t current_time, vlc_tick_t i_pts, int64_t i_fnum )
{
decoder_sys_t *p_sys = p_dec->p_sys;
/* Update frame late count (except when doing preroll) */
mtime_t i_display_date = VLC_TS_INVALID;
vlc_tick_t i_display_date = VLC_TS_INVALID;
if( !p_block || !(p_block->i_flags & BLOCK_FLAG_PREROLL) )
i_display_date = decoder_GetDisplayDate( p_dec, i_pts );
@ -1140,12 +1140,12 @@ static int DecodeBlock( decoder_t *p_dec, block_t **pp_block )
/* Compute the PTS */
#ifdef FF_API_PKT_PTS
mtime_t i_pts = frame->pts;
vlc_tick_t i_pts = frame->pts;
if (i_pts == AV_NOPTS_VALUE )
i_pts = frame->pkt_dts;
#else
mtime_t i_pts = frame->pkt_pts;
vlc_tick_t i_pts = frame->pkt_pts;
#endif
if( i_pts == AV_NOPTS_VALUE )
i_pts = date_Get( &p_sys->pts );

10
modules/codec/cc.c

@ -231,7 +231,7 @@ typedef struct
static int Decode( decoder_t *, block_t * );
static void Flush( decoder_t * );
static void DTVCC_ServiceData_Handler( void *priv, uint8_t i_sid, mtime_t i_time,
static void DTVCC_ServiceData_Handler( void *priv, uint8_t i_sid, vlc_tick_t i_time,
const uint8_t *p_data, size_t i_data )
{
decoder_t *p_dec = priv;
@ -340,7 +340,7 @@ static void Flush( decoder_t *p_dec )
****************************************************************************/
static void Push( decoder_t *, block_t * );
static block_t *Pop( decoder_t *, bool );
static void Convert( decoder_t *, mtime_t, const uint8_t *, size_t );
static void Convert( decoder_t *, vlc_tick_t, const uint8_t *, size_t );
static bool DoDecode( decoder_t *p_dec, bool b_drain )
{
@ -482,7 +482,7 @@ static block_t *Pop( decoder_t *p_dec, bool b_forced )
return p_block;
}
static subpicture_t *Subtitle( decoder_t *p_dec, eia608_t *h, mtime_t i_pts )
static subpicture_t *Subtitle( decoder_t *p_dec, eia608_t *h, vlc_tick_t i_pts )
{
//decoder_sys_t *p_sys = p_dec->p_sys;
subpicture_t *p_spu = NULL;
@ -531,7 +531,7 @@ static subpicture_t *Subtitle( decoder_t *p_dec, eia608_t *h, mtime_t i_pts )
return p_spu;
}
static void Convert( decoder_t *p_dec, mtime_t i_pts,
static void Convert( decoder_t *p_dec, vlc_tick_t i_pts,
const uint8_t *p_buffer, size_t i_buffer )
{
decoder_sys_t *p_sys = p_dec->p_sys;
@ -541,7 +541,7 @@ static void Convert( decoder_t *p_dec, mtime_t i_pts,
{
if( (p_buffer[0] & 0x04) /* Valid bit */ )
{
const mtime_t i_spupts = i_pts + i_ticks * CLOCK_FREQ / (1200/3);
const vlc_tick_t i_spupts = i_pts + i_ticks * CLOCK_FREQ / (1200/3);
/* Mask off the specific i_field bit, else some sequences can be lost. */
if ( p_sys->p_eia608 &&
(p_buffer[0] & 0x03) == p_sys->i_field )

12
modules/codec/cea708.c

@ -45,7 +45,7 @@ struct cea708_demux_t
uint8_t i_total_data;
uint8_t i_data;
uint8_t data[CEA708_DTVCC_MAX_PKT_SIZE];
mtime_t i_time;
vlc_tick_t i_time;
service_data_hdlr_t p_callback;
void *priv;
};
@ -73,7 +73,7 @@ cea708_demux_t * CEA708_DTVCC_Demuxer_New( void *priv, service_data_hdlr_t hdlr
return h;
}
static void CEA708_DTVCC_Demux_ServiceBlocks( cea708_demux_t *h, mtime_t i_start,
static void CEA708_DTVCC_Demux_ServiceBlocks( cea708_demux_t *h, vlc_tick_t i_start,
const uint8_t *p_data, size_t i_data )
{
while( i_data >= 2 )
@ -103,7 +103,7 @@ static void CEA708_DTVCC_Demux_ServiceBlocks( cea708_demux_t *h, mtime_t i_start
}
}
void CEA708_DTVCC_Demuxer_Push( cea708_demux_t *h, mtime_t i_start, const uint8_t data[3] )
void CEA708_DTVCC_Demuxer_Push( cea708_demux_t *h, vlc_tick_t i_start, const uint8_t data[3] )
{
if( (data[0] & 0x03) == 3 ) /* Header packet */
{
@ -442,8 +442,8 @@ struct cea708_t
/* Decoding context */
cea708_window_t *p_cw; /* current window */
mtime_t suspended_deadline; /* > 0 when delay is active */
mtime_t i_clock;
vlc_tick_t suspended_deadline; /* > 0 when delay is active */
vlc_tick_t i_clock;
bool b_text_waiting;
};
@ -1664,7 +1664,7 @@ static void CEA708_Decode_ServiceBuffer( cea708_t *h )
}
}
void CEA708_Decoder_Push( cea708_t *h, mtime_t i_time,
void CEA708_Decoder_Push( cea708_t *h, vlc_tick_t i_time,
const uint8_t *p_data, size_t i_data )
{
/* Set new buffer start time */

Some files were not shown because too many files changed in this diff

Loading…
Cancel
Save