src/missing.c

   1 /*****************************************************************************
   2  * missing.c: missing libvlccore symbols
   3  *****************************************************************************
   4  * Copyright (C) 2008-2011 Rémi Denis-Courmont
   5  * Copyright (C) 2009-2014 VLC authors and VideoLAN
   6  * $Id$
   7  *
   8  * Authors: Rémi Denis-Courmont <rem # videolan : org>
   9  *          Pierre Ynard <linkfanel # yahoo fr>
  10  *          Toralf Niebuhr <gmthor85 # aim com>
  11  *          Felix Paul Kühne <fkuehne # videolan org>
  12  *          Jean-Paul Saman <jpsaman # videolan org>
  13  *          Antoine Cellerier <dionoea # videolan org>
  14  *
  15  * This program is free software; you can redistribute it and/or modify it
  16  * under the terms of the GNU Lesser General Public License as published by
  17  * the Free Software Foundation; either version 2.1 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  23  * GNU Lesser General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU Lesser General Public License
  26  * along with this program; if not, write to the Free Software Foundation,
  27  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  28  *****************************************************************************/
  29
  30 /** \file
  31  * This file contains dummy replacement API for disabled features
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 # include "config.h"
  36 #endif
  37
  38 #include <vlc_common.h>
  39 #include <assert.h>
  40
  41 #ifndef ENABLE_HTTPD
  42 # include <vlc_httpd.h>
  43
  44 char *httpd_ClientIP (const httpd_client_t *cl, char *psz_ip, int *port)
  45 {
  46     (void) cl; (void) psz_ip; (void) port;
  47     vlc_assert_unreachable ();
  48 }
  49
  50 httpd_file_sys_t *httpd_FileDelete (httpd_file_t *file)
  51 {
  52     (void) file;
  53     vlc_assert_unreachable ();
  54 }
  55
  56 httpd_file_t *httpd_FileNew (httpd_host_t *host,
  57                              const char *url, const char *content_type,
  58                              const char *login, const char *password,
  59                              httpd_file_callback_t cb, httpd_file_sys_t *data)
  60 {
  61     (void) host;
  62     (void) url; (void) content_type;
  63     (void) login; (void) password;
  64     (void) cb; (void) data;
  65     vlc_assert_unreachable ();
  66 }
  67
  68 void *httpd_HandlerDelete(httpd_handler_t *handler)
  69 {
  70     (void) handler;
  71     vlc_assert_unreachable ();
  72 }
  73
  74 httpd_handler_t *httpd_HandlerNew(httpd_host_t *host, const char *url,
  75                                   const char *login, const char *password,
  76                                   httpd_handler_callback_t cb,
  77                                   void *data)
  78 {
  79     (void) host; (void) url;
  80     (void) login; (void) password;
  81     (void) cb; (void) data;
  82     vlc_assert_unreachable ();
  83 }
  84
  85 void httpd_HostDelete (httpd_host_t *h)
  86 {
  87     (void) h;
  88     vlc_assert_unreachable ();
  89 }
  90
  91 httpd_host_t *vlc_http_HostNew (vlc_object_t *obj)
  92 {
  93     msg_Err (obj, "HTTP server not compiled-in!");
  94     return NULL;
  95 }
  96
  97 httpd_host_t *vlc_https_HostNew (vlc_object_t *obj)
  98 {
  99     msg_Err (obj, "HTTPS server not compiled-in!");
 100     return NULL;
 101 }
 102
 103 httpd_host_t *vlc_rtsp_HostNew (vlc_object_t *obj)
 104 {
 105     msg_Err (obj, "RTSP server not compiled-in!");
 106     return NULL;
 107 }
 108
 109 void httpd_MsgAdd (httpd_message_t *m, const char *name, const char *fmt, ...)
 110 {
 111     (void) m; (void) name; (void) fmt;
 112     vlc_assert_unreachable ();
 113 }
 114
 115 const char *httpd_MsgGet (const httpd_message_t *m, const char *name)
 116 {
 117     (void) m; (void) name;
 118     vlc_assert_unreachable ();
 119 }
 120
 121 void httpd_RedirectDelete (httpd_redirect_t *r)
 122 {
 123     (void) r;
 124     vlc_assert_unreachable ();
 125 }
 126
 127 httpd_redirect_t *httpd_RedirectNew (httpd_host_t *host,
 128                                      const char *dst, const char *src)
 129 {
 130     (void) host; (void) dst; (void) src;
 131     vlc_assert_unreachable ();
 132 }
 133
 134 char *httpd_ServerIP (const httpd_client_t *client, char *ip, int *port)
 135 {
 136     (void) client; (void) ip; (void) port;
 137     vlc_assert_unreachable ();
 138 }
 139
 140 void httpd_StreamDelete (httpd_stream_t *stream)
 141 {
 142     (void) stream;
 143     vlc_assert_unreachable ();
 144 }
 145
 146 int httpd_StreamHeader (httpd_stream_t *stream, uint8_t *data, int count)
 147 {
 148     (void) stream; (void) data; (void) count;
 149     vlc_assert_unreachable ();
 150 }
 151
 152 httpd_stream_t *httpd_StreamNew (httpd_host_t *host,
 153                                  const char *url, const char *content_type,
 154                                  const char *login, const char *password)
 155 {
 156     (void) host; (void) url; (void) content_type;
 157     (void) login; (void) password;
 158     vlc_assert_unreachable ();
 159 }
 160
 161 int httpd_StreamSend (httpd_stream_t *stream, const block_t *p_block)
 162 {
 163     (void) stream; (void) p_block;
 164     vlc_assert_unreachable ();
 165 }
 166
 167 int httpd_StreamSetHTTPHeaders (httpd_stream_t * stream,
 168                                 httpd_header * headers,
 169                                 size_t i_headers)
 170 {
 171     (void) stream; (void) headers; (void) i_headers;
 172     vlc_assert_unreachable ();
 173 }
 174
 175 int httpd_UrlCatch (httpd_url_t *url, int request, httpd_callback_t cb,
 176                     httpd_callback_sys_t *data)
 177 {
 178     (void) url; (void) request; (void) cb; (void) data;
 179     vlc_assert_unreachable ();
 180 }
 181
 182 void httpd_UrlDelete (httpd_url_t *url)
 183 {
 184     (void) url;
 185     vlc_assert_unreachable ();
 186 }
 187
 188 httpd_url_t *httpd_UrlNew (httpd_host_t *host, const char *url,
 189                            const char *login, const char *password)
 190 {
 191     (void) host; (void) url; (void) login; (void) password;
 192     vlc_assert_unreachable ();
 193 }
 194 #endif /* !ENABLE_HTTPD */
 195
 196 #ifndef ENABLE_SOUT
 197 # include <vlc_sout.h>
 198
 199 void sdp_AddMedia (struct vlc_memstream *sdp, const char *type, const char *protocol,
 200                     int dport, unsigned pt, bool bw_indep, unsigned bw,
 201                     const char *ptname, unsigned clockrate, unsigned channels,
 202                     const char *fmtp)
 203 {
 204     VLC_UNUSED (sdp); VLC_UNUSED (type); VLC_UNUSED (protocol);
 205     VLC_UNUSED (dport); VLC_UNUSED (pt); VLC_UNUSED (bw_indep);
 206     VLC_UNUSED (bw); VLC_UNUSED (ptname); VLC_UNUSED (clockrate);
 207     VLC_UNUSED (channels); VLC_UNUSED (fmtp);
 208     assert (sdp == NULL);
 209 }
 210
 211 void sdp_AddAttribute (struct vlc_memstream *sdp, const char *name, const char *fmt, ...)
 212 {
 213     VLC_UNUSED (sdp); VLC_UNUSED (name); VLC_UNUSED (fmt);
 214     assert (sdp == NULL);
 215 }
 216
 217 int sout_AccessOutControl (sout_access_out_t *out, int query, ...)
 218 {
 219     VLC_UNUSED (out); VLC_UNUSED (query);
 220     vlc_assert_unreachable ();
 221 }
 222
 223 void sout_AccessOutDelete (sout_access_out_t *out)
 224 {
 225     VLC_UNUSED (out);
 226     vlc_assert_unreachable ();
 227 }
 228
 229 #undef sout_AccessOutNew
 230 sout_access_out_t *sout_AccessOutNew (vlc_object_t *obj,
 231                                       const char *access, const char *name)
 232 {
 233     VLC_UNUSED (access); VLC_UNUSED (name);
 234     msg_Err (obj, "Output support not compiled-in!");
 235     return NULL;
 236 }
 237
 238 ssize_t sout_AccessOutRead (sout_access_out_t *out, block_t *block)
 239 {
 240     VLC_UNUSED (out); VLC_UNUSED (block);
 241     vlc_assert_unreachable ();
 242 }
 243
 244 int sout_AccessOutSeek (sout_access_out_t *out, off_t offset)
 245 {
 246     VLC_UNUSED (out); VLC_UNUSED (offset);
 247     vlc_assert_unreachable ();
 248 }
 249
 250 ssize_t sout_AccessOutWrite (sout_access_out_t *out, block_t *block)
 251 {
 252     VLC_UNUSED (out); VLC_UNUSED (block);
 253     vlc_assert_unreachable ();
 254 }
 255
 256 #undef sout_AnnounceRegisterSDP
 257 session_descriptor_t *sout_AnnounceRegisterSDP (vlc_object_t *obj,
 258                                                 const char *sdp,
 259                                                 const char *dst)
 260 {
 261     VLC_UNUSED (sdp); VLC_UNUSED (dst);
 262     msg_Err (obj, "SDP export not compiled-in!");
 263     return NULL;
 264 }
 265
 266 #undef sout_AnnounceUnRegister
 267 void sout_AnnounceUnRegister (vlc_object_t *obj, session_descriptor_t *d)
 268 {
 269     VLC_UNUSED (obj); VLC_UNUSED (d);
 270     vlc_assert_unreachable ();
 271 }
 272
 273 #undef sout_EncoderCreate
 274 encoder_t *sout_EncoderCreate( vlc_object_t *p_this )
 275 {
 276     msg_Err (p_this, "Encoding support not compiled-in!");
 277     return NULL;
 278 }
 279
 280 sout_input_t *sout_MuxAddStream( sout_mux_t *mux, const es_format_t *fmt )
 281 {
 282     VLC_UNUSED (mux); VLC_UNUSED (fmt);
 283     vlc_assert_unreachable ();
 284 }
 285
 286 void sout_MuxDelete (sout_mux_t *mux)
 287 {
 288     VLC_UNUSED (mux);
 289     vlc_assert_unreachable ();
 290 }
 291
 292 void sout_MuxDeleteStream (sout_mux_t *mux, sout_input_t *input)
 293 {
 294     VLC_UNUSED (mux); VLC_UNUSED (input);
 295     vlc_assert_unreachable ();
 296 }
 297
 298 int sout_MuxGetStream (sout_mux_t *p_mux, unsigned int i_blocks, mtime_t *pi_dts)
 299 {
 300     VLC_UNUSED (p_mux); VLC_UNUSED (i_blocks); VLC_UNUSED (pi_dts);
 301     vlc_assert_unreachable ();
 302 }
 303
 304 sout_mux_t *sout_MuxNew (sout_instance_t *instance, const char *mux,
 305                          sout_access_out_t *out)
 306 {
 307     VLC_UNUSED (instance); VLC_UNUSED (mux); VLC_UNUSED (out);
 308     vlc_assert_unreachable ();
 309 }
 310
 311 int sout_MuxSendBuffer (sout_mux_t *mux, sout_input_t *input, block_t *block)
 312 {
 313     VLC_UNUSED (mux); VLC_UNUSED (input); VLC_UNUSED (block);
 314     vlc_assert_unreachable ();
 315 }
 316
 317 void sout_MuxFlush( sout_mux_t *mux, sout_input_t *input )
 318 {
 319     VLC_UNUSED (mux); VLC_UNUSED (input);
 320     vlc_assert_unreachable ();
 321 }
 322
 323 void sout_StreamChainDelete (sout_stream_t *p_first, sout_stream_t *p_last)
 324 {
 325     VLC_UNUSED (p_first); VLC_UNUSED (p_last);
 326     vlc_assert_unreachable ();
 327 }
 328
 329 sout_stream_t *sout_StreamChainNew (sout_instance_t *p_sout, const char *psz_chain,
 330                                     sout_stream_t *p_next,
 331                                     sout_stream_t **pp_last)
 332 {
 333     VLC_UNUSED (p_sout); VLC_UNUSED (psz_chain); VLC_UNUSED (p_next);
 334     VLC_UNUSED (pp_last);
 335     vlc_assert_unreachable ();
 336 }
 337
 338 int vlc_sdp_Start (struct vlc_memstream *sdp, vlc_object_t *obj, const char *cfg,
 339                      const struct sockaddr *src, size_t srclen,
 340                      const struct sockaddr *addr, size_t addrlen)
 341 {
 342     VLC_UNUSED (obj); VLC_UNUSED (cfg); VLC_UNUSED (src); VLC_UNUSED (srclen);
 343     VLC_UNUSED (addr); VLC_UNUSED (addrlen);
 344     return 0;
 345 }
 346 #endif /* !ENABLE_SOUT */
 347
 348 #ifndef ENABLE_VLM
 349 # include <vlc_vlm.h>
 350
 351 int vlm_Control (vlm_t *vlm, int query, ...)
 352 {
 353     VLC_UNUSED (query);
 354     VLC_UNUSED (vlm);
 355     vlc_assert_unreachable ();
 356 }
 357
 358 void vlm_Delete (vlm_t *vlm)
 359 {
 360     VLC_UNUSED (vlm);
 361     vlc_assert_unreachable ();
 362 }
 363
 364 int vlm_ExecuteCommand (vlm_t *vlm, const char *cmd, vlm_message_t **pm)
 365 {
 366     VLC_UNUSED (vlm);
 367     VLC_UNUSED (cmd);
 368     VLC_UNUSED (pm);
 369     vlc_assert_unreachable ();
 370 }
 371
 372 vlm_message_t *vlm_MessageAdd (vlm_message_t *a, vlm_message_t *b)
 373 {
 374     VLC_UNUSED (a);
 375     VLC_UNUSED (b);
 376     vlc_assert_unreachable ();
 377 }
 378
 379 void vlm_MessageDelete (vlm_message_t *m)
 380 {
 381     VLC_UNUSED (m);
 382     vlc_assert_unreachable ();
 383 }
 384
 385 vlm_message_t *vlm_MessageSimpleNew (const char *a)
 386 {
 387     VLC_UNUSED (a);
 388     return NULL;
 389 }
 390
 391 vlm_message_t *vlm_MessageNew (const char *a, const char *fmt, ...)
 392 {
 393     VLC_UNUSED (a);
 394     VLC_UNUSED (fmt);
 395     return vlm_MessageSimpleNew (a);
 396 }
 397
 398 #undef vlm_New
 399 vlm_t *vlm_New (vlc_object_t *obj)
 400 {
 401      msg_Err (obj, "VLM not compiled-in!");
 402      return NULL;
 403 }
 404 #endif /* !ENABLE_VLM */
 405
 406 #ifndef UPDATE_CHECK
 407 # include <vlc_update.h>
 408
 409 update_t *(update_New)(vlc_object_t *obj)
 410 {
 411     (void) obj;
 412     return NULL;
 413 }
 414
 415 void update_Delete(update_t *u)
 416 {
 417     (void) u;
 418     vlc_assert_unreachable();
 419 }
 420
 421 void update_Check(update_t *u, void (*cb)(void *, bool), void *opaque)
 422 {
 423     (void) u; (void) cb; (void) opaque;
 424     vlc_assert_unreachable();
 425 }
 426
 427 bool update_NeedUpgrade(update_t *u)
 428 {
 429     (void) u;
 430     vlc_assert_unreachable();
 431 }
 432
 433 void update_Download(update_t *u, const char *dir)
 434 {
 435     (void) u; (void) dir;
 436     vlc_assert_unreachable();
 437 }
 438
 439 update_release_t *update_GetRelease(update_t *u)
 440 {
 441     (void) u;
 442     vlc_assert_unreachable();
 443 }
 444 #endif /* !UPDATE_CHECK */