missing.c 7.94 KB
Newer Older
1 2 3
/*****************************************************************************
 * missing.c: missing libvlccore symbols
 *****************************************************************************
4 5 6
 * Copyright (C) 2008-2011 Rémi Denis-Courmont
 * Copyright (C) 2009-2014 VLC authors and VideoLAN
 *
7
 * Authors: Rémi Denis-Courmont
8 9 10 11 12
 *          Pierre Ynard <linkfanel # yahoo fr>
 *          Toralf Niebuhr <gmthor85 # aim com>
 *          Felix Paul Kühne <fkuehne # videolan org>
 *          Jean-Paul Saman <jpsaman # videolan org>
 *          Antoine Cellerier <dionoea # videolan org>
13
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
14 15 16
 * 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
17 18 19 20
 * (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
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
21 22
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
23
 *
Jean-Baptiste Kempf's avatar
Jean-Baptiste Kempf committed
24 25 26
 * 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.
27 28 29 30 31 32 33 34 35 36
 *****************************************************************************/

/** \file
 * This file contains dummy replacement API for disabled features
 */

#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

37 38
#include <stdnoreturn.h>

39
#include <vlc_common.h>
40
#include <assert.h>
41 42

#ifndef ENABLE_SOUT
43 44
# include <vlc_sout.h>

45
void sdp_AddMedia (struct vlc_memstream *sdp, const char *type, const char *protocol,
46 47 48 49
                    int dport, unsigned pt, bool bw_indep, unsigned bw,
                    const char *ptname, unsigned clockrate, unsigned channels,
                    const char *fmtp)
{
50 51 52 53
    VLC_UNUSED (sdp); VLC_UNUSED (type); VLC_UNUSED (protocol);
    VLC_UNUSED (dport); VLC_UNUSED (pt); VLC_UNUSED (bw_indep);
    VLC_UNUSED (bw); VLC_UNUSED (ptname); VLC_UNUSED (clockrate);
    VLC_UNUSED (channels); VLC_UNUSED (fmtp);
54
    assert (sdp == NULL);
55 56
}

57
void sdp_AddAttribute (struct vlc_memstream *sdp, const char *name, const char *fmt, ...)
58
{
59
    VLC_UNUSED (sdp); VLC_UNUSED (name); VLC_UNUSED (fmt);
60
    assert (sdp == NULL);
61 62
}

63
noreturn int sout_AccessOutControl(sout_access_out_t *out, int query, ...)
64
{
65
    VLC_UNUSED (out); VLC_UNUSED (query);
66
    vlc_assert_unreachable ();
67 68
}

69
noreturn void sout_AccessOutDelete(sout_access_out_t *out)
70
{
71
    VLC_UNUSED (out);
72
    vlc_assert_unreachable ();
73 74 75 76 77 78
}

#undef sout_AccessOutNew
sout_access_out_t *sout_AccessOutNew (vlc_object_t *obj,
                                      const char *access, const char *name)
{
79
    VLC_UNUSED (access); VLC_UNUSED (name);
80 81 82 83
    msg_Err (obj, "Output support not compiled-in!");
    return NULL;
}

84
noreturn ssize_t sout_AccessOutRead(sout_access_out_t *out, block_t *block)
85
{
86
    VLC_UNUSED (out); VLC_UNUSED (block);
87
    vlc_assert_unreachable ();
88 89
}

90
noreturn int sout_AccessOutSeek(sout_access_out_t *out, off_t offset)
91
{
92
    VLC_UNUSED (out); VLC_UNUSED (offset);
93
    vlc_assert_unreachable ();
94 95
}

96
noreturn ssize_t sout_AccessOutWrite(sout_access_out_t *out, block_t *block)
97
{
98
    VLC_UNUSED (out); VLC_UNUSED (block);
99
    vlc_assert_unreachable ();
100 101
}

102 103
#undef sout_AnnounceRegisterSDP
session_descriptor_t *sout_AnnounceRegisterSDP (vlc_object_t *obj,
104
                                                const char *sdp,
Pierre Ynard's avatar
Pierre Ynard committed
105
                                                const char *dst)
106
{
107
    VLC_UNUSED (sdp); VLC_UNUSED (dst);
108
    msg_Err (obj, "SDP export not compiled-in!");
109 110 111
    return NULL;
}

112
#undef sout_AnnounceUnRegister
113 114
noreturn void sout_AnnounceUnRegister(vlc_object_t *obj,
                                      session_descriptor_t *d)
115
{
116
    VLC_UNUSED (obj); VLC_UNUSED (d);
117
    vlc_assert_unreachable ();
118 119
}

120 121 122 123 124 125 126
#undef sout_EncoderCreate
encoder_t *sout_EncoderCreate( vlc_object_t *p_this )
{
    msg_Err (p_this, "Encoding support not compiled-in!");
    return NULL;
}

127 128
noreturn sout_input_t *sout_MuxAddStream(sout_mux_t *mux,
                                         const es_format_t *fmt)
129
{
130
    VLC_UNUSED (mux); VLC_UNUSED (fmt);
131
    vlc_assert_unreachable ();
132 133
}

134
noreturn void sout_MuxDelete(sout_mux_t *mux)
135
{
136
    VLC_UNUSED (mux);
137
    vlc_assert_unreachable ();
138 139
}

