Merge "res_rtp_asterisk: Always return provided DTLS packet length."
[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  */
31
32 /*** MODULEINFO
33         <support_level>core</support_level>
34  ***/
35
36 #include "asterisk.h"
37
38 #include "asterisk/frame.h"
39 #include "asterisk/channel.h"
40 #include "asterisk/term.h"
41 #include "asterisk/utils.h"
42 #include "asterisk/pbx.h"
43 #include "asterisk/timing.h"
44 #include "asterisk/rtp_engine.h"
45 #include "asterisk/format_cache.h"
46
47 #include "asterisk/abstract_jb.h"
48 #include "fixedjitterbuf.h"
49 #include "jitterbuf.h"
50
51 /*! Internal jb flags */
52 enum {
53         JB_USE =                  (1 << 0),
54         JB_TIMEBASE_INITIALIZED = (1 << 1),
55         JB_CREATED =              (1 << 2)
56 };
57
58 /*! The maximum size we allow the early frame buffer to get */
59 #define MAXIMUM_EARLY_FRAME_COUNT 200
60
61
62 /* Implementation functions */
63 /* fixed */
64 static void *jb_create_fixed(struct ast_jb_conf *general_config);
65 static void jb_destroy_fixed(void *jb);
66 static int jb_put_first_fixed(void *jb, struct ast_frame *fin, long now);
67 static int jb_put_fixed(void *jb, struct ast_frame *fin, long now);
68 static int jb_get_fixed(void *jb, struct ast_frame **fout, long now, long interpl);
69 static long jb_next_fixed(void *jb);
70 static int jb_remove_fixed(void *jb, struct ast_frame **fout);
71 static void jb_force_resynch_fixed(void *jb);
72 static void jb_empty_and_reset_fixed(void *jb);
73 static int jb_is_late_fixed(void *jb, long ts);
74 /* adaptive */
75 static void * jb_create_adaptive(struct ast_jb_conf *general_config);
76 static void jb_destroy_adaptive(void *jb);
77 static int jb_put_first_adaptive(void *jb, struct ast_frame *fin, long now);
78 static int jb_put_adaptive(void *jb, struct ast_frame *fin, long now);
79 static int jb_get_adaptive(void *jb, struct ast_frame **fout, long now, long interpl);
80 static long jb_next_adaptive(void *jb);
81 static int jb_remove_adaptive(void *jb, struct ast_frame **fout);
82 static void jb_force_resynch_adaptive(void *jb);
83 static void jb_empty_and_reset_adaptive(void *jb);
84 static int jb_is_late_adaptive(void *jb, long ts);
85
86 /* Available jb implementations */
87 static const struct ast_jb_impl avail_impl[] = {
88         {
89                 .name = "fixed",
90                 .type = AST_JB_FIXED,
91                 .create = jb_create_fixed,
92                 .destroy = jb_destroy_fixed,
93                 .put_first = jb_put_first_fixed,
94                 .put = jb_put_fixed,
95                 .get = jb_get_fixed,
96                 .next = jb_next_fixed,
97                 .remove = jb_remove_fixed,
98                 .force_resync = jb_force_resynch_fixed,
99                 .empty_and_reset = jb_empty_and_reset_fixed,
100                 .is_late = jb_is_late_fixed,
101         },
102         {
103                 .name = "adaptive",
104                 .type = AST_JB_ADAPTIVE,
105                 .create = jb_create_adaptive,
106                 .destroy = jb_destroy_adaptive,
107                 .put_first = jb_put_first_adaptive,
108                 .put = jb_put_adaptive,
109                 .get = jb_get_adaptive,
110                 .next = jb_next_adaptive,
111                 .remove = jb_remove_adaptive,
112                 .force_resync = jb_force_resynch_adaptive,
113                 .empty_and_reset = jb_empty_and_reset_adaptive,
114                 .is_late = jb_is_late_adaptive,
115         }
116 };
117
118 static int default_impl = 0;
119
120 /* Translations between impl and abstract return codes */
121 static const int fixed_to_abstract_code[] =
122         {AST_JB_IMPL_OK, AST_JB_IMPL_DROP, AST_JB_IMPL_INTERP, AST_JB_IMPL_NOFRAME};
123 static const int adaptive_to_abstract_code[] =
124         {AST_JB_IMPL_OK, AST_JB_IMPL_NOFRAME, AST_JB_IMPL_NOFRAME, AST_JB_IMPL_INTERP, AST_JB_IMPL_DROP, AST_JB_IMPL_OK};
125
126 /* JB_GET actions (used only for the frames log) */
127 static const char * const jb_get_actions[] = {"Delivered", "Dropped", "Interpolated", "No"};
128
129 /*! \brief Macros for the frame log files */
130 #define jb_framelog(...) do { \
131         if (jb->logfile) { \
132                 fprintf(jb->logfile, __VA_ARGS__); \
133                 fflush(jb->logfile); \
134         } \
135 } while (0)
136
137
138 /* Internal utility functions */
139 static void jb_choose_impl(struct ast_channel *chan);
140 static void jb_get_and_deliver(struct ast_channel *chan);
141 static int create_jb(struct ast_channel *chan, struct ast_frame *first_frame);
142 static long get_now(struct ast_jb *jb, struct timeval *tv);
143
144
145 /* Interface ast jb functions impl */
146
147
148 static void jb_choose_impl(struct ast_channel *chan)
149 {
150         struct ast_jb *jb = ast_channel_jb(chan);
151         struct ast_jb_conf *jbconf = &jb->conf;
152         const struct ast_jb_impl *test_impl;
153         int i, avail_impl_count = ARRAY_LEN(avail_impl);
154
155         jb->impl = &avail_impl[default_impl];
156
157         if (ast_strlen_zero(jbconf->impl)) {
158                 return;
159         }
160
161         for (i = 0; i < avail_impl_count; i++) {
162                 test_impl = &avail_impl[i];
163                 if (!strcasecmp(jbconf->impl, test_impl->name)) {
164                         jb->impl = test_impl;
165                         return;
166                 }
167         }
168 }
169
170 int ast_jb_do_usecheck(struct ast_channel *c0, struct ast_channel *c1)
171 {
172         struct ast_jb *jb0 = ast_channel_jb(c0);
173         struct ast_jb *jb1 = ast_channel_jb(c1);
174         struct ast_jb_conf *conf0 = &jb0->conf;
175         struct ast_jb_conf *conf1 = &jb1->conf;
176         int c0_wants_jitter = ast_channel_tech(c0)->properties & AST_CHAN_TP_WANTSJITTER;
177         int c0_creates_jitter = ast_channel_tech(c0)->properties & AST_CHAN_TP_CREATESJITTER;
178         int c0_jb_enabled = ast_test_flag(conf0, AST_JB_ENABLED);
179         int c0_force_jb = ast_test_flag(conf0, AST_JB_FORCED);
180         int c0_jb_timebase_initialized = ast_test_flag(jb0, JB_TIMEBASE_INITIALIZED);
181         int c0_jb_created = ast_test_flag(jb0, JB_CREATED);
182         int c1_wants_jitter = ast_channel_tech(c1)->properties & AST_CHAN_TP_WANTSJITTER;
183         int c1_creates_jitter = ast_channel_tech(c1)->properties & AST_CHAN_TP_CREATESJITTER;
184         int c1_jb_enabled = ast_test_flag(conf1, AST_JB_ENABLED);
185         int c1_force_jb = ast_test_flag(conf1, AST_JB_FORCED);
186         int c1_jb_timebase_initialized = ast_test_flag(jb1, JB_TIMEBASE_INITIALIZED);
187         int c1_jb_created = ast_test_flag(jb1, JB_CREATED);
188         int inuse = 0;
189
190         /* Determine whether audio going to c0 needs a jitter buffer */
191         if (((!c0_wants_jitter && c1_creates_jitter) || (c0_force_jb && c1_creates_jitter)) && c0_jb_enabled) {
192                 ast_set_flag(jb0, JB_USE);
193                 if (!c0_jb_timebase_initialized) {
194                         if (c1_jb_timebase_initialized) {
195                                 memcpy(&jb0->timebase, &jb1->timebase, sizeof(struct timeval));
196                         } else {
197                                 gettimeofday(&jb0->timebase, NULL);
198                         }
199                         ast_set_flag(jb0, JB_TIMEBASE_INITIALIZED);
200                 }
201
202                 if (!c0_jb_created) {
203                         jb_choose_impl(c0);
204                 }
205
206                 inuse = 1;
207         }
208
209         /* Determine whether audio going to c1 needs a jitter buffer */
210         if (((!c1_wants_jitter && c0_creates_jitter) || (c1_force_jb && c0_creates_jitter)) && c1_jb_enabled) {
211                 ast_set_flag(jb1, JB_USE);
212                 if (!c1_jb_timebase_initialized) {
213                         if (c0_jb_timebase_initialized) {
214                                 memcpy(&jb1->timebase, &jb0->timebase, sizeof(struct timeval));
215                         } else {
216                                 gettimeofday(&jb1->timebase, NULL);
217                         }
218                         ast_set_flag(jb1, JB_TIMEBASE_INITIALIZED);
219                 }
220
221                 if (!c1_jb_created) {
222                         jb_choose_impl(c1);
223                 }
224
225                 inuse = 1;
226         }
227
228         return inuse;
229 }
230
231 int ast_jb_get_when_to_wakeup(struct ast_channel *c0, struct ast_channel *c1, int time_left)
232 {
233         struct ast_jb *jb0 = ast_channel_jb(c0);
234         struct ast_jb *jb1 = ast_channel_jb(c1);
235         int c0_use_jb = ast_test_flag(jb0, JB_USE);
236         int c0_jb_is_created = ast_test_flag(jb0, JB_CREATED);
237         int c1_use_jb = ast_test_flag(jb1, JB_USE);
238         int c1_jb_is_created = ast_test_flag(jb1, JB_CREATED);
239         int wait, wait0, wait1;
240         struct timeval tv_now;
241
242         if (time_left == 0) {
243                 /* No time left - the bridge will be retried */
244                 /* TODO: Test disable this */
245                 /*return 0;*/
246         }
247
248         if (time_left < 0) {
249                 time_left = INT_MAX;
250         }
251
252         gettimeofday(&tv_now, NULL);
253
254         wait0 = (c0_use_jb && c0_jb_is_created) ? jb0->next - get_now(jb0, &tv_now) : time_left;
255         wait1 = (c1_use_jb && c1_jb_is_created) ? jb1->next - get_now(jb1, &tv_now) : time_left;
256
257         wait = wait0 < wait1 ? wait0 : wait1;
258         wait = wait < time_left ? wait : time_left;
259
260         if (wait == INT_MAX) {
261                 wait = -1;
262         } else if (wait < 1) {
263                 /* don't let wait=0, because this can cause the pbx thread to loop without any sleeping at all */
264                 wait = 1;
265         }
266
267         return wait;
268 }
269
270
271 int ast_jb_put(struct ast_channel *chan, struct ast_frame *f)
272 {
273         struct ast_jb *jb = ast_channel_jb(chan);
274         const struct ast_jb_impl *jbimpl = jb->impl;
275         void *jbobj = jb->jbobj;
276         struct ast_frame *frr;
277         long now = 0;
278
279         if (!ast_test_flag(jb, JB_USE))
280                 return -1;
281
282         if (f->frametype != AST_FRAME_VOICE) {
283                 if (f->frametype == AST_FRAME_DTMF && ast_test_flag(jb, JB_CREATED)) {
284                         jb_framelog("JB_PUT {now=%ld}: Received DTMF frame. Force resynching jb...\n", now);
285                         jbimpl->force_resync(jbobj);
286                 }
287
288                 return -1;
289         }
290
291         /* We consider an enabled jitterbuffer should receive frames with valid timing info. */
292         if (!ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO) || f->len < 2 || f->ts < 0) {
293                 ast_log(LOG_WARNING, "%s received frame with invalid timing info: "
294                         "has_timing_info=%u, len=%ld, ts=%ld, src=%s\n",
295                         ast_channel_name(chan), ast_test_flag(f, AST_FRFLAG_HAS_TIMING_INFO), f->len, f->ts, f->src);
296                 return -1;
297         }
298
299         frr = ast_frdup(f);
300
301         if (!frr) {
302                 ast_log(LOG_ERROR, "Failed to isolate frame for the jitterbuffer on channel '%s'\n", ast_channel_name(chan));
303                 return -1;
304         }
305
306         if (!ast_test_flag(jb, JB_CREATED)) {
307                 if (create_jb(chan, frr)) {
308                         ast_frfree(frr);
309                         /* Disable the jitterbuffer */
310                         ast_clear_flag(jb, JB_USE);
311                         return -1;
312                 }
313
314                 ast_set_flag(jb, JB_CREATED);
315                 return 0;
316         } else {
317                 now = get_now(jb, NULL);
318                 if (jbimpl->put(jbobj, frr, now) != AST_JB_IMPL_OK) {
319                         jb_framelog("JB_PUT {now=%ld}: Dropped frame with ts=%ld and len=%ld\n", now, frr->ts, frr->len);
320                         ast_frfree(frr);
321                         /*return -1;*/
322                         /* TODO: Check this fix - should return 0 here, because the dropped frame shouldn't
323                            be delivered at all */
324                         return 0;
325                 }
326
327                 jb->next = jbimpl->next(jbobj);
328
329                 jb_framelog("JB_PUT {now=%ld}: Queued frame with ts=%ld and len=%ld\n", now, frr->ts, frr->len);
330
331                 return 0;
332         }
333 }
334
335
336 void ast_jb_get_and_deliver(struct ast_channel *c0, struct ast_channel *c1)
337 {
338         struct ast_jb *jb0 = ast_channel_jb(c0);
339         struct ast_jb *jb1 = ast_channel_jb(c1);
340         int c0_use_jb = ast_test_flag(jb0, JB_USE);
341         int c0_jb_is_created = ast_test_flag(jb0, JB_CREATED);
342         int c1_use_jb = ast_test_flag(jb1, JB_USE);
343         int c1_jb_is_created = ast_test_flag(jb1, JB_CREATED);
344
345         if (c0_use_jb && c0_jb_is_created)
346                 jb_get_and_deliver(c0);
347
348         if (c1_use_jb && c1_jb_is_created)
349                 jb_get_and_deliver(c1);
350 }
351
352
353 static void jb_get_and_deliver(struct ast_channel *chan)
354 {
355         struct ast_jb *jb = ast_channel_jb(chan);
356         const struct ast_jb_impl *jbimpl = jb->impl;
357         void *jbobj = jb->jbobj;
358         struct ast_frame *f, finterp = { .frametype = AST_FRAME_VOICE, };
359         long now;
360         int interpolation_len, res;
361
362         now = get_now(jb, NULL);
363         jb->next = jbimpl->next(jbobj);
364         if (now < jb->next) {
365                 jb_framelog("\tJB_GET {now=%ld}: now < next=%ld\n", now, jb->next);
366                 return;
367         }
368
369         while (now >= jb->next) {
370                 interpolation_len = ast_format_get_default_ms(jb->last_format);
371
372                 res = jbimpl->get(jbobj, &f, now, interpolation_len);
373
374                 switch (res) {
375                 case AST_JB_IMPL_OK:
376                         /* deliver the frame */
377                         ast_write(chan, f);
378                 case AST_JB_IMPL_DROP:
379                         jb_framelog("\tJB_GET {now=%ld}: %s frame with ts=%ld and len=%ld\n",
380                                 now, jb_get_actions[res], f->ts, f->len);
381                         ao2_replace(jb->last_format, f->subclass.format);
382                         ast_frfree(f);
383                         break;
384                 case AST_JB_IMPL_INTERP:
385                         /* interpolate a frame */
386                         f = &finterp;
387                         f->subclass.format = jb->last_format;
388                         f->samples  = interpolation_len * 8;
389                         f->src  = "JB interpolation";
390                         f->delivery = ast_tvadd(jb->timebase, ast_samp2tv(jb->next, 1000));
391                         f->offset = AST_FRIENDLY_OFFSET;
392                         /* deliver the interpolated frame */
393                         ast_write(chan, f);
394                         jb_framelog("\tJB_GET {now=%ld}: Interpolated frame with len=%d\n", now, interpolation_len);
395                         break;
396                 case AST_JB_IMPL_NOFRAME:
397                         ast_log(LOG_WARNING,
398                                 "AST_JB_IMPL_NOFRAME is returned from the %s jb when now=%ld >= next=%ld, jbnext=%ld!\n",
399                                 jbimpl->name, now, jb->next, jbimpl->next(jbobj));
400                         jb_framelog("\tJB_GET {now=%ld}: No frame for now!?\n", now);
401                         return;
402                 default:
403                         ast_log(LOG_ERROR, "This should never happen!\n");
404                         ast_assert("JB type unknown" == NULL);
405                         break;
406                 }
407
408                 jb->next = jbimpl->next(jbobj);
409         }
410 }
411
412
413 static int create_jb(struct ast_channel *chan, struct ast_frame *frr)
414 {
415         struct ast_jb *jb = ast_channel_jb(chan);
416         struct ast_jb_conf *jbconf = &jb->conf;
417         const struct ast_jb_impl *jbimpl = jb->impl;
418         void *jbobj;
419         long now;
420         char logfile_pathname[20 + AST_JB_IMPL_NAME_SIZE + 2*AST_CHANNEL_NAME + 1];
421         char name1[AST_CHANNEL_NAME], name2[AST_CHANNEL_NAME], *tmp;
422         int res;
423
424         jbobj = jb->jbobj = jbimpl->create(jbconf);
425         if (!jbobj) {
426                 ast_log(LOG_WARNING, "Failed to create jitterbuffer on channel '%s'\n", ast_channel_name(chan));
427                 return -1;
428         }
429
430         now = get_now(jb, NULL);
431         res = jbimpl->put_first(jbobj, frr, now);
432
433         /* The result of putting the first frame should not differ from OK. However, its possible
434            some implementations (i.e. adaptive's when resynch_threshold is specified) to drop it. */
435         if (res != AST_JB_IMPL_OK) {
436                 ast_log(LOG_WARNING, "Failed to put first frame in the jitterbuffer on channel '%s'\n", ast_channel_name(chan));
437                 /*
438                 jbimpl->destroy(jbobj);
439                 return -1;
440                 */
441         }
442
443         /* Init next */
444         jb->next = jbimpl->next(jbobj);
445
446         /* Init last format for a first time. */
447         jb->last_format = ao2_bump(frr->subclass.format);
448
449         /* Create a frame log file */
450         if (ast_test_flag(jbconf, AST_JB_LOG)) {
451                 struct ast_channel *bridged = ast_channel_bridge_peer(chan);
452                 char safe_logfile[30] = "/tmp/logfile-XXXXXX";
453                 int safe_fd;
454
455                 snprintf(name2, sizeof(name2), "%s", ast_channel_name(chan));
456                 while ((tmp = strchr(name2, '/'))) {
457                         *tmp = '#';
458                 }
459
460                 /* We should always have bridged chan if a jitterbuffer is in use */
461                 ast_assert(bridged != NULL);
462
463                 snprintf(name1, sizeof(name1), "%s", ast_channel_name(bridged));
464                 while ((tmp = strchr(name1, '/'))) {
465                         *tmp = '#';
466                 }
467
468                 snprintf(logfile_pathname, sizeof(logfile_pathname),
469                         "/tmp/ast_%s_jb_%s--%s.log", jbimpl->name, name1, name2);
470                 unlink(logfile_pathname);
471                 safe_fd = mkstemp(safe_logfile);
472                 if (safe_fd < 0 || link(safe_logfile, logfile_pathname) || unlink(safe_logfile) || !(jb->logfile = fdopen(safe_fd, "w+b"))) {
473                         ast_log(LOG_ERROR, "Failed to create frame log file with pathname '%s': %s\n", logfile_pathname, strerror(errno));
474                         jb->logfile = NULL;
475                         if (safe_fd > -1) {
476                                 close(safe_fd);
477                         }
478                 }
479
480                 if (res == AST_JB_IMPL_OK) {
481                         jb_framelog("JB_PUT_FIRST {now=%ld}: Queued frame with ts=%ld and len=%ld\n",
482                                 now, frr->ts, frr->len);
483                 } else {
484                         jb_framelog("JB_PUT_FIRST {now=%ld}: Dropped frame with ts=%ld and len=%ld\n",
485                                 now, frr->ts, frr->len);
486                 }
487
488                 ast_channel_cleanup(bridged);
489         }
490
491         ast_verb(3, "%s jitterbuffer created on channel %s\n", jbimpl->name, ast_channel_name(chan));
492
493         /* Free the frame if it has not been queued in the jb */
494         if (res != AST_JB_IMPL_OK) {
495                 ast_frfree(frr);
496         }
497
498         return 0;
499 }
500
501
502 void ast_jb_destroy(struct ast_channel *chan)
503 {
504         struct ast_jb *jb = ast_channel_jb(chan);
505         const struct ast_jb_impl *jbimpl = jb->impl;
506         void *jbobj = jb->jbobj;
507         struct ast_frame *f;
508
509         if (jb->logfile) {
510                 fclose(jb->logfile);
511                 jb->logfile = NULL;
512         }
513
514         ao2_cleanup(jb->last_format);
515
516         if (ast_test_flag(jb, JB_CREATED)) {
517                 /* Remove and free all frames still queued in jb */
518                 while (jbimpl->remove(jbobj, &f) == AST_JB_IMPL_OK) {
519                         ast_frfree(f);
520                 }
521
522                 jbimpl->destroy(jbobj);
523                 jb->jbobj = NULL;
524
525                 ast_clear_flag(jb, JB_CREATED);
526
527                 ast_verb(3, "%s jitterbuffer destroyed on channel %s\n", jbimpl->name, ast_channel_name(chan));
528         }
529 }
530
531
532 static long get_now(struct ast_jb *jb, struct timeval *when)
533 {
534         struct timeval now;
535
536         if (!when) {
537                 when = &now;
538                 gettimeofday(when, NULL);
539         }
540
541         return ast_tvdiff_ms(*when, jb->timebase);
542 }
543
544
545 int ast_jb_read_conf(struct ast_jb_conf *conf, const char *varname, const char *value)
546 {
547         int prefixlen = sizeof(AST_JB_CONF_PREFIX) - 1;
548         const char *name;
549         int tmp;
550
551         if (strncasecmp(AST_JB_CONF_PREFIX, varname, prefixlen)) {
552                 return -1;
553         }
554
555         name = varname + prefixlen;
556
557         if (!strcasecmp(name, AST_JB_CONF_ENABLE)) {
558                 ast_set2_flag(conf, ast_true(value), AST_JB_ENABLED);
559         } else if (!strcasecmp(name, AST_JB_CONF_FORCE)) {
560                 ast_set2_flag(conf, ast_true(value), AST_JB_FORCED);
561         } else if (!strcasecmp(name, AST_JB_CONF_MAX_SIZE)) {
562                 if ((tmp = atoi(value)) > 0)
563                         conf->max_size = tmp;
564         } else if (!strcasecmp(name, AST_JB_CONF_RESYNCH_THRESHOLD)) {
565                 if ((tmp = atoi(value)) > 0)
566                         conf->resync_threshold = tmp;
567         } else if (!strcasecmp(name, AST_JB_CONF_IMPL)) {
568                 if (!ast_strlen_zero(value))
569                         snprintf(conf->impl, sizeof(conf->impl), "%s", value);
570         } else if (!strcasecmp(name, AST_JB_CONF_TARGET_EXTRA)) {
571                 if (sscanf(value, "%30d", &tmp) == 1) {
572                         conf->target_extra = tmp;
573                 }
574         } else if (!strcasecmp(name, AST_JB_CONF_LOG)) {
575                 ast_set2_flag(conf, ast_true(value), AST_JB_LOG);
576         } else if (!strcasecmp(name, AST_JB_CONF_SYNC_VIDEO)) {
577                 ast_set2_flag(conf, ast_true(value), AST_JB_SYNC_VIDEO);
578         } else {
579                 return -1;
580         }
581
582         return 0;
583 }
584
585 void ast_jb_enable_for_channel(struct ast_channel *chan)
586 {
587         struct ast_jb_conf conf = ast_channel_jb(chan)->conf;
588         if (ast_test_flag(&conf, AST_JB_ENABLED)) {
589                 ast_jb_create_framehook(chan, &conf, 1);
590         }
591 }
592
593 void ast_jb_configure(struct ast_channel *chan, const struct ast_jb_conf *conf)
594 {
595         memcpy(&ast_channel_jb(chan)->conf, conf, sizeof(*conf));
596 }
597
598
599 void ast_jb_get_config(const struct ast_channel *chan, struct ast_jb_conf *conf)
600 {
601         memcpy(conf, &ast_channel_jb((struct ast_channel *) chan)->conf, sizeof(*conf));
602 }
603
604 void ast_jb_empty_and_reset(struct ast_channel *c0, struct ast_channel *c1)
605 {
606         struct ast_jb *jb0 = ast_channel_jb(c0);
607         struct ast_jb *jb1 = ast_channel_jb(c1);
608         int c0_use_jb = ast_test_flag(jb0, JB_USE);
609         int c0_jb_is_created = ast_test_flag(jb0, JB_CREATED);
610         int c1_use_jb = ast_test_flag(jb1, JB_USE);
611         int c1_jb_is_created = ast_test_flag(jb1, JB_CREATED);
612
613         if (c0_use_jb && c0_jb_is_created && jb0->impl->empty_and_reset) {
614                 jb0->impl->empty_and_reset(jb0->jbobj);
615         }
616
617         if (c1_use_jb && c1_jb_is_created && jb1->impl->empty_and_reset) {
618                 jb1->impl->empty_and_reset(jb1->jbobj);
619         }
620 }
621
622 /* Implementation functions */
623
624 /* fixed */
625 static void * jb_create_fixed(struct ast_jb_conf *general_config)
626 {
627         struct fixed_jb_conf conf;
628
629         conf.jbsize = general_config->max_size;
630         conf.resync_threshold = general_config->resync_threshold;
631
632         return fixed_jb_new(&conf);
633 }
634
635 static void jb_destroy_fixed(void *jb)
636 {
637         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
638
639         /* Ensure the fixed jb is empty - otherwise it will raise an ASSERT */
640         jb_empty_and_reset_fixed(jb);
641
642         /* destroy the jb */
643         fixed_jb_destroy(fixedjb);
644 }
645
646
647 static int jb_put_first_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_first(fixedjb, fin, fin->len, fin->ts, now);
653
654         return fixed_to_abstract_code[res];
655 }
656
657
658 static int jb_put_fixed(void *jb, struct ast_frame *fin, long now)
659 {
660         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
661         int res;
662
663         res = fixed_jb_put(fixedjb, fin, fin->len, fin->ts, now);
664
665         return fixed_to_abstract_code[res];
666 }
667
668
669 static int jb_get_fixed(void *jb, struct ast_frame **fout, long now, long interpl)
670 {
671         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
672         struct fixed_jb_frame frame = { .data = &ast_null_frame };
673         int res;
674
675         res = fixed_jb_get(fixedjb, &frame, now, interpl);
676         *fout = frame.data;
677
678         return fixed_to_abstract_code[res];
679 }
680
681
682 static long jb_next_fixed(void *jb)
683 {
684         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
685
686         return fixed_jb_next(fixedjb);
687 }
688
689
690 static int jb_remove_fixed(void *jb, struct ast_frame **fout)
691 {
692         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
693         struct fixed_jb_frame frame;
694         int res;
695
696         res = fixed_jb_remove(fixedjb, &frame);
697         *fout = frame.data;
698
699         return fixed_to_abstract_code[res];
700 }
701
702
703 static void jb_force_resynch_fixed(void *jb)
704 {
705         struct fixed_jb *fixedjb = (struct fixed_jb *) jb;
706
707         fixed_jb_set_force_resynch(fixedjb);
708 }
709
710 static void jb_empty_and_reset_fixed(void *jb)
711 {
712         struct fixed_jb *fixedjb = jb;
713         struct fixed_jb_frame f;
714
715         while (fixed_jb_remove(fixedjb, &f) == FIXED_JB_OK) {
716                 ast_frfree(f.data);
717         }
718 }
719
720 static int jb_is_late_fixed(void *jb, long ts)
721 {
722         return fixed_jb_is_late(jb, ts);
723 }
724
725 /* adaptive */
726
727 static void *jb_create_adaptive(struct ast_jb_conf *general_config)
728 {
729         jb_conf jbconf;
730         jitterbuf *adaptivejb;
731
732         adaptivejb = jb_new();
733         if (adaptivejb) {
734                 jbconf.max_jitterbuf = general_config->max_size;
735                 jbconf.resync_threshold = general_config->resync_threshold;
736                 jbconf.max_contig_interp = 10;
737                 jbconf.target_extra = general_config->target_extra;
738                 jb_setconf(adaptivejb, &jbconf);
739         }
740
741         return adaptivejb;
742 }
743
744
745 static void jb_destroy_adaptive(void *jb)
746 {
747         jitterbuf *adaptivejb = (jitterbuf *) jb;
748
749         jb_destroy(adaptivejb);
750 }
751
752
753 static int jb_put_first_adaptive(void *jb, struct ast_frame *fin, long now)
754 {
755         return jb_put_adaptive(jb, fin, now);
756 }
757
758
759 static int jb_put_adaptive(void *jb, struct ast_frame *fin, long now)
760 {
761         jitterbuf *adaptivejb = (jitterbuf *) jb;
762         int res;
763
764         res = jb_put(adaptivejb, fin, JB_TYPE_VOICE, fin->len, fin->ts, now);
765
766         return adaptive_to_abstract_code[res];
767 }
768
769
770 static int jb_get_adaptive(void *jb, struct ast_frame **fout, long now, long interpl)
771 {
772         jitterbuf *adaptivejb = (jitterbuf *) jb;
773         jb_frame frame = { .data = &ast_null_frame };
774         int res;
775
776         res = jb_get(adaptivejb, &frame, now, interpl);
777         *fout = frame.data;
778
779         return adaptive_to_abstract_code[res];
780 }
781
782
783 static long jb_next_adaptive(void *jb)
784 {
785         jitterbuf *adaptivejb = (jitterbuf *) jb;
786
787         return jb_next(adaptivejb);
788 }
789
790
791 static int jb_remove_adaptive(void *jb, struct ast_frame **fout)
792 {
793         jitterbuf *adaptivejb = (jitterbuf *) jb;
794         jb_frame frame;
795         int res;
796
797         res = jb_getall(adaptivejb, &frame);
798         *fout = frame.data;
799
800         return adaptive_to_abstract_code[res];
801 }
802
803
804 static void jb_force_resynch_adaptive(void *jb)
805 {
806 }
807
808 static void jb_empty_and_reset_adaptive(void *jb)
809 {
810         jitterbuf *adaptivejb = jb;
811         jb_frame f;
812
813         while (jb_getall(adaptivejb, &f) == JB_OK) {
814                 ast_frfree(f.data);
815         }
816
817         jb_reset(adaptivejb);
818 }
819
820 const struct ast_jb_impl *ast_jb_get_impl(enum ast_jb_type type)
821 {
822         int i;
823         for (i = 0; i < ARRAY_LEN(avail_impl); i++) {
824                 if (avail_impl[i].type == type) {
825                         return &avail_impl[i];
826                 }
827         }
828         return NULL;
829 }
830
831 static int jb_is_late_adaptive(void *jb, long ts)
832 {
833         return jb_is_late(jb, ts);
834 }
835
836 #define DEFAULT_TIMER_INTERVAL 20
837 #define DEFAULT_SIZE  200
838 #define DEFAULT_TARGET_EXTRA  40
839 #define DEFAULT_RESYNC  1000
840 #define DEFAULT_TYPE AST_JB_FIXED
841
842 struct jb_stream_sync {
843         unsigned int timestamp;
844         struct timeval ntp;
845 };
846
847 struct jb_framedata {
848         const struct ast_jb_impl *jb_impl;
849         struct ast_jb_conf jb_conf;
850         struct timeval start_tv;
851         struct ast_format *last_format;
852         struct ast_timer *timer;
853         int timer_interval; /* ms between deliveries */
854         int timer_fd;
855         int first;
856         int audio_stream_id;
857         struct jb_stream_sync audio_stream_sync;
858         int video_stream_id;
859         struct jb_stream_sync video_stream_sync;
860         AST_LIST_HEAD_NOLOCK(, ast_frame) early_frames;
861         unsigned int early_frame_count;
862         struct timeval last_audio_ntp_timestamp;
863         int audio_flowing;
864         void *jb_obj;
865 };
866
867 static void jb_framedata_destroy(struct jb_framedata *framedata)
868 {
869         struct ast_frame *frame;
870
871         if (framedata->timer) {
872                 ast_timer_close(framedata->timer);
873                 framedata->timer = NULL;
874         }
875         if (framedata->jb_impl && framedata->jb_obj) {
876                 struct ast_frame *f;
877                 while (framedata->jb_impl->remove(framedata->jb_obj, &f) == AST_JB_IMPL_OK) {
878                         ast_frfree(f);
879                 }
880                 framedata->jb_impl->destroy(framedata->jb_obj);
881                 framedata->jb_obj = NULL;
882         }
883         ao2_cleanup(framedata->last_format);
884         while ((frame = AST_LIST_REMOVE_HEAD(&framedata->early_frames, frame_list))) {
885                 ast_frfree(frame);
886         }
887         ast_free(framedata);
888 }
889
890 void ast_jb_conf_default(struct ast_jb_conf *conf)
891 {
892         ast_clear_flag(conf, AST_FLAGS_ALL);
893         conf->max_size = DEFAULT_SIZE;
894         conf->resync_threshold = DEFAULT_RESYNC;
895         ast_copy_string(conf->impl, "fixed", sizeof(conf->impl));
896         conf->target_extra = DEFAULT_TARGET_EXTRA;
897 }
898
899 static void datastore_destroy_cb(void *data) {
900         ast_free(data);
901         ast_debug(1, "JITTERBUFFER datastore destroyed\n");
902 }
903
904 static const struct ast_datastore_info jb_datastore = {
905         .type = "jitterbuffer",
906         .destroy = datastore_destroy_cb
907 };
908
909 static void hook_destroy_cb(void *framedata)
910 {
911         ast_debug(1, "JITTERBUFFER hook destroyed\n");
912         jb_framedata_destroy((struct jb_framedata *) framedata);
913 }
914
915 static struct timeval jitterbuffer_frame_get_ntp_timestamp(const struct jb_stream_sync *stream_sync, const struct ast_frame *frame)
916 {
917         int timestamp_diff;
918         unsigned int rate;
919
920         /* It's possible for us to receive frames before we receive the information allowing
921          * us to do NTP/RTP timestamp calculations. Since the information isn't available we
922          * can't generate one and give an empty timestamp.
923          */
924         if (ast_tvzero(stream_sync->ntp)) {
925                 return ast_tv(0, 0);
926         }
927
928         /* Convert the Asterisk timestamp into an RTP timestamp, and then based on the difference we can
929          * determine how many samples are in the frame and how long has elapsed since the synchronization
930          * RTP and NTP timestamps were received giving us the NTP timestamp for this frame.
931          */
932         if (frame->frametype == AST_FRAME_VOICE) {
933                 rate = ast_rtp_get_rate(frame->subclass.format);
934                 timestamp_diff = (frame->ts * (rate / 1000)) - stream_sync->timestamp;
935         } else {
936                 /* Video is special - internally we reference it as 1000 to preserve the RTP timestamp but
937                  * it is actualy 90000, this is why we can just directly subtract the timestamp.
938                  */
939                 rate = 90000;
940                 timestamp_diff = frame->ts - stream_sync->timestamp;
941         }
942
943         if (timestamp_diff < 0) {
944                 /* It's possible for us to be asked for an NTP timestamp from before our latest
945                  * RTCP SR report. To handle this we subtract so we go back in time.
946                  */
947                 return ast_tvsub(stream_sync->ntp, ast_samp2tv(abs(timestamp_diff), rate));
948         } else {
949                 return ast_tvadd(stream_sync->ntp, ast_samp2tv(timestamp_diff, rate));
950         }
951 }
952
953 static struct ast_frame *hook_event_cb(struct ast_channel *chan, struct ast_frame *frame, enum ast_framehook_event event, void *data)
954 {
955         struct jb_framedata *framedata = data;
956         struct timeval now_tv;
957         unsigned long now;
958         int putframe = 0; /* signifies if audio frame was placed into the buffer or not */
959
960         switch (event) {
961         case AST_FRAMEHOOK_EVENT_READ:
962                 break;
963         case AST_FRAMEHOOK_EVENT_ATTACHED:
964         case AST_FRAMEHOOK_EVENT_DETACHED:
965         case AST_FRAMEHOOK_EVENT_WRITE:
966                 return frame;
967         }
968
969         if (ast_channel_fdno(chan) == AST_JITTERBUFFER_FD && framedata->timer) {
970                 if (ast_timer_ack(framedata->timer, 1) < 0) {
971                         ast_log(LOG_ERROR, "Failed to acknowledge timer in jitter buffer\n");
972                         return frame;
973                 }
974         }
975
976         /*
977          * If the frame has been requeued (for instance when the translate core returns
978          * more than one frame) then if the frame is late we want to immediately return
979          * it. Otherwise attempt to insert it into the jitterbuffer.
980          *
981          * If the frame is requeued and late then in all likely hood it's a frame that
982          * that was previously retrieved from the jitterbuffer, passed to the translate
983          * core, and then put back into the channel read queue. Even if it had not been
984          * in the jitterbuffer prior to now it needs to be the next frame "out".
985          *
986          * However late arriving frames that have not been requeued (i.e. regular frames)
987          * need to be passed to the jitterbuffer so they can be appropriately dropped. As
988          * well any requeued frames that are not late should be put into the jitterbuffer.
989          */
990         if (!frame || (ast_test_flag(frame, AST_FRFLAG_REQUEUED) &&
991                        framedata->jb_impl->is_late(framedata->jb_obj, frame->ts))) {
992                 return frame;
993         }
994
995         if (ast_test_flag(&framedata->jb_conf, AST_JB_SYNC_VIDEO)) {
996                 if (frame->frametype == AST_FRAME_VOICE) {
997                         /* Store the stream identifier for the audio stream so we can associate the incoming RTCP SR
998                          * with the correct stream sync structure.
999                          */
1000                         framedata->audio_stream_id = frame->stream_num;
1001                 } else if (frame->frametype == AST_FRAME_RTCP && frame->subclass.integer == AST_RTP_RTCP_SR) {
1002                         struct ast_rtp_rtcp_report *rtcp_report = frame->data.ptr;
1003                         struct jb_stream_sync *stream_sync = NULL;
1004
1005                         /* Determine which stream this RTCP is in regards to */
1006                         if (framedata->audio_stream_id == frame->stream_num) {
1007                                 stream_sync = &framedata->audio_stream_sync;
1008                         } else if (framedata->video_stream_id == frame->stream_num) {
1009                                 stream_sync = &framedata->video_stream_sync;
1010                         }
1011
1012                         if (stream_sync) {
1013                                 /* Store the RTP and NTP timestamp mapping so we can derive an NTP timestamp for each frame */
1014                                 stream_sync->timestamp = rtcp_report->sender_information.rtp_timestamp;
1015                                 stream_sync->ntp = rtcp_report->sender_information.ntp_timestamp;
1016                         }
1017                 } else if (frame->frametype == AST_FRAME_VIDEO) {
1018                         /* If a video frame is late according to the audio timestamp don't stash it away, just return it.
1019                          * If however it is ahead then we keep it until such time as the audio catches up.
1020                          */
1021                         struct ast_frame *jbframe;
1022
1023                         framedata->video_stream_id = frame->stream_num;
1024
1025                         /* If no timing information is available we can't store this away, so just let it through now */
1026                         if (!ast_test_flag(frame, AST_FRFLAG_HAS_TIMING_INFO)) {
1027                                 return frame;
1028                         }
1029
1030                         /* To ensure that the video starts when the audio starts we only start allowing frames through once
1031                          * audio starts flowing.
1032                          */
1033                         if (framedata->audio_flowing) {
1034                                 struct timeval video_timestamp;
1035
1036                                 video_timestamp = jitterbuffer_frame_get_ntp_timestamp(&framedata->video_stream_sync, frame);
1037                                 if (ast_tvdiff_ms(framedata->last_audio_ntp_timestamp, video_timestamp) >= 0) {
1038                                         return frame;
1039                                 }
1040                         }
1041
1042                         /* To prevent the early frame buffer from growing uncontrolled we impose a maximum count that it can
1043                          * get to. If this is reached then we drop a video frame, which should cause the receiver to ask for a
1044                          * new key frame.
1045                          */
1046                         if (framedata->early_frame_count == MAXIMUM_EARLY_FRAME_COUNT) {
1047                                 jbframe = AST_LIST_REMOVE_HEAD(&framedata->early_frames, frame_list);
1048                                 framedata->early_frame_count--;
1049                                 ast_frfree(jbframe);
1050                         }
1051
1052                         jbframe = ast_frisolate(frame);
1053                         if (!jbframe) {
1054                                 /* If we can't isolate the frame the safest thing we can do is return it, even if the A/V sync
1055                                  * may be off.
1056                                  */
1057                                 return frame;
1058                         }
1059
1060                         AST_LIST_INSERT_TAIL(&framedata->early_frames, jbframe, frame_list);
1061                         framedata->early_frame_count++;
1062                         return &ast_null_frame;
1063                 }
1064         }
1065
1066         now_tv = ast_tvnow();
1067         now = ast_tvdiff_ms(now_tv, framedata->start_tv);
1068
1069         if (frame->frametype == AST_FRAME_VOICE) {
1070                 int res;
1071                 struct ast_frame *jbframe;
1072
1073                 if (!ast_test_flag(frame, AST_FRFLAG_HAS_TIMING_INFO) || frame->len < 2 || frame->ts < 0) {
1074                         /* only frames with timing info can enter the jitterbuffer */
1075                         return frame;
1076                 }
1077
1078                 jbframe = ast_frisolate(frame);
1079                 ao2_replace(framedata->last_format, frame->subclass.format);
1080
1081                 if (frame->len && (frame->len != framedata->timer_interval)) {
1082                         framedata->timer_interval = frame->len;
1083                         ast_timer_set_rate(framedata->timer, 1000 / framedata->timer_interval);
1084                 }
1085                 if (!framedata->first) {
1086                         framedata->first = 1;
1087                         res = framedata->jb_impl->put_first(framedata->jb_obj, jbframe, now);
1088                 } else {
1089                         res = framedata->jb_impl->put(framedata->jb_obj, jbframe, now);
1090                 }
1091
1092                 if (res == AST_JB_IMPL_OK) {
1093                         if (jbframe != frame) {
1094                                 ast_frfree(frame);
1095                         }
1096                         frame = &ast_null_frame;
1097                 } else if (jbframe != frame) {
1098                         ast_frfree(jbframe);
1099                 }
1100                 putframe = 1;
1101         }
1102
1103         if (frame->frametype == AST_FRAME_NULL) {
1104                 int res;
1105                 long next = framedata->jb_impl->next(framedata->jb_obj);
1106
1107                 /* If now is earlier than the next expected output frame
1108                  * from the jitterbuffer we may choose to pass on retrieving
1109                  * a frame during this read iteration.  The only exception
1110                  * to this rule is when an audio frame is placed into the buffer
1111                  * and the time for the next frame to come out of the buffer is
1112                  * at least within the timer_interval of the next output frame. By
1113                  * doing this we are able to feed off the timing of the input frames
1114                  * and only rely on our jitterbuffer timer when frames are dropped.
1115                  * During testing, this hybrid form of timing gave more reliable results. */
1116                 if (now < next) {
1117                         long int diff = next - now;
1118                         if (!putframe) {
1119                                 return frame;
1120                         } else if (diff >= framedata->timer_interval) {
1121                                 return frame;
1122                         }
1123                 }
1124
1125                 ast_frfree(frame);
1126                 frame = &ast_null_frame;
1127                 res = framedata->jb_impl->get(framedata->jb_obj, &frame, now, framedata->timer_interval);
1128                 switch (res) {
1129                 case AST_JB_IMPL_OK:
1130                         /* got it, and pass it through */
1131                         break;
1132                 case AST_JB_IMPL_DROP:
1133                         ast_frfree(frame);
1134                         frame = &ast_null_frame;
1135                         break;
1136                 case AST_JB_IMPL_INTERP:
1137                         if (framedata->last_format) {
1138                                 struct ast_frame tmp = { 0, };
1139
1140                                 tmp.frametype = AST_FRAME_VOICE;
1141                                 tmp.subclass.format = framedata->last_format;
1142                                 /* example: 8000hz / (1000 / 20ms) = 160 samples */
1143                                 tmp.samples = ast_format_get_sample_rate(framedata->last_format) / (1000 / framedata->timer_interval);
1144                                 tmp.delivery = ast_tvadd(framedata->start_tv, ast_samp2tv(next, 1000));
1145                                 tmp.offset = AST_FRIENDLY_OFFSET;
1146                                 tmp.src  = "func_jitterbuffer interpolation";
1147                                 ast_frfree(frame);
1148                                 frame = ast_frdup(&tmp);
1149                                 break;
1150                         }
1151                         /* else fall through */
1152                 case AST_JB_IMPL_NOFRAME:
1153                         ast_frfree(frame);
1154                         frame = &ast_null_frame;
1155                         break;
1156                 }
1157         }
1158
1159         if (frame->frametype == AST_FRAME_CONTROL) {
1160                 struct ast_frame *early_frame;
1161
1162                 switch(frame->subclass.integer) {
1163                 case AST_CONTROL_HOLD:
1164                 case AST_CONTROL_UNHOLD:
1165                 case AST_CONTROL_T38_PARAMETERS:
1166                 case AST_CONTROL_SRCUPDATE:
1167                 case AST_CONTROL_SRCCHANGE:
1168                         framedata->jb_impl->force_resync(framedata->jb_obj);
1169                         /* Since we are resyncing go ahead and clear out the video frames too */
1170                         while ((early_frame = AST_LIST_REMOVE_HEAD(&framedata->early_frames, frame_list))) {
1171                                 ast_frfree(early_frame);
1172                         }
1173                         framedata->audio_flowing = 0;
1174                         framedata->early_frame_count = 0;
1175                         break;
1176                 default:
1177                         break;
1178                 }
1179         }
1180
1181         /* If a voice frame is being passed through see if we need to add any additional frames to it */
1182         if (ast_test_flag(&framedata->jb_conf, AST_JB_SYNC_VIDEO) && frame->frametype == AST_FRAME_VOICE) {
1183                 AST_LIST_HEAD_NOLOCK(, ast_frame) additional_frames;
1184                 struct ast_frame *early_frame;
1185
1186                 /* We store the last NTP timestamp for the audio given to the core so that subsequents frames which
1187                  * are late can be passed immediately through (this will occur for video frames which are returned here)
1188                  */
1189                 framedata->last_audio_ntp_timestamp = jitterbuffer_frame_get_ntp_timestamp(&framedata->audio_stream_sync, frame);
1190                 framedata->audio_flowing = 1;
1191
1192                 AST_LIST_HEAD_INIT_NOLOCK(&additional_frames);
1193
1194                 AST_LIST_TRAVERSE_SAFE_BEGIN(&framedata->early_frames, early_frame, frame_list) {
1195                         struct timeval early_timestamp = jitterbuffer_frame_get_ntp_timestamp(&framedata->video_stream_sync, early_frame);
1196                         int diff = ast_tvdiff_ms(framedata->last_audio_ntp_timestamp, early_timestamp);
1197
1198                         /* If this frame is from the past we need to include it with the audio frame that is going
1199                          * out.
1200                          */
1201                         if (diff >= 0) {
1202                                 AST_LIST_REMOVE_CURRENT(frame_list);
1203                                 framedata->early_frame_count--;
1204                                 AST_LIST_INSERT_TAIL(&additional_frames, early_frame, frame_list);
1205                         }
1206                 }
1207                 AST_LIST_TRAVERSE_SAFE_END;
1208
1209                 /* Append any additional frames we may want to include (such as video) */
1210                 AST_LIST_NEXT(frame, frame_list) = AST_LIST_FIRST(&additional_frames);
1211         }
1212
1213         return frame;
1214 }
1215
1216 /* set defaults */
1217 static int jb_framedata_init(struct jb_framedata *framedata, struct ast_jb_conf *jb_conf)
1218 {
1219         int jb_impl_type = DEFAULT_TYPE;
1220         /* Initialize defaults */
1221         framedata->timer_fd = -1;
1222         memcpy(&framedata->jb_conf, jb_conf, sizeof(*jb_conf));
1223
1224         /* Figure out implementation type from the configuration implementation string */
1225         if (!ast_strlen_zero(jb_conf->impl)) {
1226                 if (!strcasecmp(jb_conf->impl, "fixed")) {
1227                         jb_impl_type = AST_JB_FIXED;
1228                 } else if (!strcasecmp(jb_conf->impl, "adaptive")) {
1229                         jb_impl_type = AST_JB_ADAPTIVE;
1230                 } else {
1231                         ast_log(LOG_WARNING, "Unknown Jitterbuffer type %s. Failed to create jitterbuffer.\n", jb_conf->impl);
1232                         return -1;
1233                 }
1234         }
1235
1236         if (!(framedata->jb_impl = ast_jb_get_impl(jb_impl_type))) {
1237                 return -1;
1238         }
1239
1240         if (!(framedata->timer = ast_timer_open())) {
1241                 return -1;
1242         }
1243
1244         framedata->audio_stream_id = -1;
1245         framedata->video_stream_id = -1;
1246         AST_LIST_HEAD_INIT_NOLOCK(&framedata->early_frames);
1247         framedata->timer_fd = ast_timer_fd(framedata->timer);
1248         framedata->timer_interval = DEFAULT_TIMER_INTERVAL;
1249         ast_timer_set_rate(framedata->timer, 1000 / framedata->timer_interval);
1250         framedata->start_tv = ast_tvnow();
1251
1252         framedata->jb_obj = framedata->jb_impl->create(&framedata->jb_conf);
1253         return 0;
1254 }
1255
1256
1257 void ast_jb_create_framehook(struct ast_channel *chan, struct ast_jb_conf *jb_conf, int prefer_existing)
1258 {
1259         struct jb_framedata *framedata;
1260         struct ast_datastore *datastore = NULL;
1261         struct ast_framehook_interface interface = {
1262                 .version = AST_FRAMEHOOK_INTERFACE_VERSION,
1263                 .event_cb = hook_event_cb,
1264                 .destroy_cb = hook_destroy_cb,
1265         };
1266         int i = 0;
1267
1268         /* If disabled, strip any existing jitterbuffer and don't replace it. */
1269         if (!strcasecmp(jb_conf->impl, "disabled")) {
1270                 int *id;
1271                 ast_channel_lock(chan);
1272                 if ((datastore = ast_channel_datastore_find(chan, &jb_datastore, NULL))) {
1273                         id = datastore->data;
1274                         ast_framehook_detach(chan, *id);
1275                         ast_channel_datastore_remove(chan, datastore);
1276                         ast_datastore_free(datastore);
1277                 }
1278                 ast_channel_unlock(chan);
1279                 return;
1280         }
1281
1282         if (!(framedata = ast_calloc(1, sizeof(*framedata)))) {
1283                 return;
1284         }
1285
1286         if (jb_framedata_init(framedata, jb_conf)) {
1287                 jb_framedata_destroy(framedata);
1288                 return;
1289         }
1290
1291         interface.data = framedata;
1292
1293         ast_channel_lock(chan);
1294         i = ast_framehook_attach(chan, &interface);
1295         if (i >= 0) {
1296                 int *id;
1297                 if ((datastore = ast_channel_datastore_find(chan, &jb_datastore, NULL))) {
1298                         /* There is already a jitterbuffer on the channel. */
1299                         if (prefer_existing) {
1300                                 /* We prefer the existing jitterbuffer, so remove the new one and keep the old one. */
1301                                 ast_framehook_detach(chan, i);
1302                                 ast_channel_unlock(chan);
1303                                 return;
1304                         }
1305                         /* We prefer the new jitterbuffer, so strip the old one. */
1306                         id = datastore->data;
1307                         ast_framehook_detach(chan, *id);
1308                         ast_channel_datastore_remove(chan, datastore);
1309                         ast_datastore_free(datastore);
1310                 }
1311
1312                 if (!(datastore = ast_datastore_alloc(&jb_datastore, NULL))) {
1313                         ast_framehook_detach(chan, i);
1314                         ast_channel_unlock(chan);
1315                         return;
1316                 }
1317
1318                 if (!(id = ast_calloc(1, sizeof(int)))) {
1319                         ast_datastore_free(datastore);
1320                         ast_framehook_detach(chan, i);
1321                         ast_channel_unlock(chan);
1322                         return;
1323                 }
1324
1325                 *id = i; /* Store off the id. The channel is still locked so it is safe to access this ptr. */
1326                 datastore->data = id;
1327                 ast_channel_datastore_add(chan, datastore);
1328
1329                 ast_channel_set_fd(chan, AST_JITTERBUFFER_FD, framedata->timer_fd);
1330         } else {
1331                 jb_framedata_destroy(framedata);
1332                 framedata = NULL;
1333         }
1334         ast_channel_unlock(chan);
1335 }