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