main/abstract_jb.c

   1 /*
   2  * abstract_jb: common implementation-independent jitterbuffer stuff
   3  *
   4  * Copyright (C) 2005, Attractel OOD
   5  *
   6  * Contributors:
   7  * Slav Klenov <slav@securax.org>
   8  *
   9  * See http://www.asterisk.org for more information about
  10  * the Asterisk project. Please do not directly contact
  11  * any of the maintainers of this project for assistance;
  12  * the project provides a web site, mailing lists and IRC
  13  * channels for your use.
  14  *
  15  * This program is free software, distributed under the terms of
  16  * the GNU General Public License Version 2. See the LICENSE file
  17  * at the top of the source tree.
  18  *
  19  * A license has been granted to Digium (via disclaimer) for the use of
  20  * this code.
  21  */
  22
  23 /*! \file
  24  *
  25  * \brief Common implementation-independent jitterbuffer stuff.
  26  *
  27  * \author Slav Klenov <slav@securax.org>
  28  */
  29
  30 #include "asterisk.h"
  31
  32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  33
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36
  37 #include "asterisk/frame.h"
  38 #include "asterisk/channel.h"
  39 #include "asterisk/logger.h"
  40 #include "asterisk/term.h"
  41 #include "asterisk/options.h"
  42 #include "asterisk/utils.h"
  43
  44 #include "asterisk/abstract_jb.h"
  45 #include "fixedjitterbuf.h"
  46 #include "jitterbuf.h"
  47
  48 /*! Internal jb flags */
  49 enum {
  50         JB_USE =                  (1 << 0),
  51         JB_TIMEBASE_INITIALIZED = (1 << 1),
  52         JB_CREATED =              (1 << 2)
  53 };
  54
  55 /* Hooks for the abstract jb implementation */
  56
  57 /*! \brief Create */
  58 typedef void * (*jb_create_impl)(struct ast_jb_conf *general_config, long resynch_threshold);
  59 /*! \brief Destroy */
  60 typedef void (*jb_destroy_impl)(void *jb);
  61 /*! \brief Put first frame */
  62 typedef int (*jb_put_first_impl)(void *jb, struct ast_frame *fin, long now);
  63 /*! \brief Put frame */
  64 typedef int (*jb_put_impl)(void *jb, struct ast_frame *fin, long now);
  65 /*! \brief Get frame for now */
  66 typedef int (*jb_get_impl)(void *jb, struct ast_frame **fout, long now, long interpl);
  67 /*! \brief Get next */
  68 typedef long (*jb_next_impl)(void *jb);
  69 /*! \brief Remove first frame */
  70 typedef int (*jb_remove_impl)(void *jb, struct ast_frame **fout);
  71 /*! \brief Force resynch */
  72 typedef void (*jb_force_resynch_impl)(void *jb);
  73 /*! \brief Empty and reset jb */
  74 typedef void (*jb_empty_and_reset_impl)(void *jb);
  75
  76 /*!
  77  * \brief Jitterbuffer implementation private struct.
  78  */
  79 struct ast_jb_impl
  80 {
  81         char name[AST_JB_IMPL_NAME_SIZE];
  82         jb_create_impl create;
  83         jb_destroy_impl destroy;
  84         jb_put_first_impl put_first;
  85         jb_put_impl put;
  86         jb_get_impl get;
  87         jb_next_impl next;
  88         jb_remove_impl remove;
  89         jb_force_resynch_impl force_resync;
  90         jb_empty_and_reset_impl empty_and_reset;
  91 };
  92
  93 /* Implementation functions */
  94 /* fixed */
  95 static void * jb_create_fixed(struct ast_jb_conf *general_config, long resynch_threshold);
  96 static void jb_destroy_fixed(void *jb);
  97 static int jb_put_first_fixed(void *jb, struct ast_frame *fin, long now);
  98 static int jb_put_fixed(void *jb, struct ast_frame *fin, long now);
  99 static int jb_get_fixed(void *jb, struct ast_frame **fout, long now, long interpl);
 100 static long jb_next_fixed(void *jb);
 101 static int jb_remove_fixed(void *jb, struct ast_frame **fout);
 102 static void jb_force_resynch_fixed(void *jb);
 103 static void jb_empty_and_reset_fixed(void *jb);
 104 /* adaptive */
 105 static void * jb_create_adaptive(struct ast_jb_conf *general_config, long resynch_threshold);
 106 static void jb_destroy_adaptive(void *jb);
 107 static int jb_put_first_adaptive(void *jb, struct ast_frame *fin, long now);
 108 static int jb_put_adaptive(void *jb, struct ast_frame *fin, long now);
 109 static int jb_get_adaptive(void *jb, struct ast_frame **fout, long now, long interpl);
 110 static long jb_next_adaptive(void *jb);
 111 static int jb_remove_adaptive(void *jb, struct ast_frame **fout);
 112 static void jb_force_resynch_adaptive(void *jb);
 113 static void jb_empty_and_reset_adaptive(void *jb);
 114
 115 /* Available jb implementations */
 116 static struct ast_jb_impl avail_impl[] =
 117 {
 118         {
 119                 .name = "fixed",
 120                 .create = jb_create_fixed,
 121                 .destroy = jb_destroy_fixed,
 122                 .put_first = jb_put_first_fixed,
 123                 .put = jb_put_fixed,
 124                 .get = jb_get_fixed,
 125                 .next = jb_next_fixed,
 126                 .remove = jb_remove_fixed,
 127                 .force_resync = jb_force_resynch_fixed,
 128                 .empty_and_reset = jb_empty_and_reset_fixed,
 129         },
 130         {
 131                 .name = "adaptive",
 132                 .create = jb_create_adaptive,
 133                 .destroy = jb_destroy_adaptive,
 134                 .put_first = jb_put_first_adaptive,
 135                 .put = jb_put_adaptive,
 136                 .get = jb_get_adaptive,
 137                 .next = jb_next_adaptive,
 138                 .remove = jb_remove_adaptive,
 139                 .force_resync = jb_force_resynch_adaptive,
 140                 .empty_and_reset = jb_empty_and_reset_adaptive,
 141         }
 142 };
 143
 144 static int default_impl = 0;
 145
 146
 147 /*! Abstract return codes */
 148 enum {
 149         JB_IMPL_OK,
 150         JB_IMPL_DROP,
 151         JB_IMPL_INTERP,
 152         JB_IMPL_NOFRAME
 153 };
 154
 155 /* Translations between impl and abstract return codes */
 156 static int fixed_to_abstract_code[] =
 157         {JB_IMPL_OK, JB_IMPL_DROP, JB_IMPL_INTERP, JB_IMPL_NOFRAME};
 158 static int adaptive_to_abstract_code[] =
 159         {JB_IMPL_OK, JB_IMPL_NOFRAME, JB_IMPL_NOFRAME, JB_IMPL_INTERP, JB_IMPL_DROP, JB_IMPL_OK};
 160
 161 /* JB_GET actions (used only for the frames log) */
 162 static char *jb_get_actions[] = {"Delivered", "Dropped", "Interpolated", "No"};
 163
 164 /*! \brief Macros for the frame log files */
 165 #define jb_framelog(...) do { \
 166         if (jb->logfile) { \
 167                 fprintf(jb->logfile, __VA_ARGS__); \
 168                 fflush(jb->logfile); \
 169         } \
 170 } while (0)
 171
 172
 173 /* Internal utility functions */
 174 static void jb_choose_impl(struct ast_channel *chan);
 175 static void jb_get_and_deliver(struct ast_channel *chan);
 176 static int create_jb(struct ast_channel *chan, struct ast_frame *first_frame);
 177 static long get_now(struct ast_jb *jb, struct timeval *tv);
 178
 179
 180 /* Interface ast jb functions impl */
 181
 182
 183 static void jb_choose_impl(struct ast_channel *chan)
 184 {
 185         struct ast_jb *jb = &chan->jb;
 186         struct ast_jb_conf *jbconf = &jb->conf;
 187         struct ast_jb_impl *test_impl;
 188         int i, avail_impl_count = sizeof(avail_impl) / sizeof(avail_impl[0]);
 189
 190         jb->impl = &avail_impl[default_impl];
 191
 192         if (ast_strlen_zero(jbconf->impl))
 193                 return;
 194
 195         for (i = 0; i < avail_impl_count; i++) {
 196                 test_impl = &avail_impl[i];
 197                 if (!strcasecmp(jbconf->impl, test_impl->name)) {
 198                         jb->impl = test_impl;
 199                         return;
 200                 }
 201         }
 202 }
 203
 204 int ast_jb_do_usecheck(struct ast_channel *c0, struct ast_channel *c1)
 205 {
 206         struct ast_jb *jb0 = &c0->jb;
 207         struct ast_jb *jb1 = &c1->jb;
 208         struct ast_jb_conf *conf0 = &jb0->conf;
 209         struct ast_jb_conf *conf1 = &jb1->conf;
 210         int c0_wants_jitter = c0->tech->properties & AST_CHAN_TP_WANTSJITTER;
 211         int c0_creates_jitter = c0->tech->properties & AST_CHAN_TP_CREATESJITTER;
 212         int c0_jb_enabled = ast_test_flag(conf0, AST_JB_ENABLED);
 213         int c0_force_jb = ast_test_flag(conf0, AST_JB_FORCED);
 214         int c0_jb_timebase_initialized = ast_test_flag(jb0, JB_TIMEBASE_INITIALIZED);
 215         int c0_jb_created = ast_test_flag(jb0, JB_CREATED);
 216         int c1_wants_jitter = c1->tech->properties & AST_CHAN_TP_WANTSJITTER;
 217         int c1_creates_jitter = c1->tech->properties & AST_CHAN_TP_CREATESJITTER;
 218         int c1_jb_enabled = ast_test_flag(conf1, AST_JB_ENABLED);
 219         int c1_force_jb = ast_test_flag(conf1, AST_JB_FORCED);
 220         int c1_jb_timebase_initialized = ast_test_flag(jb1, JB_TIMEBASE_INITIALIZED);
 221         int c1_jb_created = ast_test_flag(jb1, JB_CREATED);
 222         int inuse = 0;
 223
 224         /* Determine whether audio going to c0 needs a jitter buffer */
 225         if (((!c0_wants_jitter && c1_creates_jitter) || (c0_force_jb && c1_creates_jitter)) && c0_jb_enabled) {
 226                 ast_set_flag(jb0, JB_USE);
 227                 if (!c0_jb_timebase_initialized) {
 228                         if (c1_jb_timebase_initialized) {
 229                                 memcpy(&jb0->timebase, &jb1->timebase, sizeof(struct timeval));
 230                         } else {
 231                                 gettimeofday(&jb0->timebase, NULL);
 232                         }
 233                         ast_set_flag(jb0, JB_TIMEBASE_INITIALIZED);
 234                 }
 235
 236                 if (!c0_jb_created) {
 237                         jb_choose_impl(c0);
 238                 }
 239
 240                 inuse = 1;
 241         }
 242
 243         /* Determine whether audio going to c1 needs a jitter buffer */
 244         if (((!c1_wants_jitter && c0_creates_jitter) || (c1_force_jb && c0_creates_jitter)) && c1_jb_enabled) {
 245                 ast_set_flag(jb1, JB_USE);
 246                 if (!c1_jb_timebase_initialized) {
 247                         if (c0_jb_timebase_initialized) {
 248                                 memcpy(&jb1->timebase, &jb0->timebase, sizeof(struct timeval));
 249                         } else {
 250                                 gettimeofday(&jb1->timebase, NULL);
 251                         }
 252                         ast_set_flag(jb1, JB_TIMEBASE_INITIALIZED);
 253                 }
 254
 255                 if (!c1_jb_created) {
 256                         jb_choose_impl(c1);
 257                 }
 258
 259                 inuse = 1;
 260         }
 261
 262         return inuse;
 263 }
 264
 265 int ast_jb_get_when_to_wakeup(struct ast_channel *c0, struct ast_channel *c1, int time_left)
 266 {
 267         struct ast_jb *jb0 = &c0->jb;
 268         struct ast_jb *jb1 = &c1->jb;
 269         int c0_use_jb = ast_test_flag(jb0, JB_USE);
 270         int c0_jb_is_created = ast_test_flag(jb0, JB_CREATED);
 271         int c1_use_jb = ast_test_flag(jb1, JB_USE);
 272         int c1_jb_is_created = ast_test_flag(jb1, JB_CREATED);
 273         int wait, wait0, wait1;
 274         struct timeval tv_now;
 275
 276         if (time_left == 0) {
 277                 /* No time left - the bridge will be retried */
 278                 /* TODO: Test disable this */
 279                 /*return 0;*/
 280         }
 281
 282         if (time_left < 0) {
 283                 time_left = INT_MAX;
 284         }
 285
 286         gettimeofday(&tv_now, NULL);
 287
 288         wait0 = (c0_use_jb && c0_jb_is_created) ? jb0->next - get_now(jb0, &tv_now) : time_left;
 289         wait1 = (c1_use_jb && c1_jb_is_created) ? jb1->next - get_now(jb1, &tv_now) : time_left;
 290
 291         wait = wait0 < wait1 ? wait0 : wait1;
 292         wait = wait < time_left ? wait : time_left;
 293
 294         if (wait == INT_MAX) {
 295                 wait = -1;
 296         } else if (wait < 1) {
 297                 /* don't let wait=0, because this can cause the pbx thread to loop without any sleeping at all */
 298                 wait = 1;
 299         }
 300
 301         return wait;
 302 }
 303
 304
 305 int ast_jb_put(struct ast_channel *chan, struct ast_frame *f)
 306 {
 307         struct ast_jb *jb = &chan->jb;
 308         struct ast_jb_impl *jbimpl = jb->impl;
 309         void *jbobj = jb->jbobj;
 310         struct ast_frame *frr;
 311         long now = 0;
 312
 313         if (!ast_test_flag(jb, JB_USE))
 314                 return -1;
 315
 316         if (f->frametype != AST_FRAME_VOICE) {
 317                 if (f->frametype == AST_FRAME_DTMF && ast_test_flag(jb, JB_CREATED)) {
 318                         jb_framelog("JB_PUT {now=%ld}: Received DTMF frame. Force resynching jb...\n", now);
 319                         jbimpl->force_resync(jbobj);
 320                 }
 321
 322                 return -1;
 323         }
 324
 325         /* We consider an enabled jitterbuffer should receive frames with valid timing info. */
 326         if (!ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO) || f->len < 2 || f->ts < 0) {
 327                 ast_log(LOG_WARNING, "%s recieved frame with invalid timing info: "
 328                         "has_timing_info=%d, len=%ld, ts=%ld, src=%s\n",
 329                         chan->name, ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO), f->len, f->ts, f->src);
 330                 return -1;
 331         }
 332
 333         frr = ast_frdup(f);
 334
 335         if (!frr) {
 336                 ast_log(LOG_ERROR, "Failed to isolate frame for the jitterbuffer on channel '%s'\n", chan->name);
 337                 return -1;
 338         }
 339
 340         if (!ast_test_flag(jb, JB_CREATED)) {
 341                 if (create_jb(chan, frr)) {
 342                         ast_frfree(frr);
 343                         /* Disable the jitterbuffer */
 344                         ast_clear_flag(jb, JB_USE);
 345                         return -1;
 346                 }
 347
 348                 ast_set_flag(jb, JB_CREATED);
 349                 return 0;
 350         } else {
 351                 now = get_now(jb, NULL);
 352                 if (jbimpl->put(jbobj, frr, now) != JB_IMPL_OK) {
 353                         jb_framelog("JB_PUT {now=%ld}: Dropped frame with ts=%ld and len=%ld\n", now, frr->ts, frr->len);
 354                         ast_frfree(frr);
 355                         /*return -1;*/
 356                         /* TODO: Check this fix - should return 0 here, because the dropped frame shouldn't
 357                            be delivered at all */
 358                         return 0;
 359                 }
 360
 361                 jb->next = jbimpl->next(jbobj);
 362
 363                 jb_framelog("JB_PUT {now=%ld}: Queued frame with ts=%ld and len=%ld\n", now, frr->ts, frr->len);
 364
 365                 return 0;
 366         }
 367 }
 368
 369
 370 void ast_jb_get_and_deliver(struct ast_channel *c0, struct ast_channel *c1)
 371 {
 372         struct ast_jb *jb0 = &c0->jb;
 373         struct ast_jb *jb1 = &c1->jb;
 374         int c0_use_jb = ast_test_flag(jb0, JB_USE);
 375         int c0_jb_is_created = ast_test_flag(jb0, JB_CREATED);
 376         int c1_use_jb = ast_test_flag(jb1, JB_USE);
 377         int c1_jb_is_created = ast_test_flag(jb1, JB_CREATED);
 378
 379         if (c0_use_jb && c0_jb_is_created)
 380                 jb_get_and_deliver(c0);
 381
 382         if (c1_use_jb && c1_jb_is_created)
 383                 jb_get_and_deliver(c1);
 384 }
 385
 386
 387 static void jb_get_and_deliver(struct ast_channel *chan)
 388 {
 389         struct ast_jb *jb = &chan->jb;
 390         struct ast_jb_impl *jbimpl = jb->impl;
 391         void *jbobj = jb->jbobj;
 392         struct ast_frame *f, finterp;
 393         long now;
 394         int interpolation_len, res;
 395
 396         now = get_now(jb, NULL);
 397         jb->next = jbimpl->next(jbobj);
 398         if (now < jb->next) {
 399                 jb_framelog("\tJB_GET {now=%ld}: now < next=%ld\n", now, jb->next);
 400                 return;
 401         }
 402
 403         while (now >= jb->next) {
 404                 interpolation_len = ast_codec_interp_len(jb->last_format);
 405
 406                 res = jbimpl->get(jbobj, &f, now, interpolation_len);
 407
 408                 switch(res) {
 409                 case JB_IMPL_OK:
 410                         /* deliver the frame */
 411                         ast_write(chan, f);
 412                 case JB_IMPL_DROP:
 413                         jb_framelog("\tJB_GET {now=%ld}: %s frame with ts=%ld and len=%ld\n",
 414                                 now, jb_get_actions[res], f->ts, f->len);
 415                         jb->last_format = f->subclass;
 416                         ast_frfree(f);
 417                         break;
 418                 case JB_IMPL_INTERP:
 419                         /* interpolate a frame */
 420                         f = &finterp;
 421                         f->frametype = AST_FRAME_VOICE;
 422                         f->subclass = jb->last_format;
 423                         f->datalen  = 0;
 424                         f->samples  = interpolation_len * 8;
 425                         f->mallocd  = 0;
 426                         f->src  = "JB interpolation";
 427                         f->data  = NULL;
 428                         f->delivery = ast_tvadd(jb->timebase, ast_samp2tv(jb->next, 1000));
 429                         f->offset = AST_FRIENDLY_OFFSET;
 430                         /* deliver the interpolated frame */
 431                         ast_write(chan, f);
 432                         jb_framelog("\tJB_GET {now=%ld}: Interpolated frame with len=%d\n", now, interpolation_len);
 433                         break;
 434                 case JB_IMPL_NOFRAME:
 435                         ast_log(LOG_WARNING,
 436                                 "JB_IMPL_NOFRAME is retuned from the %s jb when now=%ld >= next=%ld, jbnext=%ld!\n",
 437                                 jbimpl->name, now, jb->next, jbimpl->next(jbobj));
 438                         jb_framelog("\tJB_GET {now=%ld}: No frame for now!?\n", now);
 439                         return;
 440                 default:
 441                         ast_log(LOG_ERROR, "This should never happen!\n");
 442                         ast_assert("JB type unknown" == NULL);
 443                         break;
 444                 }
 445
 446                 jb->next = jbimpl->next(jbobj);
 447         }
 448 }
 449
 450
 451 static int create_jb(struct ast_channel *chan, struct ast_frame *frr)
 452 {
 453         struct ast_jb *jb = &chan->jb;
 454         struct ast_jb_conf *jbconf = &jb->conf;
 455         struct ast_jb_impl *jbimpl = jb->impl;
 456         void *jbobj;
 457         struct ast_channel *bridged;
 458         long now;
 459         char logfile_pathname[20 + AST_JB_IMPL_NAME_SIZE + 2*AST_CHANNEL_NAME + 1];
 460         char name1[AST_CHANNEL_NAME], name2[AST_CHANNEL_NAME], *tmp;
 461         int res;
 462
 463         jbobj = jb->jbobj = jbimpl->create(jbconf, jbconf->resync_threshold);
 464         if (!jbobj) {
 465                 ast_log(LOG_WARNING, "Failed to create jitterbuffer on channel '%s'\n", chan->name);
 466                 return -1;
 467         }
 468
 469         now = get_now(jb, NULL);
 470         res = jbimpl->put_first(jbobj, frr, now);
 471
 472         /* The result of putting the first frame should not differ from OK. However, its possible
 473            some implementations (i.e. adaptive's when resynch_threshold is specified) to drop it. */
 474         if (res != JB_IMPL_OK) {
 475                 ast_log(LOG_WARNING, "Failed to put first frame in the jitterbuffer on channel '%s'\n", chan->name);
 476                 /*
 477                 jbimpl->destroy(jbobj);
 478                 return -1;
 479                 */
 480         }
 481
 482         /* Init next */
 483         jb->next = jbimpl->next(jbobj);
 484
 485         /* Init last format for a first time. */
 486         jb->last_format = frr->subclass;
 487
 488         /* Create a frame log file */
 489         if (ast_test_flag(jbconf, AST_JB_LOG)) {
 490                 snprintf(name2, sizeof(name2), "%s", chan->name);
 491                 tmp = strchr(name2, '/');
 492                 if (tmp)
 493                         *tmp = '#';
 494
 495                 bridged = ast_bridged_channel(chan);
 496                 /* We should always have bridged chan if a jitterbuffer is in use */
 497                 ast_assert(bridged != NULL);
 498
 499                 snprintf(name1, sizeof(name1), "%s", bridged->name);
 500                 tmp = strchr(name1, '/');
 501                 if (tmp)
 502                         *tmp = '#';
 503
 504                 snprintf(logfile_pathname, sizeof(logfile_pathname),
 505                         "/tmp/ast_%s_jb_%s--%s.log", jbimpl->name, name1, name2);
 506                 jb->logfile = fopen(logfile_pathname, "w+b");
 507
 508                 if (!jb->logfile)
 509                         ast_log(LOG_WARNING, "Failed to create frame log file with pathname '%s'\n", logfile_pathname);
 510
 511                 if (res == JB_IMPL_OK)
 512                         jb_framelog("JB_PUT_FIRST {now=%ld}: Queued frame with ts=%ld and len=%ld\n",
 513                                 now, frr->ts, frr->len);
 514                 else
 515                         jb_framelog("JB_PUT_FIRST {now=%ld}: Dropped frame with ts=%ld and len=%ld\n",
 516                                 now, frr->ts, frr->len);
 517         }
 518
 519         if (option_verbose > 2)
 520                 ast_verbose(VERBOSE_PREFIX_3 "%s jitterbuffer created on channel %s\n", jbimpl->name, chan->name);
 521
 522         /* Free the frame if it has not been queued in the jb */
 523         if (res != JB_IMPL_OK)
 524                 ast_frfree(frr);
 525
 526         return 0;
 527 }
 528
 529
 530 void ast_jb_destroy(struct ast_channel *chan)
 531 {
 532         struct ast_jb *jb = &chan->jb;
 533         struct ast_jb_impl *jbimpl = jb->impl;
 534         void *jbobj = jb->jbobj;
 535         struct ast_frame *f;
 536
 537         if (jb->logfile) {
 538                 fclose(jb->logfile);
 539                 jb->logfile = NULL;
 540         }
 541
 542         if (ast_test_flag(jb, JB_CREATED)) {
 543                 /* Remove and free all frames still queued in jb */
 544                 while (jbimpl->remove(jbobj, &f) == JB_IMPL_OK) {
 545                         ast_frfree(f);
 546                 }
 547
 548                 jbimpl->destroy(jbobj);
 549                 jb->jbobj = NULL;
 550
 551                 ast_clear_flag(jb, JB_CREATED);
 552
 553                 if (option_verbose > 2)
 554                         ast_verbose(VERBOSE_PREFIX_3 "%s jitterbuffer destroyed on channel %s\n", jbimpl->name, chan->name);
 555         }
 556 }
 557
 558
 559 static long get_now(struct ast_jb *jb, struct timeval *tv)
 560 {
 561         struct timeval now;
 562
 563         if (!tv) {
 564                 tv = &now;
 565                 gettimeofday(tv, NULL);
 566         }
 567
 568         return ast_tvdiff_ms(*tv, jb->timebase);
 569 }
 570
 571
 572 int ast_jb_read_conf(struct ast_jb_conf *conf, char *varname, char *value)
 573 {
 574         int prefixlen = sizeof(AST_JB_CONF_PREFIX) - 1;
 575         char *name;
 576         int tmp;
 577
 578         if (strncasecmp(AST_JB_CONF_PREFIX, varname, prefixlen))
 579                 return -1;
 580
 581         name = varname + prefixlen;
 582
 583         if (!strcasecmp(name, AST_JB_CONF_ENABLE)) {
 584                 ast_set2_flag(conf, ast_true(value), AST_JB_ENABLED);
 585         } else if (!strcasecmp(name, AST_JB_CONF_FORCE)) {
 586                 ast_set2_flag(conf, ast_true(value), AST_JB_FORCED);
 587         } else if (!strcasecmp(name, AST_JB_CONF_MAX_SIZE)) {
 588                 if ((tmp = atoi(value)) > 0)
 589                         conf->max_size = tmp;
 590         } else if (!strcasecmp(name, AST_JB_CONF_RESYNCH_THRESHOLD)) {
 591                 if ((tmp = atoi(value)) > 0)
 592                         conf->resync_threshold = tmp;
 593         } else if (!strcasecmp(name, AST_JB_CONF_IMPL)) {
 594                 if (!ast_strlen_zero(value))
 595                         snprintf(conf->impl, sizeof(conf->impl), "%s", value);
 596         } else if (!strcasecmp(name, AST_JB_CONF_LOG)) {
 597                 ast_set2_flag(conf, ast_true(value), AST_JB_LOG);
 598         } else {
 599                 return -1;
 600         }
 601
 602         return 0;
 603 }
 604
 605
 606 void ast_jb_configure(struct ast_channel *chan, const struct ast_jb_conf *conf)
 607 {
 608         memcpy(&chan->jb.conf, conf, sizeof(*conf));
 609 }
 610
 611
 612 void ast_jb_get_config(const struct ast_channel *chan, struct ast_jb_conf *conf)
 613 {
 614         memcpy(conf, &chan->jb.conf, sizeof(*conf));
 615 }
 616
 617 void ast_jb_empty_and_reset(struct ast_channel *c0, struct ast_channel *c1)
 618 {
 619         struct ast_jb *jb0 = &c0->jb;
 620         struct ast_jb *jb1 = &c1->jb;
 621         int c0_use_jb = ast_test_flag(jb0, JB_USE);
 622         int c0_jb_is_created = ast_test_flag(jb0, JB_CREATED);
 623         int c1_use_jb = ast_test_flag(jb1, JB_USE);
 624         int c1_jb_is_created = ast_test_flag(jb1, JB_CREATED);
 625
 626         if (c0_use_jb && c0_jb_is_created && jb0->impl->empty_and_reset) {
 627                 jb0->impl->empty_and_reset(jb0->jbobj);
 628         }
 629
 630         if (c1_use_jb && c1_jb_is_created && jb1->impl->empty_and_reset) {
 631                 jb1->impl->empty_and_reset(jb1->jbobj);
 632         }
 633 }
 634
 635 /* Implementation functions */
 636
 637 /* fixed */
 638 static void * jb_create_fixed(struct ast_jb_conf *general_config, long resynch_threshold)
 639 {
 640         struct fixed_jb_conf conf;
 641
 642         conf.jbsize = general_config->max_size;
 643         conf.resync_threshold = resynch_threshold;
 644
 645         return fixed_jb_new(&conf);
 646 }
 647
 648 static void jb_destroy_fixed(void *jb)
 649 {
 650         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
 651
 652         /* destroy the jb */
 653         fixed_jb_destroy(fixedjb);
 654 }
 655
 656
 657 static int jb_put_first_fixed(void *jb, struct ast_frame *fin, long now)
 658 {
 659         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
 660         int res;
 661
 662         res = fixed_jb_put_first(fixedjb, fin, fin->len, fin->ts, now);
 663
 664         return fixed_to_abstract_code[res];
 665 }
 666
 667
 668 static int jb_put_fixed(void *jb, struct ast_frame *fin, long now)
 669 {
 670         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
 671         int res;
 672
 673         res = fixed_jb_put(fixedjb, fin, fin->len, fin->ts, now);
 674
 675         return fixed_to_abstract_code[res];
 676 }
 677
 678
 679 static int jb_get_fixed(void *jb, struct ast_frame **fout, long now, long interpl)
 680 {
 681         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
 682         struct fixed_jb_frame frame;
 683         int res;
 684
 685         res = fixed_jb_get(fixedjb, &frame, now, interpl);
 686         *fout = frame.data;
 687
 688         return fixed_to_abstract_code[res];
 689 }
 690
 691
 692 static long jb_next_fixed(void *jb)
 693 {
 694         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
 695
 696         return fixed_jb_next(fixedjb);
 697 }
 698
 699
 700 static int jb_remove_fixed(void *jb, struct ast_frame **fout)
 701 {
 702         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
 703         struct fixed_jb_frame frame;
 704         int res;
 705
 706         res = fixed_jb_remove(fixedjb, &frame);
 707         *fout = frame.data;
 708
 709         return fixed_to_abstract_code[res];
 710 }
 711
 712
 713 static void jb_force_resynch_fixed(void *jb)
 714 {
 715         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
 716
 717         fixed_jb_set_force_resynch(fixedjb);
 718 }
 719
 720 static void jb_empty_and_reset_fixed(void *jb)
 721 {
 722         struct fixed_jb *fixedjb = jb;
 723         struct fixed_jb_frame f;
 724
 725         while (fixed_jb_remove(fixedjb, &f) == FIXED_JB_OK) {
 726                 ast_frfree(f.data);
 727         }
 728 }
 729
 730 /* adaptive */
 731
 732 static void *jb_create_adaptive(struct ast_jb_conf *general_config, long resynch_threshold)
 733 {
 734         jb_conf jbconf;
 735         jitterbuf *adaptivejb;
 736
 737         adaptivejb = jb_new();
 738         if (adaptivejb) {
 739                 jbconf.max_jitterbuf = general_config->max_size;
 740                 jbconf.resync_threshold = general_config->resync_threshold;
 741                 jbconf.max_contig_interp = 10;
 742                 jb_setconf(adaptivejb, &jbconf);
 743         }
 744
 745         return adaptivejb;
 746 }
 747
 748
 749 static void jb_destroy_adaptive(void *jb)
 750 {
 751         jitterbuf *adaptivejb = (jitterbuf *) jb;
 752
 753         jb_destroy(adaptivejb);
 754 }
 755
 756
 757 static int jb_put_first_adaptive(void *jb, struct ast_frame *fin, long now)
 758 {
 759         return jb_put_adaptive(jb, fin, now);
 760 }
 761
 762
 763 static int jb_put_adaptive(void *jb, struct ast_frame *fin, long now)
 764 {
 765         jitterbuf *adaptivejb = (jitterbuf *) jb;
 766         int res;
 767
 768         res = jb_put(adaptivejb, fin, JB_TYPE_VOICE, fin->len, fin->ts, now);
 769
 770         return adaptive_to_abstract_code[res];
 771 }
 772
 773
 774 static int jb_get_adaptive(void *jb, struct ast_frame **fout, long now, long interpl)
 775 {
 776         jitterbuf *adaptivejb = (jitterbuf *) jb;
 777         jb_frame frame;
 778         int res;
 779
 780         res = jb_get(adaptivejb, &frame, now, interpl);
 781         *fout = frame.data;
 782
 783         return adaptive_to_abstract_code[res];
 784 }
 785
 786
 787 static long jb_next_adaptive(void *jb)
 788 {
 789         jitterbuf *adaptivejb = (jitterbuf *) jb;
 790
 791         return jb_next(adaptivejb);
 792 }
 793
 794
 795 static int jb_remove_adaptive(void *jb, struct ast_frame **fout)
 796 {
 797         jitterbuf *adaptivejb = (jitterbuf *) jb;
 798         jb_frame frame;
 799         int res;
 800
 801         res = jb_getall(adaptivejb, &frame);
 802         *fout = frame.data;
 803
 804         return adaptive_to_abstract_code[res];
 805 }
 806
 807
 808 static void jb_force_resynch_adaptive(void *jb)
 809 {
 810 }
 811
 812 static void jb_empty_and_reset_adaptive(void *jb)
 813 {
 814         jitterbuf *adaptivejb = jb;
 815         jb_frame f;
 816
 817         while (jb_getall(adaptivejb, &f) == JB_OK) {
 818                 ast_frfree(f.data);
 819         }
 820
 821         jb_reset(adaptivejb);
 822 }