/src/vlc/src/input/es_out.h

Source
/*****************************************************************************
 * es_out.h: Input es_out functions
 *****************************************************************************
 * Copyright (C) 1998-2008 VLC authors and VideoLAN
 * Copyright (C) 2008 Laurent Aimar
 *
 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
 *****************************************************************************/

#ifndef LIBVLC_INPUT_ES_OUT_H
#define LIBVLC_INPUT_ES_OUT_H 1

#include <vlc_common.h>
#include <vlc_es_out.h>

#include "input_internal.h"

typedef struct input_thread_t input_thread_t;

enum es_out_mode_e
{
    ES_OUT_MODE_NONE,   /* don't select anything */
    ES_OUT_MODE_ALL,    /* eg for stream output */
    ES_OUT_MODE_AUTO,   /* best audio/video or for input follow audio-track, sub-track */
    ES_OUT_MODE_PARTIAL,/* select programs given after --programs */
    ES_OUT_MODE_END     /* mark the es_out as dead */
};

enum es_out_query_private_e
{
    /* set/get mode */
    ES_OUT_PRIV_SET_MODE = ES_OUT_PRIVATE_START, /* arg1= int */

    /* Same than ES_OUT_SET_ES/ES_OUT_UNSET_ES/ES_OUT_RESTART_ES, but with vlc_es_id_t * */
    ES_OUT_PRIV_SET_ES,      /* arg1= vlc_es_id_t*                   */
    ES_OUT_PRIV_UNSET_ES,    /* arg1= vlc_es_id_t* res=can fail      */
    ES_OUT_PRIV_RESTART_ES,  /* arg1= vlc_es_id_t*                   */

    /* Get date to wait before demuxing more data */
    ES_OUT_PRIV_GET_WAKE_UP,                        /* arg1=vlc_tick_t*            res=cannot fail */

    /* Select a list of ES */
    ES_OUT_PRIV_SET_ES_LIST, /* arg1= vlc_es_id_t *const* (null terminated array) */

    ES_OUT_PRIV_SET_ES_CAT_IDS, /* arg1=es_format_category_e arg2=const char *, res=cannot fail */

    /* Stop all selected ES and save the stopped state in a context.
     * Call ES_OUT_PRIV_START_ALL_ES to release the context. */
    ES_OUT_PRIV_STOP_ALL_ES,                        /* arg1=vlc_es_id_t *** */
    /* Start all ES from the context returned by ES_OUT_PRIV_STOP_ALL_ES */
    ES_OUT_PRIV_START_ALL_ES,                       /* arg1=vlc_es_id_t ** */

    /* Get buffering state */
    ES_OUT_PRIV_GET_BUFFERING,                      /* arg1=bool*               res=cannot fail */

    /* Set delay for an ES identifier */
    ES_OUT_PRIV_SET_ES_DELAY,                       /* arg1=vlc_es_id_t *, res=cannot fail */

    /* Set delay for a ES category */
    ES_OUT_PRIV_SET_DELAY,                          /* arg1=es_category_e,      res=cannot fail */

    /* Set record state */
    ES_OUT_PRIV_SET_RECORD_STATE,                        /* arg1=bool                res=can fail */

    /* Set pause state */
    ES_OUT_PRIV_SET_PAUSE_STATE,                    /* arg1=bool b_source_paused, bool b_paused arg2=vlc_tick_t res=can fail */

    /* Set rate */
    ES_OUT_PRIV_SET_RATE,                           /* arg1=double source_rate arg2=double rate res=can fail */

    /* RESET_PCR coming from decoders, when searching for a previous frame */
    ES_OUT_PRIV_RESET_PCR_FRAME_PREV,               /* arg1=vlc_tick_t buffering_duration, res=cannot fail */

    /* Set next frame */
    ES_OUT_PRIV_SET_FRAME_NEXT,                     /*                          res=can fail */

    /* Set previous frame */
    ES_OUT_PRIV_SET_FRAME_PREVIOUS,                     /*                          res=can fail */

    /* Set position/time/length */
    ES_OUT_PRIV_SET_TIMES,                          /* arg1=double f_position arg2=vlc_tick_t i_time arg3=vlc_tick_t i_normal_time arg4=vlc_tick_t i_length arg5 int b_live res=cannot fail */

