src/miranda/miranda-media.c

   1 /**
   2  * @file miranda-media.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010-11 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <windows.h>
  24 #include <stdio.h>
  25
  26 #include <glib.h>
  27
  28 #include "newpluginapi.h"
  29 #include "m_protosvc.h"
  30 #include "m_protoint.h"
  31
  32 #include "sipe-common.h"
  33 #include "sipe-backend.h"
  34 #include "sipe-core.h"
  35 #include "miranda-private.h"
  36
  37 struct sipe_backend_media {
  38         int dummy;
  39 };
  40
  41 struct sipe_backend_stream {
  42         int dummy;
  43 };
  44
  45 struct sipe_backend_media *
  46 sipe_backend_media_new(struct sipe_core_public *sipe_public,
  47                        struct sipe_media_call *call,
  48                        const gchar *participant,
  49                        gboolean initiator)
  50 {
  51         struct sipe_backend_media *m = g_new0(struct sipe_backend_media,1);
  52
  53         return m;
  54 }
  55
  56 void
  57 sipe_backend_media_free(struct sipe_backend_media *media)
  58 {
  59         _NIF();
  60 }
  61
  62 void
  63 sipe_backend_media_set_cname(struct sipe_backend_media *media, gchar *cname)
  64 {
  65         _NIF();
  66 }
  67
  68 struct sipe_backend_media_relays *
  69 sipe_backend_media_relays_convert(GSList *media_relays, gchar *username, gchar *password)
  70 {
  71         _NIF();
  72         return NULL;
  73 }
  74
  75 void
  76 sipe_backend_media_relays_free(struct sipe_backend_media_relays *media_relays)
  77 {
  78         _NIF();
  79 }
  80
  81 struct sipe_backend_stream *
  82 sipe_backend_media_add_stream(struct sipe_backend_media *media,
  83                               const gchar *id,
  84                               const gchar *participant,
  85                               SipeMediaType type,
  86                               SipeIceVersion ice_version,
  87                               gboolean initiator,
  88                               struct sipe_backend_media_relays *media_relays)
  89 {
  90         _NIF();
  91         return NULL;
  92 }
  93
  94 void
  95 sipe_backend_media_remove_stream(struct sipe_backend_media *media,
  96                                  struct sipe_backend_stream *stream)
  97 {
  98         _NIF();
  99 }
 100
 101 GSList *sipe_backend_media_get_streams(struct sipe_backend_media *media)
 102 {
 103         _NIF();
 104         return NULL;
 105 }
 106
 107 struct sipe_backend_stream *
 108 sipe_backend_media_get_stream_by_id(struct sipe_backend_media *media,
 109                                     const gchar *id)
 110 {
 111         _NIF();
 112         return NULL;
 113 }
 114
 115 void
 116 sipe_backend_media_add_remote_candidates(struct sipe_backend_media *media,
 117                                          struct sipe_backend_stream *stream,
 118                                          GList *candidates)
 119 {
 120         _NIF();
 121 }
 122
 123 gboolean sipe_backend_media_is_initiator(struct sipe_backend_media *media,
 124                                          struct sipe_backend_stream *stream)
 125 {
 126         _NIF();
 127         return FALSE;
 128 }
 129
 130 gboolean sipe_backend_media_accepted(struct sipe_backend_media *media)
 131 {
 132         _NIF();
 133         return FALSE;
 134 }
 135
 136 gboolean
 137 sipe_backend_stream_initialized(struct sipe_backend_media *media,
 138                                 struct sipe_backend_stream *stream)
 139 {
 140         _NIF();
 141         return FALSE;
 142 }
 143
 144 GList *
 145 sipe_backend_media_get_active_local_candidates(struct sipe_backend_media *media,
 146                                                struct sipe_backend_stream *stream)
 147 {
 148         _NIF();
 149         return NULL;
 150 }
 151
 152 GList *
 153 sipe_backend_media_get_active_remote_candidates(struct sipe_backend_media *media,
 154                                                 struct sipe_backend_stream *stream)
 155 {
 156         _NIF();
 157         return NULL;
 158 }
 159
 160 const gchar *
 161 sipe_backend_stream_get_id(struct sipe_backend_stream *stream)
 162 {
 163         _NIF();
 164         return NULL;
 165 }
 166
 167 void sipe_backend_stream_hold(struct sipe_backend_media *media,
 168                               struct sipe_backend_stream *stream,
 169                               gboolean local)
 170 {
 171         _NIF();
 172 }
 173
 174 void sipe_backend_stream_unhold(struct sipe_backend_media *media,
 175                                 struct sipe_backend_stream *stream,
 176                                 gboolean local)
 177 {
 178         _NIF();
 179 }
 180
 181 gboolean sipe_backend_stream_is_held(struct sipe_backend_stream *stream)
 182 {
 183         _NIF();
 184         return FALSE;
 185 }
 186
 187 struct sipe_backend_codec *
 188 sipe_backend_codec_new(int id, const char *name, SipeMediaType type, guint clock_rate)
 189 {
 190         _NIF();
 191         return NULL;
 192 }
 193
 194 void
 195 sipe_backend_codec_free(struct sipe_backend_codec *codec)
 196 {
 197         _NIF();
 198 }
 199
 200 int
 201 sipe_backend_codec_get_id(struct sipe_backend_codec *codec)
 202 {
 203         _NIF();
 204         return 0;
 205 }
 206
 207 gchar *
 208 sipe_backend_codec_get_name(struct sipe_backend_codec *codec)
 209 {
 210         _NIF();
 211         return NULL;
 212 }
 213
 214 guint
 215 sipe_backend_codec_get_clock_rate(struct sipe_backend_codec *codec)
 216 {
 217         _NIF();
 218         return 0;
 219 }
 220
 221 void
 222 sipe_backend_codec_add_optional_parameter(struct sipe_backend_codec *codec,
 223                                           const gchar *name, const gchar *value)
 224 {
 225         _NIF();
 226 }
 227
 228 GList *
 229 sipe_backend_codec_get_optional_parameters(struct sipe_backend_codec *codec)
 230 {
 231         _NIF();
 232         return NULL;
 233 }
 234
 235 gboolean
 236 sipe_backend_set_remote_codecs(struct sipe_backend_media *media,
 237                                struct sipe_backend_stream *stream,
 238                                GList *codecs)
 239 {
 240         _NIF();
 241         return FALSE;
 242 }
 243
 244 GList*
 245 sipe_backend_get_local_codecs(struct sipe_backend_media *media,
 246                               struct sipe_backend_stream *stream)
 247 {
 248         _NIF();
 249         return NULL;
 250 }
 251
 252 struct sipe_backend_candidate *
 253 sipe_backend_candidate_new(const gchar *foundation,
 254                            SipeComponentType component,
 255                            SipeCandidateType type, SipeNetworkProtocol proto,
 256                            const gchar *ip, guint port,
 257                            const gchar *username,
 258                            const gchar *password)
 259 {
 260         _NIF();
 261         return NULL;
 262 }
 263
 264 void
 265 sipe_backend_candidate_free(struct sipe_backend_candidate *candidate)
 266 {
 267         _NIF();
 268 }
 269
 270 gchar *
 271 sipe_backend_candidate_get_username(struct sipe_backend_candidate *candidate)
 272 {
 273         _NIF();
 274         return NULL;
 275 }
 276
 277 gchar *
 278 sipe_backend_candidate_get_password(struct sipe_backend_candidate *candidate)
 279 {
 280         _NIF();
 281         return NULL;
 282 }
 283
 284 gchar *
 285 sipe_backend_candidate_get_foundation(struct sipe_backend_candidate *candidate)
 286 {
 287         _NIF();
 288         return NULL;
 289 }
 290
 291 gchar *
 292 sipe_backend_candidate_get_ip(struct sipe_backend_candidate *candidate)
 293 {
 294         _NIF();
 295         return NULL;
 296 }
 297
 298 guint
 299 sipe_backend_candidate_get_port(struct sipe_backend_candidate *candidate)
 300 {
 301         _NIF();
 302         return 0;
 303 }
 304
 305 gchar *
 306 sipe_backend_candidate_get_base_ip(struct sipe_backend_candidate *candidate)
 307 {
 308         _NIF();
 309         return FALSE;
 310 }
 311
 312 guint
 313 sipe_backend_candidate_get_base_port(struct sipe_backend_candidate *candidate)
 314 {
 315         _NIF();
 316         return 0;
 317 }
 318
 319 guint32
 320 sipe_backend_candidate_get_priority(struct sipe_backend_candidate *candidate)
 321 {
 322         _NIF();
 323         return 0;
 324 }
 325
 326 void
 327 sipe_backend_candidate_set_priority(struct sipe_backend_candidate *candidate, guint32 priority)
 328 {
 329         _NIF();
 330 }
 331
 332 SipeComponentType
 333 sipe_backend_candidate_get_component_type(struct sipe_backend_candidate *candidate)
 334 {
 335         _NIF();
 336         return SIPE_COMPONENT_NONE;
 337 }
 338
 339 SipeCandidateType
 340 sipe_backend_candidate_get_type(struct sipe_backend_candidate *candidate)
 341 {
 342         _NIF();
 343         return SIPE_CANDIDATE_TYPE_ANY;
 344 }
 345
 346 SipeNetworkProtocol
 347 sipe_backend_candidate_get_protocol(struct sipe_backend_candidate *candidate)
 348 {
 349         _NIF();
 350         return SIPE_NETWORK_PROTOCOL_TCP_ACTIVE;
 351 }
 352
 353 GList *
 354 sipe_backend_get_local_candidates(struct sipe_backend_media *media,
 355                                   struct sipe_backend_stream *stream)
 356 {
 357         _NIF();
 358         return FALSE;
 359 }
 360
 361 void
 362 sipe_backend_media_accept(struct sipe_backend_media *media, gboolean local)
 363 {
 364         _NIF();
 365 }
 366
 367 void
 368 sipe_backend_media_hangup(struct sipe_backend_media *media, gboolean local)
 369 {
 370         _NIF();
 371 }
 372
 373 void
 374 sipe_backend_media_reject(struct sipe_backend_media *media, gboolean local)
 375 {
 376         _NIF();
 377 }
 378
 379 /*
 380   Local Variables:
 381   mode: c
 382   c-file-style: "bsd"
 383   indent-tabs-mode: t
 384   tab-width: 8
 385   End:
 386 */