Merge team/russell/frame_caching
[asterisk/asterisk.git] / 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 (!f->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, f->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                         CRASH;
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                 if (!bridged) {
491                         /* We should always have bridged chan if a jitterbuffer is in use */
492                         CRASH;
493                 }
494                 snprintf(name1, sizeof(name1), "%s", bridged->name);
495                 tmp = strchr(name1, '/');
496                 if (tmp)
497                         *tmp = '#';
498                 
499                 snprintf(logfile_pathname, sizeof(logfile_pathname),
500                         "/tmp/ast_%s_jb_%s--%s.log", jbimpl->name, name1, name2);
501                 jb->logfile = fopen(logfile_pathname, "w+b");
502                 
503                 if (!jb->logfile)
504                         ast_log(LOG_WARNING, "Failed to create frame log file with pathname '%s'\n", logfile_pathname);
505                 
506                 if (res == JB_IMPL_OK)
507                         jb_framelog("JB_PUT_FIRST {now=%ld}: Queued frame with ts=%ld and len=%ld\n",
508                                 now, frr->ts, frr->len);
509                 else
510                         jb_framelog("JB_PUT_FIRST {now=%ld}: Dropped frame with ts=%ld and len=%ld\n",
511                                 now, frr->ts, frr->len);
512         }
513
514         if (option_verbose > 2) 
515                 ast_verbose(VERBOSE_PREFIX_3 "%s jitterbuffer created on channel %s\n", jbimpl->name, chan->name);
516         
517         /* Free the frame if it has not been queued in the jb */
518         if (res != JB_IMPL_OK)
519                 ast_frfree(frr);
520         
521         return 0;
522 }
523
524
525 void ast_jb_destroy(struct ast_channel *chan)
526 {
527         struct ast_jb *jb = &chan->jb;
528         struct ast_jb_impl *jbimpl = jb->impl;
529         void *jbobj = jb->jbobj;
530         struct ast_frame *f;
531
532         if (jb->logfile) {
533                 fclose(jb->logfile);
534                 jb->logfile = NULL;
535         }
536         
537         if (ast_test_flag(jb, JB_CREATED)) {
538                 /* Remove and free all frames still queued in jb */
539                 while (jbimpl->remove(jbobj, &f) == JB_IMPL_OK) {
540                         ast_frfree(f);
541                 }
542                 
543                 jbimpl->destroy(jbobj);
544                 jb->jbobj = NULL;
545                 
546                 ast_clear_flag(jb, JB_CREATED);
547
548                 if (option_verbose > 2)
549                         ast_verbose(VERBOSE_PREFIX_3 "%s jitterbuffer destroyed on channel %s\n", jbimpl->name, chan->name);
550         }
551 }
552
553
554 static long get_now(struct ast_jb *jb, struct timeval *tv)
555 {
556         struct timeval now;
557
558         if (!tv) {
559                 tv = &now;
560                 gettimeofday(tv, NULL);
561         }
562
563         return ast_tvdiff_ms(*tv, jb->timebase);
564 }
565
566
567 int ast_jb_read_conf(struct ast_jb_conf *conf, char *varname, char *value)
568 {
569         int prefixlen = sizeof(AST_JB_CONF_PREFIX) - 1;
570         char *name;
571         int tmp;
572         
573         if (strncasecmp(AST_JB_CONF_PREFIX, varname, prefixlen))
574                 return -1;
575         
576         name = varname + prefixlen;
577         
578         if (!strcasecmp(name, AST_JB_CONF_ENABLE)) {
579                 ast_set2_flag(conf, ast_true(value), AST_JB_ENABLED);
580         } else if (!strcasecmp(name, AST_JB_CONF_FORCE)) {
581                 ast_set2_flag(conf, ast_true(value), AST_JB_FORCED);
582         } else if (!strcasecmp(name, AST_JB_CONF_MAX_SIZE)) {
583                 if ((tmp = atoi(value)) > 0)
584                         conf->max_size = tmp;
585         } else if (!strcasecmp(name, AST_JB_CONF_RESYNCH_THRESHOLD)) {
586                 if ((tmp = atoi(value)) > 0)
587                         conf->resync_threshold = tmp;
588         } else if (!strcasecmp(name, AST_JB_CONF_IMPL)) {
589                 if (!ast_strlen_zero(value))
590                         snprintf(conf->impl, sizeof(conf->impl), "%s", value);
591         } else if (!strcasecmp(name, AST_JB_CONF_LOG)) {
592                 ast_set2_flag(conf, ast_true(value), AST_JB_LOG);
593         } else {
594                 return -1;
595         }
596         
597         return 0;
598 }
599
600
601 void ast_jb_configure(struct ast_channel *chan, const struct ast_jb_conf *conf)
602 {
603         memcpy(&chan->jb.conf, conf, sizeof(*conf));
604 }
605
606
607 void ast_jb_get_config(const struct ast_channel *chan, struct ast_jb_conf *conf)
608 {
609         memcpy(conf, &chan->jb.conf, sizeof(*conf));
610 }
611
612
613 /* Implementation functions */
614
615 /* fixed */
616
617 static void * jb_create_fixed(struct ast_jb_conf *general_config, long resynch_threshold)
618 {
619         struct fixed_jb_conf conf;
620         
621         conf.jbsize = general_config->max_size;
622         conf.resync_threshold = resynch_threshold;
623         
624         return fixed_jb_new(&conf);
625 }
626
627
628 static void jb_destroy_fixed(void *jb)
629 {
630         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
631         
632         /* destroy the jb */
633         fixed_jb_destroy(fixedjb);
634 }
635
636
637 static int jb_put_first_fixed(void *jb, struct ast_frame *fin, long now)
638 {
639         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
640         int res;
641         
642         res = fixed_jb_put_first(fixedjb, fin, fin->len, fin->ts, now);
643         
644         return fixed_to_abstract_code[res];
645 }
646
647
648 static int jb_put_fixed(void *jb, struct ast_frame *fin, long now)
649 {
650         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
651         int res;
652         
653         res = fixed_jb_put(fixedjb, fin, fin->len, fin->ts, now);
654         
655         return fixed_to_abstract_code[res];
656 }
657
658
659 static int jb_get_fixed(void *jb, struct ast_frame **fout, long now, long interpl)
660 {
661         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
662         struct fixed_jb_frame frame;
663         int res;
664         
665         res = fixed_jb_get(fixedjb, &frame, now, interpl);
666         *fout = frame.data;
667         
668         return fixed_to_abstract_code[res];
669 }
670
671
672 static long jb_next_fixed(void *jb)
673 {
674         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
675         
676         return fixed_jb_next(fixedjb);
677 }
678
679
680 static int jb_remove_fixed(void *jb, struct ast_frame **fout)
681 {
682         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
683         struct fixed_jb_frame frame;
684         int res;
685         
686         res = fixed_jb_remove(fixedjb, &frame);
687         *fout = frame.data;
688         
689         return fixed_to_abstract_code[res];
690 }
691
692
693 static void jb_force_resynch_fixed(void *jb)
694 {
695         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
696         
697         fixed_jb_set_force_resynch(fixedjb);
698 }
699
700
701 /* adaptive */
702
703 static void *jb_create_adaptive(struct ast_jb_conf *general_config, long resynch_threshold)
704 {
705         jb_conf jbconf;
706         jitterbuf *adaptivejb;
707
708         adaptivejb = jb_new();
709         if (adaptivejb) {
710                 jbconf.max_jitterbuf = general_config->max_size;
711                 jbconf.resync_threshold = general_config->resync_threshold;
712                 jbconf.max_contig_interp = 10;
713                 jb_setconf(adaptivejb, &jbconf);
714         }
715         
716         return adaptivejb;
717 }
718
719
720 static void jb_destroy_adaptive(void *jb)
721 {
722         jitterbuf *adaptivejb = (jitterbuf *) jb;
723         
724         jb_destroy(adaptivejb);
725 }
726
727
728 static int jb_put_first_adaptive(void *jb, struct ast_frame *fin, long now)
729 {
730         return jb_put_adaptive(jb, fin, now);
731 }
732
733
734 static int jb_put_adaptive(void *jb, struct ast_frame *fin, long now)
735 {
736         jitterbuf *adaptivejb = (jitterbuf *) jb;
737         int res;
738         
739         res = jb_put(adaptivejb, fin, JB_TYPE_VOICE, fin->len, fin->ts, now);
740         
741         return adaptive_to_abstract_code[res];
742 }
743
744
745 static int jb_get_adaptive(void *jb, struct ast_frame **fout, long now, long interpl)
746 {
747         jitterbuf *adaptivejb = (jitterbuf *) jb;
748         jb_frame frame;
749         int res;
750         
751         res = jb_get(adaptivejb, &frame, now, interpl);
752         *fout = frame.data;
753         
754         return adaptive_to_abstract_code[res];
755 }
756
757
758 static long jb_next_adaptive(void *jb)
759 {
760         jitterbuf *adaptivejb = (jitterbuf *) jb;
761         
762         return jb_next(adaptivejb);
763 }
764
765
766 static int jb_remove_adaptive(void *jb, struct ast_frame **fout)
767 {
768         jitterbuf *adaptivejb = (jitterbuf *) jb;
769         jb_frame frame;
770         int res;
771         
772         res = jb_getall(adaptivejb, &frame);
773         *fout = frame.data;
774         
775         return adaptive_to_abstract_code[res];
776 }
777
778
779 static void jb_force_resynch_adaptive(void *jb)
780 {
781 }