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_candidates_prepared(struct sipe_backend_media *media)
 138 {
 139         _NIF();
 140         return FALSE;
 141 }
 142
 143 GList *
 144 sipe_backend_media_get_active_local_candidates(struct sipe_backend_media *media,
 145                                                struct sipe_backend_stream *stream)
 146 {
 147         _NIF();
 148         return NULL;
 149 }
 150
 151 GList *
 152 sipe_backend_media_get_active_remote_candidates(struct sipe_backend_media *media,
 153                                                 struct sipe_backend_stream *stream)
 154 {
 155         _NIF();
 156         return NULL;
 157 }
 158
 159 gchar *
 160 sipe_backend_stream_get_id(struct sipe_backend_stream *stream)
 161 {
 162         _NIF();
 163         return NULL;
 164 }
 165
 166 void sipe_backend_stream_hold(struct sipe_backend_media *media,
 167                               struct sipe_backend_stream *stream,
 168                               gboolean local)
 169 {
 170         _NIF();
 171 }
 172
 173 void sipe_backend_stream_unhold(struct sipe_backend_media *media,
 174                                 struct sipe_backend_stream *stream,
 175                                 gboolean local)
 176 {
 177         _NIF();
 178 }
 179
 180 gboolean sipe_backend_stream_is_held(struct sipe_backend_stream *stream)
 181 {
 182         _NIF();
 183         return FALSE;
 184 }
 185
 186 struct sipe_backend_codec *
 187 sipe_backend_codec_new(int id, const char *name, SipeMediaType type, guint clock_rate)
 188 {
 189         _NIF();
 190         return NULL;
 191 }
 192
 193 void
 194 sipe_backend_codec_free(struct sipe_backend_codec *codec)
 195 {
 196         _NIF();
 197 }
 198
 199 int
 200 sipe_backend_codec_get_id(struct sipe_backend_codec *codec)
 201 {
 202         _NIF();
 203         return 0;
 204 }
 205
 206 gchar *
 207 sipe_backend_codec_get_name(struct sipe_backend_codec *codec)
 208 {
 209         _NIF();
 210         return NULL;
 211 }
 212
 213 guint
 214 sipe_backend_codec_get_clock_rate(struct sipe_backend_codec *codec)
 215 {
 216         _NIF();
 217         return 0;
 218 }
 219
 220 void
 221 sipe_backend_codec_add_optional_parameter(struct sipe_backend_codec *codec,
 222                                           const gchar *name, const gchar *value)
 223 {
 224         _NIF();
 225 }
 226
 227 GList *
 228 sipe_backend_codec_get_optional_parameters(struct sipe_backend_codec *codec)
 229 {
 230         _NIF();
 231         return NULL;
 232 }
 233
 234 gboolean
 235 sipe_backend_set_remote_codecs(struct sipe_backend_media *media,
 236                                struct sipe_backend_stream *stream,
 237                                GList *codecs)
 238 {
 239         _NIF();
 240         return FALSE;
 241 }
 242
 243 GList*
 244 sipe_backend_get_local_codecs(struct sipe_backend_media *media,
 245                               struct sipe_backend_stream *stream)
 246 {
 247         _NIF();
 248         return NULL;
 249 }
 250
 251 struct sipe_backend_candidate *
 252 sipe_backend_candidate_new(const gchar *foundation,
 253                            SipeComponentType component,
 254                            SipeCandidateType type, SipeNetworkProtocol proto,
 255                            const gchar *ip, guint port,
 256                            const gchar *username,
 257                            const gchar *password)
 258 {
 259         _NIF();
 260         return NULL;
 261 }
 262
 263 void
 264 sipe_backend_candidate_free(struct sipe_backend_candidate *candidate)
 265 {
 266         _NIF();
 267 }
 268
 269 gchar *
 270 sipe_backend_candidate_get_username(struct sipe_backend_candidate *candidate)
 271 {
 272         _NIF();
 273         return NULL;
 274 }
 275
 276 gchar *
 277 sipe_backend_candidate_get_password(struct sipe_backend_candidate *candidate)
 278 {
 279         _NIF();
 280         return NULL;
 281 }
 282
 283 gchar *
 284 sipe_backend_candidate_get_foundation(struct sipe_backend_candidate *candidate)
 285 {
 286         _NIF();
 287         return NULL;
 288 }
 289
 290 gchar *
 291 sipe_backend_candidate_get_ip(struct sipe_backend_candidate *candidate)
 292 {
 293         _NIF();
 294         return NULL;
 295 }
 296
 297 guint
 298 sipe_backend_candidate_get_port(struct sipe_backend_candidate *candidate)
 299 {
 300         _NIF();
 301         return 0;
 302 }
 303
 304 gchar *
 305 sipe_backend_candidate_get_base_ip(struct sipe_backend_candidate *candidate)
 306 {
 307         _NIF();
 308         return FALSE;
 309 }
 310
 311 guint
 312 sipe_backend_candidate_get_base_port(struct sipe_backend_candidate *candidate)
 313 {
 314         _NIF();
 315         return 0;
 316 }
 317
 318 guint32
 319 sipe_backend_candidate_get_priority(struct sipe_backend_candidate *candidate)
 320 {
 321         _NIF();
 322         return 0;
 323 }
 324
 325 void
 326 sipe_backend_candidate_set_priority(struct sipe_backend_candidate *candidate, guint32 priority)
 327 {
 328         _NIF();
 329 }
 330
 331 SipeComponentType
 332 sipe_backend_candidate_get_component_type(struct sipe_backend_candidate *candidate)
 333 {
 334         _NIF();
 335         return SIPE_COMPONENT_NONE;
 336 }
 337
 338 SipeCandidateType
 339 sipe_backend_candidate_get_type(struct sipe_backend_candidate *candidate)
 340 {
 341         _NIF();
 342         return SIPE_CANDIDATE_TYPE_ANY;
 343 }
 344
 345 SipeNetworkProtocol
 346 sipe_backend_candidate_get_protocol(struct sipe_backend_candidate *candidate)
 347 {
 348         _NIF();
 349         return SIPE_NETWORK_PROTOCOL_TCP_ACTIVE;
 350 }
 351
 352 GList *
 353 sipe_backend_get_local_candidates(struct sipe_backend_media *media,
 354                                   struct sipe_backend_stream *stream)
 355 {
 356         _NIF();
 357         return FALSE;
 358 }
 359
 360 void
 361 sipe_backend_media_accept(struct sipe_backend_media *media, gboolean local)
 362 {
 363         _NIF();
 364 }
 365
 366 void
 367 sipe_backend_media_hangup(struct sipe_backend_media *media, gboolean local)
 368 {
 369         _NIF();
 370 }
 371
 372 void
 373 sipe_backend_media_reject(struct sipe_backend_media *media, gboolean local)
 374 {
 375         _NIF();
 376 }
 377
 378 /*
 379   Local Variables:
 380   mode: c
 381   c-file-style: "bsd"
 382   indent-tabs-mode: t
 383   tab-width: 8
 384   End:
 385 */