    /* Set jitter */
    ES_OUT_PRIV_SET_JITTER,                         /* arg1=vlc_tick_t i_pts_delay arg2= vlc_tick_t i_pts_jitter, arg2=int i_cr_average res=cannot fail */

    /* Get forced group */
    ES_OUT_PRIV_GET_GROUP_FORCED,                   /* arg1=int * res=cannot fail */

    /* Set End Of Stream */
    ES_OUT_PRIV_SET_EOS,                            /* res=cannot fail */

    /* Set a VBI/Teletext page */
    ES_OUT_PRIV_SET_VBI_PAGE,                       /* arg1=unsigned res=can fail */

    /* Set VBI/Teletext menu transparent */
    ES_OUT_PRIV_SET_VBI_TRANSPARENCY                /* arg1=bool res=can fail */
};

struct vlc_input_es_out;
struct vlc_input_es_out_ops {
    int (*priv_control)(
        struct vlc_input_es_out *out,
        input_source_t *source,
        int query,
        va_list args);
};

struct vlc_input_es_out {
    es_out_t out;

    const struct vlc_input_es_out_ops *ops;
};

static inline int
es_out_vaPrivControl(struct vlc_input_es_out *out, int query, va_list args )
{
    return out->ops->priv_control(out, NULL, query, args);
}

static inline int
es_out_PrivControl(struct vlc_input_es_out *out, int query, ...)
{
    va_list args;
    va_start( args, query );
    int result = es_out_vaPrivControl( out, query, args );
    va_end( args );
    return result;
}

static inline void
es_out_SetMode(struct vlc_input_es_out *out, int i_mode)
{
    int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_MODE, i_mode);
    assert( !i_ret );
}

static inline int
es_out_SetEs(struct vlc_input_es_out *out, vlc_es_id_t *id)
{
    return es_out_PrivControl(out, ES_OUT_PRIV_SET_ES, id);
}

static inline int
es_out_UnsetEs(struct vlc_input_es_out *out, vlc_es_id_t *id)
{
    return es_out_PrivControl(out, ES_OUT_PRIV_UNSET_ES, id);
}

static inline int
es_out_RestartEs(struct vlc_input_es_out *out, vlc_es_id_t *id)
{
    return es_out_PrivControl(out, ES_OUT_PRIV_RESTART_ES, id);
}

static inline vlc_tick_t
es_out_GetWakeup(struct vlc_input_es_out *out)
{
    vlc_tick_t i_wu;
    int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_GET_WAKE_UP, &i_wu);

    assert( !i_ret );
    return i_wu;
}

static inline int
es_out_SetEsList(struct vlc_input_es_out *out,
                 enum es_format_category_e cat,
                 vlc_es_id_t **ids)
{
    return es_out_PrivControl(out, ES_OUT_PRIV_SET_ES_LIST, cat, ids);
}

static inline void
es_out_SetEsCatIds(struct vlc_input_es_out *out,
                   enum es_format_category_e cat,
                   const char *str_ids)
{
    int ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_ES_CAT_IDS,
                                 cat, str_ids);
    assert( ret == VLC_SUCCESS );
}

static inline int
es_out_StopAllEs(struct vlc_input_es_out *out,
                 vlc_es_id_t ***context)
{
    return es_out_PrivControl(out, ES_OUT_PRIV_STOP_ALL_ES, context);
}

static inline int
es_out_StartAllEs(struct vlc_input_es_out *out, vlc_es_id_t **context )
{
    return es_out_PrivControl(out, ES_OUT_PRIV_START_ALL_ES, context);
}

static inline bool
es_out_GetBuffering(struct vlc_input_es_out *out)
{
    bool b;
    int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_GET_BUFFERING, &b);

    assert( !i_ret );
    return b;
}

static inline bool
es_out_IsEmpty(struct vlc_input_es_out *out)
{
    bool b;
    int i_ret = es_out_Control(&out->out, ES_OUT_IS_EMPTY, &b);

    assert( !i_ret );
    return b;
}

static inline void
es_out_SetEsDelay(struct vlc_input_es_out *out,
                  vlc_es_id_t *es,
                  vlc_tick_t i_delay)
{
    int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_ES_DELAY, es, i_delay);
    assert( !i_ret );
}

