2e89e9a7d8da721d30e575947f219e6b175f843d
[asterisk/asterisk.git] / main / codec_builtin.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2014, Digium, Inc.
5  *
6  * Joshua Colp <jcolp@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 /*! \file
20  *
21  * \brief Built-in supported codecs
22  *
23  * \author Joshua Colp <jcolp@digium.com>
24  */
25
26 /*** MODULEINFO
27         <support_level>core</support_level>
28  ***/
29
30 #include "asterisk.h"
31
32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
33
34 #include "asterisk/logger.h"
35 #include "asterisk/astobj2.h"
36 #include "asterisk/codec.h"
37 #include "asterisk/format.h"
38 #include "asterisk/format_cache.h"
39 #include "asterisk/frame.h"
40
41 enum frame_type {
42         TYPE_HIGH,     /* 0x0 */
43         TYPE_LOW,      /* 0x1 */
44         TYPE_SILENCE,  /* 0x2 */
45         TYPE_DONTSEND  /* 0x3 */
46 };
47
48 #define TYPE_MASK 0x3
49
50 static int g723_len(unsigned char buf)
51 {
52         enum frame_type type = buf & TYPE_MASK;
53
54         switch(type) {
55         case TYPE_DONTSEND:
56                 return 0;
57                 break;
58         case TYPE_SILENCE:
59                 return 4;
60                 break;
61         case TYPE_HIGH:
62                 return 24;
63                 break;
64         case TYPE_LOW:
65                 return 20;
66                 break;
67         default:
68                 ast_log(LOG_WARNING, "Badly encoded frame (%u)\n", type);
69         }
70         return -1;
71 }
72
73 static int g723_samples(struct ast_frame *frame)
74 {
75         unsigned char *buf = frame->data.ptr;
76         int pos = 0, samples = 0, res;
77
78         while(pos < frame->datalen) {
79                 res = g723_len(buf[pos]);
80                 if (res <= 0)
81                         break;
82                 samples += 240;
83                 pos += res;
84         }
85
86         return samples;
87 }
88
89 static int g723_length(unsigned int samples)
90 {
91         return (samples / 240) * 20;
92 }
93
94 static struct ast_codec g723 = {
95         .name = "g723",
96         .description = "G.723.1",
97         .type = AST_MEDIA_TYPE_AUDIO,
98         .sample_rate = 8000,
99         .minimum_ms = 30,
100         .maximum_ms = 300,
101         .default_ms = 30,
102         .minimum_bytes = 20,
103         .samples_count = g723_samples,
104         .get_length = g723_length,
105 };
106
107 static int none_samples(struct ast_frame *frame)
108 {
109         return frame->datalen;
110 }
111
112 static int none_length(unsigned int samples) {
113         return samples;
114 }
115
116 static struct ast_codec none = {
117         .name = "none",
118         .description = "<Null> codec",
119         .type = AST_MEDIA_TYPE_AUDIO,
120         .sample_rate = 8000, /* This must have some sample rate to prevent divide by 0 */
121         .minimum_ms = 10,
122         .maximum_ms = 150,
123         .default_ms = 20,
124         .minimum_bytes = 20,
125         .samples_count = none_samples,
126         .get_length = none_length,
127 };
128
129 static int ulaw_samples(struct ast_frame *frame)
130 {
131         return frame->datalen;
132 }
133
134 static int ulaw_length(unsigned int samples)
135 {
136         return samples;
137 }
138
139 static struct ast_codec ulaw = {
140         .name = "ulaw",
141         .description = "G.711 u-law",
142         .type = AST_MEDIA_TYPE_AUDIO,
143         .sample_rate = 8000,
144         .minimum_ms = 10,
145         .maximum_ms = 150,
146         .default_ms = 20,
147         .minimum_bytes = 80,
148         .samples_count = ulaw_samples,
149         .get_length = ulaw_length,
150         .smooth = 1,
151 };
152
153 static struct ast_codec alaw = {
154         .name = "alaw",
155         .description = "G.711 a-law",
156         .type = AST_MEDIA_TYPE_AUDIO,
157         .sample_rate = 8000,
158         .minimum_ms = 10,
159         .maximum_ms = 150,
160         .default_ms = 20,
161         .minimum_bytes = 80,
162         .samples_count = ulaw_samples,
163         .get_length = ulaw_length,
164         .smooth = 1,
165 };
166
167 static int gsm_samples(struct ast_frame *frame)
168 {
169         return 160 * (frame->datalen / 33);
170 }
171
172 static int gsm_length(unsigned int samples)
173 {
174         return (samples / 160) * 33;
175 }
176
177 static struct ast_codec gsm = {
178         .name = "gsm",
179         .description = "GSM",
180         .type = AST_MEDIA_TYPE_AUDIO,
181         .sample_rate = 8000,
182         .minimum_ms = 20,
183         .maximum_ms = 300,
184         .default_ms = 20,
185         .minimum_bytes = 33,
186         .samples_count = gsm_samples,
187         .get_length = gsm_length,
188         .smooth = 1,
189 };
190
191 static int g726_samples(struct ast_frame *frame)
192 {
193         return frame->datalen * 2;
194 }
195
196 static int g726_length(unsigned int samples)
197 {
198         return samples / 2;
199 }
200
201 static struct ast_codec g726rfc3551 = {
202         .name = "g726",
203         .description = "G.726 RFC3551",
204         .type = AST_MEDIA_TYPE_AUDIO,
205         .sample_rate = 8000,
206         .minimum_ms = 10,
207         .maximum_ms = 300,
208         .default_ms = 20,
209         .minimum_bytes = 40,
210         .samples_count = g726_samples,
211         .get_length = g726_length,
212         .smooth = 1,
213 };
214
215 static struct ast_codec g726aal2 = {
216         .name = "g726aal2",
217         .description = "G.726 AAL2",
218         .type = AST_MEDIA_TYPE_AUDIO,
219         .sample_rate = 8000,
220         .minimum_ms = 10,
221         .maximum_ms = 300,
222         .default_ms = 20,
223         .minimum_bytes = 40,
224         .samples_count = g726_samples,
225         .get_length = g726_length,
226         .smooth = 1,
227 };
228
229 static struct ast_codec adpcm = {
230         .name = "adpcm",
231         .description = "Dialogic ADPCM",
232         .type = AST_MEDIA_TYPE_AUDIO,
233         .sample_rate = 8000,
234         .minimum_ms = 10,
235         .maximum_ms = 300,
236         .default_ms = 20,
237         .minimum_bytes = 40,
238         .samples_count = g726_samples,
239         .get_length = g726_length,
240         .smooth = 1,
241 };
242
243 static int slin_samples(struct ast_frame *frame)
244 {
245         return frame->datalen / 2;
246 }
247
248 static int slin_length(unsigned int samples)
249 {
250         return samples * 2;
251 }
252
253 static struct ast_codec slin8 = {
254         .name = "slin",
255         .description = "16 bit Signed Linear PCM",
256         .type = AST_MEDIA_TYPE_AUDIO,
257         .sample_rate = 8000,
258         .minimum_ms = 10,
259         .maximum_ms = 70,
260         .default_ms = 20,
261         .minimum_bytes = 160,
262         .samples_count = slin_samples,
263         .get_length = slin_length,
264         .smooth = 1,
265 };
266
267 static struct ast_codec slin12 = {
268         .name = "slin",
269         .description = "16 bit Signed Linear PCM (12kHz)",
270         .type = AST_MEDIA_TYPE_AUDIO,
271         .sample_rate = 12000,
272         .minimum_ms = 10,
273         .maximum_ms = 70,
274         .default_ms = 20,
275         .minimum_bytes = 240,
276         .samples_count = slin_samples,
277         .get_length = slin_length,
278         .smooth = 1,
279 };
280
281 static struct ast_codec slin16 = {
282         .name = "slin",
283         .description = "16 bit Signed Linear PCM (16kHz)",
284         .type = AST_MEDIA_TYPE_AUDIO,
285         .sample_rate = 16000,
286         .minimum_ms = 10,
287         .maximum_ms = 70,
288         .default_ms = 20,
289         .minimum_bytes = 320,
290         .samples_count = slin_samples,
291         .get_length = slin_length,
292         .smooth = 1,
293 };
294
295 static struct ast_codec slin24 = {
296         .name = "slin",
297         .description = "16 bit Signed Linear PCM (24kHz)",
298         .type = AST_MEDIA_TYPE_AUDIO,
299         .sample_rate = 24000,
300         .minimum_ms = 10,
301         .maximum_ms = 70,
302         .default_ms = 20,
303         .minimum_bytes = 480,
304         .samples_count = slin_samples,
305         .get_length = slin_length,
306         .smooth = 1,
307 };
308
309 static struct ast_codec slin32 = {
310         .name = "slin",
311         .description = "16 bit Signed Linear PCM (32kHz)",
312         .type = AST_MEDIA_TYPE_AUDIO,
313         .sample_rate = 32000,
314         .minimum_ms = 10,
315         .maximum_ms = 70,
316         .default_ms = 20,
317         .minimum_bytes = 640,
318         .samples_count = slin_samples,
319         .get_length = slin_length,
320         .smooth = 1,
321 };
322
323 static struct ast_codec slin44 = {
324         .name = "slin",
325         .description = "16 bit Signed Linear PCM (44kHz)",
326         .type = AST_MEDIA_TYPE_AUDIO,
327         .sample_rate = 44100,
328         .minimum_ms = 10,
329         .maximum_ms = 70,
330         .default_ms = 20,
331         .minimum_bytes = 882,
332         .samples_count = slin_samples,
333         .get_length = slin_length,
334         .smooth = 1,
335 };
336
337 static struct ast_codec slin48 = {
338         .name = "slin",
339         .description = "16 bit Signed Linear PCM (48kHz)",
340         .type = AST_MEDIA_TYPE_AUDIO,
341         .sample_rate = 48000,
342         .minimum_ms = 10,
343         .maximum_ms = 70,
344         .default_ms = 20,
345         .minimum_bytes = 960,
346         .samples_count = slin_samples,
347         .get_length = slin_length,
348         .smooth = 1,
349 };
350
351 static struct ast_codec slin96 = {
352         .name = "slin",
353         .description = "16 bit Signed Linear PCM (96kHz)",
354         .type = AST_MEDIA_TYPE_AUDIO,
355         .sample_rate = 96000,
356         .minimum_ms = 10,
357         .maximum_ms = 70,
358         .default_ms = 20,
359         .minimum_bytes = 1920,
360         .samples_count = slin_samples,
361         .get_length = slin_length,
362         .smooth = 1,
363 };
364
365 static struct ast_codec slin192 = {
366         .name = "slin",
367         .description = "16 bit Signed Linear PCM (192kHz)",
368         .type = AST_MEDIA_TYPE_AUDIO,
369         .sample_rate = 192000,
370         .minimum_ms = 10,
371         .maximum_ms = 70,
372         .default_ms = 20,
373         .minimum_bytes = 3840,
374         .samples_count = slin_samples,
375         .get_length = slin_length,
376         .smooth = 1,
377 };
378
379 static int lpc10_samples(struct ast_frame *frame)
380 {
381         int samples = 22 * 8;
382
383         /* assumes that the RTP packet contains one LPC10 frame */
384         samples += (((char *)(frame->data.ptr))[7] & 0x1) * 8;
385
386         return samples;
387 }
388
389 static struct ast_codec lpc10 = {
390         .name = "lpc10",
391         .description = "LPC10",
392         .type = AST_MEDIA_TYPE_AUDIO,
393         .sample_rate = 8000,
394         .minimum_ms = 20,
395         .maximum_ms = 20,
396         .default_ms = 20,
397         .minimum_bytes = 7,
398         .samples_count = lpc10_samples,
399         .smooth = 1,
400 };
401
402 static int g729_samples(struct ast_frame *frame)
403 {
404         return frame->datalen * 8;
405 }
406
407 static int g729_length(unsigned int samples)
408 {
409         return samples / 8;
410 }
411
412 static struct ast_codec g729a = {
413         .name = "g729",
414         .description = "G.729A",
415         .type = AST_MEDIA_TYPE_AUDIO,
416         .sample_rate = 8000,
417         .minimum_ms = 10,
418         .maximum_ms = 230,
419         .default_ms = 20,
420         .minimum_bytes = 10,
421         .samples_count = g729_samples,
422         .get_length = g729_length,
423         .smooth = 1,
424 };
425
426 static unsigned char get_n_bits_at(unsigned char *data, int n, int bit)
427 {
428         int byte = bit / 8;       /* byte containing first bit */
429         int rem = 8 - (bit % 8);  /* remaining bits in first byte */
430         unsigned char ret = 0;
431
432         if (n <= 0 || n > 8)
433                 return 0;
434
435         if (rem < n) {
436                 ret = (data[byte] << (n - rem));
437                 ret |= (data[byte + 1] >> (8 - n + rem));
438         } else {
439                 ret = (data[byte] >> (rem - n));
440         }
441
442         return (ret & (0xff >> (8 - n)));
443 }
444
445 static int speex_get_wb_sz_at(unsigned char *data, int len, int bit)
446 {
447         static const int SpeexWBSubModeSz[] = {
448                 4, 36, 112, 192,
449                 352, 0, 0, 0 };
450         int off = bit;
451         unsigned char c;
452
453         /* skip up to two wideband frames */
454         if (((len * 8 - off) >= 5) &&
455                 get_n_bits_at(data, 1, off)) {
456                 c = get_n_bits_at(data, 3, off + 1);
457                 off += SpeexWBSubModeSz[c];
458
459                 if (((len * 8 - off) >= 5) &&
460                         get_n_bits_at(data, 1, off)) {
461                         c = get_n_bits_at(data, 3, off + 1);
462                         off += SpeexWBSubModeSz[c];
463
464                         if (((len * 8 - off) >= 5) &&
465                                 get_n_bits_at(data, 1, off)) {
466                                 ast_log(LOG_WARNING, "Encountered corrupt speex frame; too many wideband frames in a row.\n");
467                                 return -1;
468                         }
469                 }
470
471         }
472         return off - bit;
473 }
474
475 static int speex_samples(unsigned char *data, int len)
476 {
477         static const int SpeexSubModeSz[] = {
478                 5, 43, 119, 160,
479                 220, 300, 364, 492,
480                 79, 0, 0, 0,
481                 0, 0, 0, 0 };
482         static const int SpeexInBandSz[] = {
483                 1, 1, 4, 4,
484                 4, 4, 4, 4,
485                 8, 8, 16, 16,
486                 32, 32, 64, 64 };
487         int bit = 0;
488         int cnt = 0;
489         int off;
490         unsigned char c;
491
492         while ((len * 8 - bit) >= 5) {
493                 /* skip wideband frames */
494                 off = speex_get_wb_sz_at(data, len, bit);
495                 if (off < 0)  {
496                         ast_log(LOG_WARNING, "Had error while reading wideband frames for speex samples\n");
497                         break;
498                 }
499                 bit += off;
500
501                 if ((len * 8 - bit) < 5)
502                         break;
503
504                 /* get control bits */
505                 c = get_n_bits_at(data, 5, bit);
506                 bit += 5;
507
508                 if (c == 15) {
509                         /* terminator */
510                         break;
511                 } else if (c == 14) {
512                         /* in-band signal; next 4 bits contain signal id */
513                         c = get_n_bits_at(data, 4, bit);
514                         bit += 4;
515                         bit += SpeexInBandSz[c];
516                 } else if (c == 13) {
517                         /* user in-band; next 4 bits contain msg len */
518                         c = get_n_bits_at(data, 4, bit);
519                         bit += 4;
520                         /* after which it's 5-bit signal id + c bytes of data */
521                         bit += 5 + c * 8;
522                 } else if (c > 8) {
523                         /* unknown */
524                         ast_log(LOG_WARNING, "Unknown speex control frame %d\n", c);
525                         break;
526                 } else {
527                         /* skip number bits for submode (less the 5 control bits) */
528                         bit += SpeexSubModeSz[c] - 5;
529                         cnt += 160; /* new frame */
530                 }
531         }
532         return cnt;
533 }
534
535 static int speex8_samples(struct ast_frame *frame)
536 {
537         return speex_samples(frame->data.ptr, frame->datalen);
538 }
539
540 static struct ast_codec speex8 = {
541         .name = "speex",
542         .description = "SpeeX",
543         .type = AST_MEDIA_TYPE_AUDIO,
544         .sample_rate = 8000,
545         .minimum_ms = 10,
546         .maximum_ms = 60,
547         .default_ms = 20,
548         .minimum_bytes = 10,
549         .samples_count = speex8_samples,
550 };
551
552 static int speex16_samples(struct ast_frame *frame)
553 {
554         return 2 * speex_samples(frame->data.ptr, frame->datalen);
555 }
556
557 static struct ast_codec speex16 = {
558         .name = "speex",
559         .description = "SpeeX 16khz",
560         .type = AST_MEDIA_TYPE_AUDIO,
561         .sample_rate = 16000,
562         .minimum_ms = 10,
563         .maximum_ms = 60,
564         .default_ms = 20,
565         .minimum_bytes = 10,
566         .samples_count = speex16_samples,
567 };
568
569 static int speex32_samples(struct ast_frame *frame)
570 {
571         return 4 * speex_samples(frame->data.ptr, frame->datalen);
572 }
573
574 static struct ast_codec speex32 = {
575         .name = "speex",
576         .description = "SpeeX 32khz",
577         .type = AST_MEDIA_TYPE_AUDIO,
578         .sample_rate = 32000,
579         .minimum_ms = 10,
580         .maximum_ms = 60,
581         .default_ms = 20,
582         .minimum_bytes = 10,
583         .samples_count = speex32_samples,
584 };
585
586 static int ilbc_samples(struct ast_frame *frame)
587 {
588         return 240 * (frame->datalen / 50);
589 }
590
591 static struct ast_codec ilbc = {
592         .name = "ilbc",
593         .description = "iLBC",
594         .type = AST_MEDIA_TYPE_AUDIO,
595         .sample_rate = 8000,
596         .minimum_ms = 30,
597         .maximum_ms = 30,
598         .default_ms = 30,
599         .minimum_bytes = 50,
600         .samples_count = ilbc_samples,
601         .smooth = 1,
602 };
603
604 static struct ast_codec g722 = {
605         .name = "g722",
606         .description = "G722",
607         .type = AST_MEDIA_TYPE_AUDIO,
608         .sample_rate = 16000,
609         .minimum_ms = 10,
610         .maximum_ms = 150,
611         .default_ms = 20,
612         .minimum_bytes = 80,
613         .samples_count = g726_samples,
614         .get_length = g726_length,
615         .smooth = 1,
616 };
617
618 static int siren7_samples(struct ast_frame *frame)
619 {
620         return frame->datalen * (16000 / 4000);
621 }
622
623 static int siren7_length(unsigned int samples)
624 {
625         return samples / (16000 / 4000);
626 }
627
628 static struct ast_codec siren7 = {
629         .name = "siren7",
630         .description = "ITU G.722.1 (Siren7, licensed from Polycom)",
631         .type = AST_MEDIA_TYPE_AUDIO,
632         .sample_rate = 16000,
633         .minimum_ms = 20,
634         .maximum_ms = 80,
635         .default_ms = 20,
636         .minimum_bytes = 80,
637         .samples_count = siren7_samples,
638         .get_length = siren7_length,
639 };
640
641 static int siren14_samples(struct ast_frame *frame)
642 {
643         return (int) frame->datalen * ((float) 32000 / 6000);
644 }
645
646 static int siren14_length(unsigned int samples)
647 {
648         return (int) samples / ((float) 32000 / 6000);;
649 }
650
651 static struct ast_codec siren14 = {
652         .name = "siren14",
653         .description = "ITU G.722.1 Annex C, (Siren14, licensed from Polycom)",
654         .type = AST_MEDIA_TYPE_AUDIO,
655         .sample_rate = 32000,
656         .minimum_ms = 20,
657         .maximum_ms = 80,
658         .default_ms = 20,
659         .minimum_bytes = 120,
660         .samples_count = siren14_samples,
661         .get_length = siren14_length,
662 };
663
664 static struct ast_codec testlaw = {
665         .name = "testlaw",
666         .description = "G.711 test-law",
667         .type = AST_MEDIA_TYPE_AUDIO,
668         .sample_rate = 8000,
669         .minimum_ms = 10,
670         .maximum_ms = 150,
671         .default_ms = 20,
672         .minimum_bytes = 80,
673         .samples_count = ulaw_samples,
674         .get_length = ulaw_length,
675         .smooth = 1,
676 };
677
678 static int g719_samples(struct ast_frame *frame)
679 {
680         return (int) frame->datalen * ((float) 48000 / 8000);
681 }
682
683 static int g719_length(unsigned int samples)
684 {
685         return (int) samples / ((float) 48000 / 8000);
686 }
687
688 static struct ast_codec g719 = {
689         .name = "g719",
690         .description = "ITU G.719",
691         .type = AST_MEDIA_TYPE_AUDIO,
692         .sample_rate = 48000,
693         .minimum_ms = 20,
694         .maximum_ms = 80,
695         .default_ms = 20,
696         .minimum_bytes = 160,
697         .samples_count = g719_samples,
698         .get_length = g719_length,
699 };
700
701 static struct ast_codec opus = {
702         .name = "opus",
703         .description = "Opus Codec",
704         .type = AST_MEDIA_TYPE_AUDIO,
705         .sample_rate = 48000,
706         .minimum_ms = 20,
707         .maximum_ms = 60,
708         .default_ms = 20,
709         .minimum_bytes = 10,
710 };
711
712 static struct ast_codec jpeg = {
713         .name = "jpeg",
714         .description = "JPEG image",
715         .type = AST_MEDIA_TYPE_IMAGE,
716 };
717
718 static struct ast_codec png = {
719         .name = "png",
720         .description = "PNG Image",
721         .type = AST_MEDIA_TYPE_IMAGE,
722 };
723
724 static struct ast_codec h261 = {
725         .name = "h261",
726         .description = "H.261 video",
727         .type = AST_MEDIA_TYPE_VIDEO,
728 };
729
730 static struct ast_codec h263 = {
731         .name = "h263",
732         .description = "H.263 video",
733         .type = AST_MEDIA_TYPE_VIDEO,
734 };
735
736 static struct ast_codec h263p = {
737         .name = "h263p",
738         .description = "H.263+ video",
739         .type = AST_MEDIA_TYPE_VIDEO,
740 };
741
742 static struct ast_codec h264 = {
743         .name = "h264",
744         .description = "H.264 video",
745         .type = AST_MEDIA_TYPE_VIDEO,
746 };
747
748 static struct ast_codec mpeg4 = {
749         .name = "mpeg4",
750         .description = "MPEG4 video",
751         .type = AST_MEDIA_TYPE_VIDEO,
752 };
753
754 static struct ast_codec vp8 = {
755         .name = "vp8",
756         .description = "VP8 video",
757         .type = AST_MEDIA_TYPE_VIDEO,
758 };
759
760 static struct ast_codec t140red = {
761         .name = "red",
762         .description = "T.140 Realtime Text with redundancy",
763         .type = AST_MEDIA_TYPE_TEXT,
764 };
765
766 static struct ast_codec t140 = {
767         .name = "t140",
768         .description = "Passthrough T.140 Realtime Text",
769         .type = AST_MEDIA_TYPE_TEXT,
770 };
771
772 #define CODEC_REGISTER_AND_CACHE(codec) \
773         ({ \
774                 int __res_ ## __LINE__ = 0; \
775                 struct ast_format *__fmt_ ## __LINE__; \
776                 struct ast_codec *__codec_ ## __LINE__; \
777                 res |= __ast_codec_register(&(codec), NULL); \
778                 __codec_ ## __LINE__ = ast_codec_get((codec).name, (codec).type, (codec).sample_rate); \
779                 __fmt_ ## __LINE__ = __codec_ ## __LINE__ ? ast_format_create(__codec_ ## __LINE__) : NULL; \
780                 res |= ast_format_cache_set(__fmt_ ## __LINE__); \
781                 ao2_ref(__fmt_ ## __LINE__, -1); \
782                 ao2_ref(__codec_ ## __LINE__, -1); \
783                 __res_ ## __LINE__; \
784         })
785
786 #define CODEC_REGISTER_AND_CACHE_NAMED(format_name, codec) \
787         ({ \
788                 int __res_ ## __LINE__ = 0; \
789                 struct ast_format *__fmt_ ## __LINE__; \
790                 struct ast_codec *__codec_ ## __LINE__; \
791                 res |= __ast_codec_register(&(codec), NULL); \
792                 __codec_ ## __LINE__ = ast_codec_get((codec).name, (codec).type, (codec).sample_rate); \
793                 __fmt_ ## __LINE__ = ast_format_create_named((format_name), __codec_ ## __LINE__); \
794                 res |= ast_format_cache_set(__fmt_ ## __LINE__); \
795                 ao2_ref(__fmt_ ## __LINE__, -1); \
796                 ao2_ref(__codec_ ## __LINE__, -1); \
797                 __res_ ## __LINE__; \
798         })
799
800 int ast_codec_builtin_init(void)
801 {
802         int res = 0;
803
804         res |= CODEC_REGISTER_AND_CACHE(g723);
805         res |= CODEC_REGISTER_AND_CACHE(ulaw);
806         res |= CODEC_REGISTER_AND_CACHE(alaw);
807         res |= CODEC_REGISTER_AND_CACHE(gsm);
808         res |= CODEC_REGISTER_AND_CACHE(g726rfc3551);
809         res |= CODEC_REGISTER_AND_CACHE(g726aal2);
810         res |= CODEC_REGISTER_AND_CACHE(adpcm);
811         res |= CODEC_REGISTER_AND_CACHE(slin8);
812         res |= CODEC_REGISTER_AND_CACHE_NAMED("slin12", slin12);
813         res |= CODEC_REGISTER_AND_CACHE_NAMED("slin16", slin16);
814         res |= CODEC_REGISTER_AND_CACHE_NAMED("slin24", slin24);
815         res |= CODEC_REGISTER_AND_CACHE_NAMED("slin32", slin32);
816         res |= CODEC_REGISTER_AND_CACHE_NAMED("slin44", slin44);
817         res |= CODEC_REGISTER_AND_CACHE_NAMED("slin48", slin48);
818         res |= CODEC_REGISTER_AND_CACHE_NAMED("slin96", slin96);
819         res |= CODEC_REGISTER_AND_CACHE_NAMED("slin192", slin192);
820         res |= CODEC_REGISTER_AND_CACHE(lpc10);
821         res |= CODEC_REGISTER_AND_CACHE(g729a);
822         res |= CODEC_REGISTER_AND_CACHE(speex8);
823         res |= CODEC_REGISTER_AND_CACHE_NAMED("speex16", speex16);
824         res |= CODEC_REGISTER_AND_CACHE_NAMED("speex32", speex32);
825         res |= CODEC_REGISTER_AND_CACHE(ilbc);
826         res |= CODEC_REGISTER_AND_CACHE(g722);
827         res |= CODEC_REGISTER_AND_CACHE(siren7);
828         res |= CODEC_REGISTER_AND_CACHE(siren14);
829         res |= CODEC_REGISTER_AND_CACHE(testlaw);
830         res |= CODEC_REGISTER_AND_CACHE(g719);
831         res |= CODEC_REGISTER_AND_CACHE(opus);
832         res |= CODEC_REGISTER_AND_CACHE(jpeg);
833         res |= CODEC_REGISTER_AND_CACHE(png);
834         res |= CODEC_REGISTER_AND_CACHE(h261);
835         res |= CODEC_REGISTER_AND_CACHE(h263);
836         res |= CODEC_REGISTER_AND_CACHE(h263p);
837         res |= CODEC_REGISTER_AND_CACHE(h264);
838         res |= CODEC_REGISTER_AND_CACHE(mpeg4);
839         res |= CODEC_REGISTER_AND_CACHE(vp8);
840         res |= CODEC_REGISTER_AND_CACHE(t140red);
841         res |= CODEC_REGISTER_AND_CACHE(t140);
842         res |= CODEC_REGISTER_AND_CACHE(none);
843
844         return res;
845 }