140
noreturn void sout_MuxDeleteStream(sout_mux_t *mux, sout_input_t *input)
141
{
142
    VLC_UNUSED (mux); VLC_UNUSED (input);
143
    vlc_assert_unreachable ();
144 145
}

146
noreturn int sout_MuxGetStream(sout_mux_t *mux, unsigned n, vlc_tick_t *date)
147
{
148
    (void) mux; (void) n; (void) date;
149
    vlc_assert_unreachable ();
150 151
}

152 153
noreturn sout_mux_t *sout_MuxNew(sout_instance_t *instance, const char *mux,
                                 sout_access_out_t *out)
154
{
155
    VLC_UNUSED (instance); VLC_UNUSED (mux); VLC_UNUSED (out);
156
    vlc_assert_unreachable ();
157 158
}

159 160
noreturn int sout_MuxSendBuffer(sout_mux_t *mux, sout_input_t *input,
                                block_t *block)
161
{
162
    VLC_UNUSED (mux); VLC_UNUSED (input); VLC_UNUSED (block);
163
    vlc_assert_unreachable ();
164 165
}

166
noreturn void sout_MuxFlush(sout_mux_t *mux, sout_input_t *input)
167 168 169 170 171
{
    VLC_UNUSED (mux); VLC_UNUSED (input);
    vlc_assert_unreachable ();
}

172 173
noreturn void sout_StreamChainDelete(sout_stream_t *first,
                                     sout_stream_t *last)
174
{
175
    (void) first; (void) last;
176
    vlc_assert_unreachable ();
177 178
}

179 180 181 182
noreturn sout_stream_t *sout_StreamChainNew(sout_instance_t *sout,
                                            const char *chain,
                                            sout_stream_t *next,
                                            sout_stream_t **last)
183
{
184
    (void) sout; (void) chain; (void) next; (void) last;
185
    vlc_assert_unreachable ();
186 187
}

188
int vlc_sdp_Start (struct vlc_memstream *sdp, vlc_object_t *obj, const char *cfg,
189 190 191
                     const struct sockaddr *src, size_t srclen,
                     const struct sockaddr *addr, size_t addrlen)
{
192 193
    VLC_UNUSED (obj); VLC_UNUSED (cfg); VLC_UNUSED (src); VLC_UNUSED (srclen);
    VLC_UNUSED (addr); VLC_UNUSED (addrlen);
194
    return 0;
195
}
196
#endif /* !ENABLE_SOUT */
197

198 199
#ifndef ENABLE_VLM
# include <vlc_vlm.h>
200

201
noreturn int vlm_Control(vlm_t *vlm, int query, ...)
202
{
203
    VLC_UNUSED (query);
204
    VLC_UNUSED (vlm);
205
    vlc_assert_unreachable ();
206 207
}

208
noreturn void vlm_Delete(vlm_t *vlm)
209
{
210
    VLC_UNUSED (vlm);
211
    vlc_assert_unreachable ();
212 213
}

214 215
noreturn int vlm_ExecuteCommand(vlm_t *vlm, const char *cmd,
                                vlm_message_t **pm)
216
{
217 218 219
    VLC_UNUSED (vlm);
    VLC_UNUSED (cmd);
    VLC_UNUSED (pm);
220
    vlc_assert_unreachable ();
221 222
}

223
noreturn vlm_message_t *vlm_MessageAdd(vlm_message_t *a, vlm_message_t *b)
224
{
225 226
    VLC_UNUSED (a);
    VLC_UNUSED (b);
227
    vlc_assert_unreachable ();
228 229
}

230
noreturn void vlm_MessageDelete(vlm_message_t *m)
231
{
232
    VLC_UNUSED (m);
233
    vlc_assert_unreachable ();
234 235
}

236
vlm_message_t *vlm_MessageSimpleNew (const char *a)
237
{
238
    VLC_UNUSED (a);
239 240 241
    return NULL;
}

242 243
vlm_message_t *vlm_MessageNew (const char *a, const char *fmt, ...)
{
244 245
    VLC_UNUSED (a);
    VLC_UNUSED (fmt);
246 247 248
    return vlm_MessageSimpleNew (a);
}

249
#undef vlm_New
250
vlm_t *vlm_New (libvlc_int_t *obj, const char *file)
251 252
{
     msg_Err (obj, "VLM not compiled-in!");
253
     (void) file;
254 255
     return NULL;
}
256
#endif /* !ENABLE_VLM */
257 258 259 260 261 262 263 264 265 266

#ifndef UPDATE_CHECK
# include <vlc_update.h>

update_t *(update_New)(vlc_object_t *obj)
{
    (void) obj;
    return NULL;
}

267
noreturn void update_Delete(update_t *u)
268 269 270 271 272
{
    (void) u;
    vlc_assert_unreachable();
}

273
noreturn void update_Check(update_t *u, void (*cb)(void *, bool), void *opaque)
274 275 276 277 278
{
    (void) u; (void) cb; (void) opaque;
    vlc_assert_unreachable();
}

279
noreturn bool update_NeedUpgrade(update_t *u)
280 281 282 283 284
{
    (void) u;
    vlc_assert_unreachable();
}

285
noreturn void update_Download(update_t *u, const char *dir)
286 287 288 289 290
{
    (void) u; (void) dir;
    vlc_assert_unreachable();
}

291
noreturn update_release_t *update_GetRelease(update_t *u)
292 293 294 295 296
{
    (void) u;
    vlc_assert_unreachable();
}
#endif /* !UPDATE_CHECK */