static inline void
es_out_SetDelay(struct vlc_input_es_out *out,
                int i_cat,
                vlc_tick_t i_delay)
{
    int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_DELAY, i_cat, i_delay);
    assert( !i_ret );
}

static inline int
es_out_SetRecordState(struct vlc_input_es_out *out,
                      bool b_record,
                      const char *dir_path)
{
    return es_out_PrivControl(out, ES_OUT_PRIV_SET_RECORD_STATE, b_record, dir_path);
}

static inline int
es_out_SetPauseState(struct vlc_input_es_out *out,
                     bool b_source_paused,
                     bool b_paused,
                     vlc_tick_t i_date)
{
    return es_out_PrivControl(out, ES_OUT_PRIV_SET_PAUSE_STATE, b_source_paused, b_paused, i_date);
}

static inline int
es_out_SetRate(struct vlc_input_es_out *out, float source_rate, float rate)
{
    return es_out_PrivControl(out, ES_OUT_PRIV_SET_RATE, source_rate, rate);
}

static inline int
es_out_SetFrameNext(struct vlc_input_es_out *out )
{
    return es_out_PrivControl(out, ES_OUT_PRIV_SET_FRAME_NEXT);
}

static inline int es_out_SetFramePrevious(struct vlc_input_es_out *out)
{
    return es_out_PrivControl(out, ES_OUT_PRIV_SET_FRAME_PREVIOUS);
}

static inline void
es_out_SetTimes(struct vlc_input_es_out *out, double f_position,
                vlc_tick_t i_time, vlc_tick_t i_normal_time,
                vlc_tick_t i_length, bool b_live  )
{
    int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_TIMES, f_position, i_time,
                                   i_normal_time, i_length, b_live);
    assert( !i_ret );
}

static inline void
es_out_SetJitter(struct vlc_input_es_out *out,
                 vlc_tick_t i_pts_delay, vlc_tick_t i_pts_jitter,
                 int i_cr_average)
{
    int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_JITTER,
                                   i_pts_delay, i_pts_jitter, i_cr_average);
    assert( !i_ret );
}

static inline int
es_out_GetGroupForced(struct vlc_input_es_out *out)
{
    int i_group;
    int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_GET_GROUP_FORCED, &i_group);
    assert( !i_ret );
    return i_group;
}

static inline void
es_out_Eos(struct vlc_input_es_out *out)
{
    int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_EOS);
    assert( !i_ret );
}

static inline int
es_out_SetVbiPage(struct vlc_input_es_out *out, vlc_es_id_t *id,
                  unsigned page)
{
    return es_out_PrivControl(out, ES_OUT_PRIV_SET_VBI_PAGE, id, page);
}

static inline int
es_out_SetVbiTransparency(struct vlc_input_es_out *out, vlc_es_id_t *id,
                          bool enabled)
{
    return es_out_PrivControl(out, ES_OUT_PRIV_SET_VBI_TRANSPARENCY, id,
                              enabled);
}

struct vlc_input_es_out *
input_EsOutNew(input_thread_t *, input_source_t *main_source, float rate,
               enum input_type input_type);

struct vlc_input_es_out *
input_EsOutTimeshiftNew(input_thread_t *, struct vlc_input_es_out *, float i_rate);

struct vlc_input_es_out *
input_EsOutSourceNew(struct vlc_input_es_out *master_out, input_source_t *in);

es_out_id_t *vlc_es_id_get_out(vlc_es_id_t *id);
const input_source_t *vlc_es_id_GetSource(vlc_es_id_t *id);

static inline void
vlc_input_es_out_Delete(struct vlc_input_es_out *out)
{
    es_out_Delete(&out->out);
}

#endif

Coverage Report

Created: 2026-07-12 08:57

Line	Count	Source
1		/*****************************************************************************
2		* es_out.h: Input es_out functions
3		*****************************************************************************
4		* Copyright (C) 1998-2008 VLC authors and VideoLAN
5		* Copyright (C) 2008 Laurent Aimar
6		*
7		* Authors: Laurent Aimar <fenrir@via.ecp.fr>
8		*
9		* This program is free software; you can redistribute it and/or modify it
10		* under the terms of the GNU Lesser General Public License as published by
11		* the Free Software Foundation; either version 2.1 of the License, or
12		* (at your option) any later version.
13		*
14		* This program is distributed in the hope that it will be useful,
15		* but WITHOUT ANY WARRANTY; without even the implied warranty of
16		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17		* GNU Lesser General Public License for more details.
18		*
19		* You should have received a copy of the GNU Lesser General Public License
20		* along with this program; if not, write to the Free Software Foundation,
21		* Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22		*****************************************************************************/
23
24		#ifndef LIBVLC_INPUT_ES_OUT_H
25		#define LIBVLC_INPUT_ES_OUT_H 1
26
27		#include <vlc_common.h>
28		#include <vlc_es_out.h>
29
30		#include "input_internal.h"
31
32		typedef struct input_thread_t input_thread_t;
33
34		enum es_out_mode_e
35		{
36		ES_OUT_MODE_NONE, /* don't select anything */
37		ES_OUT_MODE_ALL, /* eg for stream output */
38		ES_OUT_MODE_AUTO, /* best audio/video or for input follow audio-track, sub-track */
39		ES_OUT_MODE_PARTIAL,/* select programs given after --programs */
40		ES_OUT_MODE_END /* mark the es_out as dead */
41		};
42
43		enum es_out_query_private_e
44		{
45		/* set/get mode */
46		ES_OUT_PRIV_SET_MODE = ES_OUT_PRIVATE_START, /* arg1= int */
47
48		/* Same than ES_OUT_SET_ES/ES_OUT_UNSET_ES/ES_OUT_RESTART_ES, but with vlc_es_id_t * */
49		ES_OUT_PRIV_SET_ES, /* arg1= vlc_es_id_t* */
50		ES_OUT_PRIV_UNSET_ES, /* arg1= vlc_es_id_t* res=can fail */
51		ES_OUT_PRIV_RESTART_ES, /* arg1= vlc_es_id_t* */
52
53		/* Get date to wait before demuxing more data */
54		ES_OUT_PRIV_GET_WAKE_UP, /* arg1=vlc_tick_t* res=cannot fail */
55
56		/* Select a list of ES */
57		ES_OUT_PRIV_SET_ES_LIST, /* arg1= vlc_es_id_t const (null terminated array) */
58
59		ES_OUT_PRIV_SET_ES_CAT_IDS, /* arg1=es_format_category_e arg2=const char , res=cannot fail /
60
61		/* Stop all selected ES and save the stopped state in a context.
62		* Call ES_OUT_PRIV_START_ALL_ES to release the context. */
63		ES_OUT_PRIV_STOP_ALL_ES, /* arg1=vlc_es_id_t *** */
64		/* Start all ES from the context returned by ES_OUT_PRIV_STOP_ALL_ES */
65		ES_OUT_PRIV_START_ALL_ES, /* arg1=vlc_es_id_t ** */
66
67		/* Get buffering state */
68		ES_OUT_PRIV_GET_BUFFERING, /* arg1=bool* res=cannot fail */
69
70		/* Set delay for an ES identifier */
71		ES_OUT_PRIV_SET_ES_DELAY, /* arg1=vlc_es_id_t , res=cannot fail /
72
73		/* Set delay for a ES category */
74		ES_OUT_PRIV_SET_DELAY, /* arg1=es_category_e, res=cannot fail */
75
76		/* Set record state */
77		ES_OUT_PRIV_SET_RECORD_STATE, /* arg1=bool res=can fail */
78
79		/* Set pause state */
80		ES_OUT_PRIV_SET_PAUSE_STATE, /* arg1=bool b_source_paused, bool b_paused arg2=vlc_tick_t res=can fail */
81
82		/* Set rate */
83		ES_OUT_PRIV_SET_RATE, /* arg1=double source_rate arg2=double rate res=can fail */
84
85		/* RESET_PCR coming from decoders, when searching for a previous frame */
86		ES_OUT_PRIV_RESET_PCR_FRAME_PREV, /* arg1=vlc_tick_t buffering_duration, res=cannot fail */
87
88		/* Set next frame */
89		ES_OUT_PRIV_SET_FRAME_NEXT, /* res=can fail */
90
91		/* Set previous frame */
92		ES_OUT_PRIV_SET_FRAME_PREVIOUS, /* res=can fail */
93
94		/* Set position/time/length */
95		ES_OUT_PRIV_SET_TIMES, /* arg1=double f_position arg2=vlc_tick_t i_time arg3=vlc_tick_t i_normal_time arg4=vlc_tick_t i_length arg5 int b_live res=cannot fail */
96
97		/* Set jitter */
98		ES_OUT_PRIV_SET_JITTER, /* arg1=vlc_tick_t i_pts_delay arg2= vlc_tick_t i_pts_jitter, arg2=int i_cr_average res=cannot fail */
99
100		/* Get forced group */
101		ES_OUT_PRIV_GET_GROUP_FORCED, /* arg1=int * res=cannot fail */
102
103		/* Set End Of Stream */
104		ES_OUT_PRIV_SET_EOS, /* res=cannot fail */
105
106		/* Set a VBI/Teletext page */
107		ES_OUT_PRIV_SET_VBI_PAGE, /* arg1=unsigned res=can fail */
108
109		/* Set VBI/Teletext menu transparent */
110		ES_OUT_PRIV_SET_VBI_TRANSPARENCY /* arg1=bool res=can fail */
111		};
112
113		struct vlc_input_es_out;
114		struct vlc_input_es_out_ops {
115		int (*priv_control)(
116		struct vlc_input_es_out *out,
117		input_source_t *source,
118		int query,
119		va_list args);
120		};
121
122		struct vlc_input_es_out {
123		es_out_t out;
124
125		const struct vlc_input_es_out_ops *ops;
126		};
127
128		static inline int
129		es_out_vaPrivControl(struct vlc_input_es_out *out, int query, va_list args )
130	0	{
131	0	return out->ops->priv_control(out, NULL, query, args);
132	0	} Unexecuted instantiation: input.c:es_out_vaPrivControl Unexecuted instantiation: es_out.c:es_out_vaPrivControl Unexecuted instantiation: es_out_source.c:es_out_vaPrivControl Unexecuted instantiation: es_out_timeshift.c:es_out_vaPrivControl
133
134		static inline int
135		es_out_PrivControl(struct vlc_input_es_out *out, int query, ...)
136	0	{
137	0	va_list args;
138	0	va_start( args, query );
139	0	int result = es_out_vaPrivControl( out, query, args );
140	0	va_end( args );
141	0	return result;
142	0	} Unexecuted instantiation: input.c:es_out_PrivControl Unexecuted instantiation: es_out.c:es_out_PrivControl Unexecuted instantiation: es_out_source.c:es_out_PrivControl Unexecuted instantiation: es_out_timeshift.c:es_out_PrivControl
143
144		static inline void
145		es_out_SetMode(struct vlc_input_es_out *out, int i_mode)
146	0	{
147	0	int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_MODE, i_mode);
148	0	assert( !i_ret );
149	0	} Unexecuted instantiation: input.c:es_out_SetMode Unexecuted instantiation: es_out.c:es_out_SetMode Unexecuted instantiation: es_out_source.c:es_out_SetMode Unexecuted instantiation: es_out_timeshift.c:es_out_SetMode
150
151		static inline int
152		es_out_SetEs(struct vlc_input_es_out out, vlc_es_id_t id)
153	0	{
154	0	return es_out_PrivControl(out, ES_OUT_PRIV_SET_ES, id);
155	0	} Unexecuted instantiation: input.c:es_out_SetEs Unexecuted instantiation: es_out.c:es_out_SetEs Unexecuted instantiation: es_out_source.c:es_out_SetEs Unexecuted instantiation: es_out_timeshift.c:es_out_SetEs
156
157		static inline int
158		es_out_UnsetEs(struct vlc_input_es_out out, vlc_es_id_t id)
159	0	{
160	0	return es_out_PrivControl(out, ES_OUT_PRIV_UNSET_ES, id);
161	0	} Unexecuted instantiation: input.c:es_out_UnsetEs Unexecuted instantiation: es_out.c:es_out_UnsetEs Unexecuted instantiation: es_out_source.c:es_out_UnsetEs Unexecuted instantiation: es_out_timeshift.c:es_out_UnsetEs
162
163		static inline int
164		es_out_RestartEs(struct vlc_input_es_out out, vlc_es_id_t id)
165	0	{
166	0	return es_out_PrivControl(out, ES_OUT_PRIV_RESTART_ES, id);
167	0	} Unexecuted instantiation: input.c:es_out_RestartEs Unexecuted instantiation: es_out.c:es_out_RestartEs Unexecuted instantiation: es_out_source.c:es_out_RestartEs Unexecuted instantiation: es_out_timeshift.c:es_out_RestartEs
168
169		static inline vlc_tick_t
170		es_out_GetWakeup(struct vlc_input_es_out *out)
171	0	{
172	0	vlc_tick_t i_wu;
173	0	int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_GET_WAKE_UP, &i_wu);
174
175	0	assert( !i_ret );
176	0	return i_wu;
177	0	} Unexecuted instantiation: input.c:es_out_GetWakeup Unexecuted instantiation: es_out.c:es_out_GetWakeup Unexecuted instantiation: es_out_source.c:es_out_GetWakeup Unexecuted instantiation: es_out_timeshift.c:es_out_GetWakeup
178
179		static inline int
180		es_out_SetEsList(struct vlc_input_es_out *out,
181		enum es_format_category_e cat,
182		vlc_es_id_t **ids)
183	0	{
184	0	return es_out_PrivControl(out, ES_OUT_PRIV_SET_ES_LIST, cat, ids);
185	0	} Unexecuted instantiation: input.c:es_out_SetEsList Unexecuted instantiation: es_out.c:es_out_SetEsList Unexecuted instantiation: es_out_source.c:es_out_SetEsList Unexecuted instantiation: es_out_timeshift.c:es_out_SetEsList
186
187		static inline void
188		es_out_SetEsCatIds(struct vlc_input_es_out *out,
189		enum es_format_category_e cat,
190		const char *str_ids)
191	0	{
192	0	int ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_ES_CAT_IDS,
193	0	cat, str_ids);
194	0	assert( ret == VLC_SUCCESS );
195	0	} Unexecuted instantiation: input.c:es_out_SetEsCatIds Unexecuted instantiation: es_out.c:es_out_SetEsCatIds Unexecuted instantiation: es_out_source.c:es_out_SetEsCatIds Unexecuted instantiation: es_out_timeshift.c:es_out_SetEsCatIds
196
197		static inline int
198		es_out_StopAllEs(struct vlc_input_es_out *out,
199		vlc_es_id_t ***context)
200	0	{
201	0	return es_out_PrivControl(out, ES_OUT_PRIV_STOP_ALL_ES, context);
202	0	} Unexecuted instantiation: input.c:es_out_StopAllEs Unexecuted instantiation: es_out.c:es_out_StopAllEs Unexecuted instantiation: es_out_source.c:es_out_StopAllEs Unexecuted instantiation: es_out_timeshift.c:es_out_StopAllEs
203
204		static inline int
205		es_out_StartAllEs(struct vlc_input_es_out out, vlc_es_id_t *context )
206	0	{
207	0	return es_out_PrivControl(out, ES_OUT_PRIV_START_ALL_ES, context);
208	0	} Unexecuted instantiation: input.c:es_out_StartAllEs Unexecuted instantiation: es_out.c:es_out_StartAllEs Unexecuted instantiation: es_out_source.c:es_out_StartAllEs Unexecuted instantiation: es_out_timeshift.c:es_out_StartAllEs
209
210		static inline bool
211		es_out_GetBuffering(struct vlc_input_es_out *out)
212	0	{
213	0	bool b;
214	0	int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_GET_BUFFERING, &b);
215
216	0	assert( !i_ret );
217	0	return b;
218	0	} Unexecuted instantiation: input.c:es_out_GetBuffering Unexecuted instantiation: es_out.c:es_out_GetBuffering Unexecuted instantiation: es_out_source.c:es_out_GetBuffering Unexecuted instantiation: es_out_timeshift.c:es_out_GetBuffering
219
220		static inline bool
221		es_out_IsEmpty(struct vlc_input_es_out *out)
222	0	{
223	0	bool b;
224	0	int i_ret = es_out_Control(&out->out, ES_OUT_IS_EMPTY, &b);
225
226	0	assert( !i_ret );
227	0	return b;
228	0	} Unexecuted instantiation: input.c:es_out_IsEmpty Unexecuted instantiation: es_out.c:es_out_IsEmpty Unexecuted instantiation: es_out_source.c:es_out_IsEmpty Unexecuted instantiation: es_out_timeshift.c:es_out_IsEmpty
229
230		static inline void
231		es_out_SetEsDelay(struct vlc_input_es_out *out,
232		vlc_es_id_t *es,
233		vlc_tick_t i_delay)
234	0	{
235	0	int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_ES_DELAY, es, i_delay);
236	0	assert( !i_ret );
237	0	} Unexecuted instantiation: input.c:es_out_SetEsDelay Unexecuted instantiation: es_out.c:es_out_SetEsDelay Unexecuted instantiation: es_out_source.c:es_out_SetEsDelay Unexecuted instantiation: es_out_timeshift.c:es_out_SetEsDelay
238
239		static inline void
240		es_out_SetDelay(struct vlc_input_es_out *out,
241		int i_cat,
242		vlc_tick_t i_delay)
243	0	{
244	0	int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_DELAY, i_cat, i_delay);
245	0	assert( !i_ret );
246	0	} Unexecuted instantiation: input.c:es_out_SetDelay Unexecuted instantiation: es_out.c:es_out_SetDelay Unexecuted instantiation: es_out_source.c:es_out_SetDelay Unexecuted instantiation: es_out_timeshift.c:es_out_SetDelay
247
248		static inline int
249		es_out_SetRecordState(struct vlc_input_es_out *out,
250		bool b_record,
251		const char *dir_path)
252	0	{
253	0	return es_out_PrivControl(out, ES_OUT_PRIV_SET_RECORD_STATE, b_record, dir_path);
254	0	} Unexecuted instantiation: input.c:es_out_SetRecordState Unexecuted instantiation: es_out.c:es_out_SetRecordState Unexecuted instantiation: es_out_source.c:es_out_SetRecordState Unexecuted instantiation: es_out_timeshift.c:es_out_SetRecordState
255
256		static inline int
257		es_out_SetPauseState(struct vlc_input_es_out *out,
258		bool b_source_paused,
259		bool b_paused,
260		vlc_tick_t i_date)
261	0	{
262	0	return es_out_PrivControl(out, ES_OUT_PRIV_SET_PAUSE_STATE, b_source_paused, b_paused, i_date);
263	0	} Unexecuted instantiation: input.c:es_out_SetPauseState Unexecuted instantiation: es_out.c:es_out_SetPauseState Unexecuted instantiation: es_out_source.c:es_out_SetPauseState Unexecuted instantiation: es_out_timeshift.c:es_out_SetPauseState
264
265		static inline int
266		es_out_SetRate(struct vlc_input_es_out *out, float source_rate, float rate)
267	0	{
268	0	return es_out_PrivControl(out, ES_OUT_PRIV_SET_RATE, source_rate, rate);
269	0	} Unexecuted instantiation: input.c:es_out_SetRate Unexecuted instantiation: es_out.c:es_out_SetRate Unexecuted instantiation: es_out_source.c:es_out_SetRate Unexecuted instantiation: es_out_timeshift.c:es_out_SetRate
270
271		static inline int
272		es_out_SetFrameNext(struct vlc_input_es_out *out )
273	0	{
274	0	return es_out_PrivControl(out, ES_OUT_PRIV_SET_FRAME_NEXT);
275	0	} Unexecuted instantiation: input.c:es_out_SetFrameNext Unexecuted instantiation: es_out.c:es_out_SetFrameNext Unexecuted instantiation: es_out_source.c:es_out_SetFrameNext Unexecuted instantiation: es_out_timeshift.c:es_out_SetFrameNext
276
277		static inline int es_out_SetFramePrevious(struct vlc_input_es_out *out)
278	0	{
279	0	return es_out_PrivControl(out, ES_OUT_PRIV_SET_FRAME_PREVIOUS);
280	0	} Unexecuted instantiation: input.c:es_out_SetFramePrevious Unexecuted instantiation: es_out.c:es_out_SetFramePrevious Unexecuted instantiation: es_out_source.c:es_out_SetFramePrevious Unexecuted instantiation: es_out_timeshift.c:es_out_SetFramePrevious
281
282		static inline void
283		es_out_SetTimes(struct vlc_input_es_out *out, double f_position,
284		vlc_tick_t i_time, vlc_tick_t i_normal_time,
285		vlc_tick_t i_length, bool b_live )
286	0	{
287	0	int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_TIMES, f_position, i_time,
288	0	i_normal_time, i_length, b_live);
289	0	assert( !i_ret );
290	0	} Unexecuted instantiation: input.c:es_out_SetTimes Unexecuted instantiation: es_out.c:es_out_SetTimes Unexecuted instantiation: es_out_source.c:es_out_SetTimes Unexecuted instantiation: es_out_timeshift.c:es_out_SetTimes
291
292		static inline void
293		es_out_SetJitter(struct vlc_input_es_out *out,
294		vlc_tick_t i_pts_delay, vlc_tick_t i_pts_jitter,
295		int i_cr_average)
296	0	{
297	0	int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_JITTER,
298	0	i_pts_delay, i_pts_jitter, i_cr_average);
299	0	assert( !i_ret );
300	0	} Unexecuted instantiation: input.c:es_out_SetJitter Unexecuted instantiation: es_out.c:es_out_SetJitter Unexecuted instantiation: es_out_source.c:es_out_SetJitter Unexecuted instantiation: es_out_timeshift.c:es_out_SetJitter
301
302		static inline int
303		es_out_GetGroupForced(struct vlc_input_es_out *out)
304	0	{
305	0	int i_group;
306	0	int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_GET_GROUP_FORCED, &i_group);
307	0	assert( !i_ret );
308	0	return i_group;
309	0	} Unexecuted instantiation: input.c:es_out_GetGroupForced Unexecuted instantiation: es_out.c:es_out_GetGroupForced Unexecuted instantiation: es_out_source.c:es_out_GetGroupForced Unexecuted instantiation: es_out_timeshift.c:es_out_GetGroupForced
310
311		static inline void
312		es_out_Eos(struct vlc_input_es_out *out)
313	0	{
314	0	int i_ret = es_out_PrivControl(out, ES_OUT_PRIV_SET_EOS);
315	0	assert( !i_ret );
316	0	} Unexecuted instantiation: input.c:es_out_Eos Unexecuted instantiation: es_out.c:es_out_Eos Unexecuted instantiation: es_out_source.c:es_out_Eos Unexecuted instantiation: es_out_timeshift.c:es_out_Eos
317
318		static inline int
319		es_out_SetVbiPage(struct vlc_input_es_out out, vlc_es_id_t id,
320		unsigned page)
321	0	{
322	0	return es_out_PrivControl(out, ES_OUT_PRIV_SET_VBI_PAGE, id, page);
323	0	} Unexecuted instantiation: input.c:es_out_SetVbiPage Unexecuted instantiation: es_out.c:es_out_SetVbiPage Unexecuted instantiation: es_out_source.c:es_out_SetVbiPage Unexecuted instantiation: es_out_timeshift.c:es_out_SetVbiPage
324
325		static inline int
326		es_out_SetVbiTransparency(struct vlc_input_es_out out, vlc_es_id_t id,
327		bool enabled)
328	0	{
329	0	return es_out_PrivControl(out, ES_OUT_PRIV_SET_VBI_TRANSPARENCY, id,
330	0	enabled);
331	0	} Unexecuted instantiation: input.c:es_out_SetVbiTransparency Unexecuted instantiation: es_out.c:es_out_SetVbiTransparency Unexecuted instantiation: es_out_source.c:es_out_SetVbiTransparency Unexecuted instantiation: es_out_timeshift.c:es_out_SetVbiTransparency
332
333		struct vlc_input_es_out *
334		input_EsOutNew(input_thread_t , input_source_t main_source, float rate,
335		enum input_type input_type);
336
337		struct vlc_input_es_out *
338		input_EsOutTimeshiftNew(input_thread_t , struct vlc_input_es_out , float i_rate);
339
340		struct vlc_input_es_out *
341		input_EsOutSourceNew(struct vlc_input_es_out master_out, input_source_t in);
342
343		es_out_id_t vlc_es_id_get_out(vlc_es_id_t id);
344		const input_source_t vlc_es_id_GetSource(vlc_es_id_t id);
345
346		static inline void
347		vlc_input_es_out_Delete(struct vlc_input_es_out *out)
348	0	{
349	0	es_out_Delete(&out->out);
350	0	} Unexecuted instantiation: input.c:vlc_input_es_out_Delete Unexecuted instantiation: es_out.c:vlc_input_es_out_Delete Unexecuted instantiation: es_out_source.c:vlc_input_es_out_Delete Unexecuted instantiation: es_out_timeshift.c:vlc_input_es_out_Delete
351
352		#endif