root/rat/trunk/codec.c @ 3272

Revision 3272, 31.9 KB (checked in by ucacoxh, 14 years ago)

- typo correction (worked on freebsd but not win32 ;-)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2 * FILE:    codec.c
3 * AUTHORS: Orion Hodson
4 *
5 * Copyright (c) 1998-2000 University College London
6 * All rights reserved.
7 */
8 
9#ifndef HIDE_SOURCE_STRINGS
10static const char cvsid[] =
11        "$Id$";
12#endif /* HIDE_SOURCE_STRINGS */
13
14#include "config_unix.h"
15#include "config_win32.h"
16#include "debug.h"
17
18/* These two just for UCL memory debugging fn's */
19#include "memory.h"
20#include "util.h"
21#include "audio_types.h"
22#include "codec_types.h"
23#include "codec.h"
24#include "codec_l16.h"
25#include "codec_g711.h"
26#include "codec_g726.h"
27#include "codec_dvi.h"
28#include "codec_gsm.h"
29#include "codec_lpc.h"
30#include "codec_vdvi.h"
31#include "codec_wbs.h"
32
33/* Codec class initialization - hey didn't c++ happen somewhere along the
34 * timeline ;-)
35 */
36
37/* One time codec {con,de}struction */
38typedef void    (*cx_init_f) (void);
39typedef void    (*cx_exit_f) (void);
40
41/* Codec Probing functions */
42typedef uint16_t               (*cx_get_formats_count_f) (void);
43typedef const codec_format_t* (*cx_get_format_f)        (uint16_t);
44
45/* Codec Encoding functions */
46typedef int     (*cx_encoder_create_f)    (uint16_t idx, u_char **state);
47typedef void    (*cx_encoder_destroy_f)   (uint16_t idx, u_char **state);
48typedef int     (*cx_encode_f)            (uint16_t idx, u_char *state,
49                                           sample *in, coded_unit *out);
50typedef int     (*cx_can_encode_f)        (uint16_t idx);
51
52/* Codec Decoding functions */
53typedef int     (*cx_decoder_create_f)    (uint16_t idx, u_char **state);
54typedef void    (*cx_decoder_destroy_f)   (uint16_t idx, u_char **state);
55typedef int     (*cx_decode_f)            (uint16_t idx, u_char *state,
56                                           coded_unit *in, sample *out);
57typedef int     (*cx_can_decode_f)        (uint16_t idx);
58
59/* For determining frame sizes of variable bit rate codecs */
60typedef int     (*cx_peek_size_f)         (uint16_t idx, u_char *data, int data_len);
61
62/* For codec domain repair schemes */
63typedef int     (*cx_repair_f)            (uint16_t idx,
64                                           u_char *state,
65                                           uint16_t consec_missing,
66                                           coded_unit *prev,
67                                           coded_unit *missing,
68                                           coded_unit *next);
69
70/* For layered codecs */
71typedef uint8_t         (*cx_can_layer_f)         (void);
72typedef int             (*cx_get_layer_f)         (uint16_t idx, coded_unit *cu_whole, uint8_t layer,
73                                                   uint16_t *markers, coded_unit *cu_layer);
74typedef int             (*cx_combine_layer_f)     (uint16_t idx, coded_unit *cu_layer, coded_unit *cu_whole, uint8_t nelem, uint16_t *markers);
75
76typedef struct s_codec_fns {
77        cx_init_f               cx_init;
78        cx_exit_f               cx_exit;
79        cx_get_formats_count_f  cx_get_formats_count;
80        cx_get_format_f         cx_get_format;
81        cx_encoder_create_f     cx_encoder_create;
82        cx_encoder_destroy_f    cx_encoder_destroy;
83        cx_encode_f             cx_encode;
84        cx_can_encode_f         cx_can_encode;
85        cx_decoder_create_f     cx_decoder_create;
86        cx_decoder_destroy_f    cx_decoder_destroy;
87        cx_decode_f             cx_decode;
88        cx_can_decode_f         cx_can_decode;
89        cx_peek_size_f          cx_peek_size;
90        cx_repair_f             cx_repair;
91        cx_can_layer_f          cx_can_layer;
92        cx_get_layer_f          cx_get_layer;
93        cx_combine_layer_f      cx_combine_layer;
94} codec_fns_t;
95
96static codec_fns_t codec_table[] = {
97        {
98                NULL,
99                NULL,
100                l16_get_formats_count,
101                l16_get_format,
102                NULL, /* No encoder setup / tear down */
103                NULL,
104                l16_encode,
105                NULL,
106                NULL,
107                NULL, /* No decoder setup / tear down */
108                l16_decode,
109                NULL,
110                NULL,
111                NULL,
112                NULL,
113                NULL,
114                NULL
115        },
116        {       g711_init,
117                NULL,
118                g711_get_formats_count,
119                g711_get_format,
120                NULL,
121                NULL,
122                g711_encode,
123                NULL,
124                NULL,
125                NULL,
126                g711_decode,
127                NULL,
128                NULL,
129                NULL,
130                NULL,
131                NULL,
132                NULL
133        },
134        {
135                NULL,
136                NULL,
137                g726_get_formats_count,
138                g726_get_format,
139                g726_state_create,
140                g726_state_destroy,
141                g726_encode,
142                NULL,
143                g726_state_create,
144                g726_state_destroy,
145                g726_decode,
146                NULL,
147                NULL,
148                NULL,
149                NULL,
150                NULL,
151                NULL
152        },
153        {
154                NULL,
155                NULL,
156                dvi_get_formats_count,
157                dvi_get_format,
158                dvi_state_create,
159                dvi_state_destroy,
160                dvi_encode,
161                NULL,
162                dvi_state_create,
163                dvi_state_destroy,
164                dvi_decode,
165                NULL,
166                NULL,
167                NULL,
168                NULL,
169                NULL,
170                NULL
171        },
172        {
173                NULL,
174                NULL,
175                vdvi_get_formats_count,
176                vdvi_get_format,
177                vdvi_state_create,
178                vdvi_state_destroy,
179                vdvi_encoder,
180                NULL,
181                vdvi_state_create,
182                vdvi_state_destroy,
183                vdvi_decoder,
184                NULL,
185                vdvi_peek_frame_size,
186                NULL,
187                NULL,
188                NULL,
189                NULL
190        },
191        {
192                NULL,
193                NULL,
194                wbs_get_formats_count,
195                wbs_get_format,
196                wbs_state_create,
197                wbs_state_destroy,
198                wbs_encoder,
199                NULL,
200                wbs_state_create,
201                wbs_state_destroy,
202                wbs_decoder,
203                NULL,
204                NULL,
205                NULL,
206                wbs_max_layers,
207                wbs_get_layer,
208                wbs_combine_layer
209        },
210        {
211                NULL,
212                NULL,
213                gsm_get_formats_count,
214                gsm_get_format,
215                gsm_state_create,
216                gsm_state_destroy,
217                gsm_encoder,
218                NULL,
219                gsm_state_create,
220                gsm_state_destroy,
221                gsm_decoder,
222                NULL,
223                NULL,
224                gsm_repair,
225                NULL,
226                NULL,
227                NULL
228        },
229        {
230                lpc_setup,
231                NULL,
232                lpc_get_formats_count,
233                lpc_get_format,
234                lpc_encoder_state_create,
235                lpc_encoder_state_destroy,
236                lpc_encoder,
237                NULL,
238                lpc_decoder_state_create,
239                lpc_decoder_state_destroy,
240                lpc_decoder,
241                NULL,
242                NULL,
243                lpc_repair,
244                NULL,
245                NULL,
246                NULL
247        }
248};
249
250/* NUM_CODEC_INTERFACES = number of codec interfaces */
251/* Applications never know this...                   */
252#define NUM_CODEC_INTERFACES (sizeof(codec_table)/sizeof(codec_fns_t))
253
254/* These are used to save multiple function calls in
255 * codec_get_codec_number function. */
256static uint16_t num_fmts_supported[NUM_CODEC_INTERFACES];
257static uint16_t total_fmts_supported;
258
259/* Codec identifier is 32 bits long. It's like an MS handle.
260 * First byte is always zero.
261 * Second byte is index in codec_table above plus 1.
262 * Third and fourth bytes hold index for encoding format
263 * used by codec.
264 */ 
265
266#define CODEC_GET_IFS_INDEX(id)     (uint16_t)(((id  & 0x00ff0000) >> 16) - 1)
267#define CODEC_GET_FMT_INDEX(id)     (uint16_t)((id & 0x0000ffff) - 1)
268#define CODEC_MAKE_ID(ifs,fmt)      (((ifs) + 1) << 16)|((fmt+1)&0xffff)
269
270#define CODEC_VALID_PAD(id)          (!(id & 0xff000000))
271#define CODEC_VALID_IFS(id)           (id & 0x00ff0000)
272#define CODEC_VALID_FMT(id)           (id & 0x0000ffff)
273
274int
275codec_id_is_valid(codec_id_t id)
276{
277        uint32_t ifs, fmt;
278
279        if (codec_is_native_coding(id)) {
280                /* Native codings should be tested with
281                 * codec_is_native_coding */
282                debug_msg("Coding is invalid because it is a native coding\n");
283                return FALSE;
284        }
285       
286        if (!CODEC_VALID_PAD(id) ||
287            !CODEC_VALID_IFS(id) ||
288            !CODEC_VALID_FMT(id)) {
289                debug_msg("Codec id (0x%08x) invalid (pad %x, ifs %x, fmt %x)",
290                          id, CODEC_VALID_PAD(id), CODEC_VALID_IFS(id),
291                          CODEC_VALID_FMT(id));
292                return FALSE;
293        }
294
295        ifs = CODEC_GET_IFS_INDEX(id);
296        fmt = CODEC_GET_FMT_INDEX(id);
297
298        if (ifs >= NUM_CODEC_INTERFACES) {
299                /* Table index too large */
300                debug_msg("Codec index outside table\n");
301                return FALSE;
302        }
303
304        if (fmt >= num_fmts_supported[ifs]) {
305                /* Format index too large */
306                debug_msg("Format index outside table %d / %d\n", fmt, num_fmts_supported[ifs]);
307                return FALSE;
308        }
309        return TRUE;
310}
311
312static void codec_map_init(void);
313static void codec_map_exit(void);
314
315void
316codec_init()
317{
318        const codec_format_t *cf;
319        uint32_t i;
320        uint16_t j;
321
322        if (total_fmts_supported == 0) {
323                for(i = 0; i < NUM_CODEC_INTERFACES; i++) {
324                        if (codec_table[i].cx_init) codec_table[i].cx_init();
325                        num_fmts_supported[i] = codec_table[i].cx_get_formats_count();
326                        total_fmts_supported += num_fmts_supported[i];
327                        for(j = 0; j < num_fmts_supported[i]; j++) {
328                                cf = codec_table[i].cx_get_format(j);
329                                /* Most compilers should spot this check anyway */
330                                assert(strlen(cf->short_name) < CODEC_SHORT_NAME_LEN);
331                                assert(strlen(cf->long_name) < CODEC_LONG_NAME_LEN);
332                                assert(strlen(cf->description) < CODEC_DESCRIPTION_LEN);
333                        }
334                }
335                codec_map_init();
336        } else {
337                debug_msg("codec_init already called - ignoring.\n");
338        }
339}       
340
341void
342codec_exit()
343{
344        uint32_t i;
345        if (total_fmts_supported != 0) {
346                for(i = 0; i < NUM_CODEC_INTERFACES; i++) {
347                        if (codec_table[i].cx_exit) codec_table[i].cx_exit();
348                }
349                codec_map_exit();
350                total_fmts_supported = 0;
351        } else {
352                debug_msg("codec_exit not inited - ignoring\n");
353        }
354}
355
356uint32_t
357codec_get_number_of_codecs()
358{
359        return total_fmts_supported;
360}
361
362codec_id_t
363codec_get_codec_number(uint32_t n)
364{
365        codec_id_t id;
366        uint32_t    ifs;
367        assert(n < total_fmts_supported);
368       
369        for(ifs = 0; n >= num_fmts_supported[ifs]; ifs++) {
370                n = n - num_fmts_supported[ifs];
371        }
372
373        id = CODEC_MAKE_ID(ifs, n);
374
375        assert(codec_id_is_valid(id));       
376
377        return id;
378}
379
380const codec_format_t*
381codec_get_format(codec_id_t id)
382{
383        uint16_t ifs, fmt;
384
385        assert(codec_id_is_valid(id));
386
387        ifs = CODEC_GET_IFS_INDEX(id);
388        fmt = CODEC_GET_FMT_INDEX(id);
389        return codec_table[ifs].cx_get_format(fmt);
390}
391
392int
393codec_can_encode(codec_id_t id)
394{
395        uint16_t ifs;
396
397        ifs = CODEC_GET_IFS_INDEX(id);
398
399        assert(codec_id_is_valid(id));               
400        assert(ifs < NUM_CODEC_INTERFACES);
401
402        if (codec_table[ifs].cx_can_encode) {
403                /* cx_can_encode only needs to exist if encoder and decoder are asymmetric */
404                return codec_table[ifs].cx_can_encode(CODEC_GET_FMT_INDEX(id));
405        } else {
406                const codec_format_t *cf;
407                cf = codec_get_format(id);
408                if (cf->format.sample_rate % 8000) {
409                        return FALSE; /* only m * 8k at the moment */
410                }
411        }
412       
413        return TRUE;
414}
415
416int
417codec_can_decode(codec_id_t id)
418{
419        uint32_t ifs;
420
421        ifs = CODEC_GET_IFS_INDEX(id);
422
423        assert(codec_id_is_valid(id));       
424        assert(ifs < NUM_CODEC_INTERFACES);
425
426        if (codec_table[ifs].cx_can_decode) {
427                /* cx_can_encode only needs to exist if encoder and decoder are asymmetric */
428                return codec_table[ifs].cx_can_decode(CODEC_GET_FMT_INDEX(id));
429        }  else {
430                const codec_format_t *cf;
431                cf = codec_get_format(id);
432                if (cf->format.sample_rate % 8000) {
433                        return FALSE; /* Only m * 8k at moment */
434                }
435        }
436       
437        return TRUE;
438}
439
440int
441codec_audio_formats_compatible(codec_id_t id1, codec_id_t id2)
442{
443        const codec_format_t *cf1, *cf2;
444        int match;
445       
446        assert(codec_id_is_valid(id1));
447        assert(codec_id_is_valid(id2));
448       
449        cf1 = codec_get_format(id1);
450        cf2 = codec_get_format(id2);
451
452        match = !memcmp(&cf1->format, &cf2->format, sizeof(audio_format));
453
454        return match;
455}
456
457uint32_t
458codec_get_samples_per_frame(codec_id_t id)
459{
460        const codec_format_t *cf;
461        uint32_t spf;
462
463        assert(codec_id_is_valid(id));
464        cf = codec_get_format(id);
465        spf = cf->format.bytes_per_block * 8 /
466                (cf->format.channels * cf->format.bits_per_sample);
467
468        return spf;
469}
470
471/* Encoder related ***********************************************************/
472int
473codec_encoder_create(codec_id_t id, codec_state **cs)
474{
475        if (codec_id_is_valid(id)) {
476                uint16_t ifs, fmt;
477                *cs = (codec_state*)block_alloc(sizeof(codec_state));
478                if (!cs) {
479                        *cs = NULL;
480                        return 0;
481                }
482                (*cs)->state = NULL;
483                (*cs)->id = id;
484                ifs = CODEC_GET_IFS_INDEX(id);
485                fmt = CODEC_GET_FMT_INDEX(id);
486                if (codec_table[ifs].cx_encoder_create) {
487                        /* Must also have a destructor */
488                        assert(codec_table[ifs].cx_encoder_destroy != NULL);
489                        codec_table[ifs].cx_encoder_create(fmt,
490                                                           &(*cs)->state);
491                }
492                return TRUE;
493        } else {
494                debug_msg("Attempting to initiate invalid codec\n");
495                abort();
496        }
497        return 0;
498}
499
500void
501codec_encoder_destroy(codec_state **cs)
502{
503        codec_id_t id;
504        assert(*cs != NULL);
505        id = (*cs)->id;
506        if (codec_id_is_valid(id)) {
507                uint16_t ifs, fmt;
508                ifs = CODEC_GET_IFS_INDEX(id);
509                fmt = CODEC_GET_FMT_INDEX(id);
510                if (codec_table[ifs].cx_encoder_destroy) {
511                        /* Must also have a destructor */
512                        codec_table[ifs].cx_encoder_destroy(fmt,
513                                                               &(*cs)->state);
514                }
515                block_free(*cs, sizeof(codec_state));
516                *cs = NULL;
517        } else {
518                debug_msg("Destroying corrupted codec\n");
519                abort();
520        }
521}
522
523int
524codec_encode(codec_state *cs,
525             coded_unit  *in_native,
526             coded_unit  *cu)
527{
528        uint16_t    ifs, fmt;
529        int        success;
530
531        assert(cs        != NULL);
532        assert(in_native != NULL);
533        assert(cu        != NULL);
534
535        assert(codec_is_native_coding(in_native->id));
536        assert (in_native->state == NULL);
537#ifdef DEBUG
538        {
539                const codec_format_t *cf = codec_get_format(cs->id);
540                assert (cf->format.bytes_per_block == in_native->data_len);
541        }
542#endif
543        cu->id = cs->id;
544        ifs = CODEC_GET_IFS_INDEX(cu->id);
545        fmt = CODEC_GET_FMT_INDEX(cu->id);
546
547        xmemchk();
548        success = codec_table[ifs].cx_encode(fmt, cs->state, (sample*)in_native->data, cu);
549        xmemchk();
550
551        return success;
552}
553
554/* Decoder related ***********************************************************/
555int
556codec_decoder_create(codec_id_t id, codec_state **cs)
557{
558        if (codec_id_is_valid(id)) {
559                uint16_t ifs, fmt;
560                *cs = (codec_state*)block_alloc(sizeof(codec_state));
561                if (!cs) {
562                        *cs = NULL;
563                        return 0;
564                }
565                (*cs)->state = NULL;
566                (*cs)->id = id;
567                ifs = CODEC_GET_IFS_INDEX(id);
568                fmt = CODEC_GET_FMT_INDEX(id);
569                if (codec_table[ifs].cx_decoder_create) {
570                        /* Must also have a destructor */
571                        assert(codec_table[ifs].cx_decoder_destroy != NULL);
572                        codec_table[ifs].cx_decoder_create(fmt,
573                                                               &(*cs)->state);
574                }
575                return TRUE;
576        } else {
577                debug_msg("Attempting to initiate invalid codec\n");
578                abort();
579        }
580        return 0;
581}
582
583void
584codec_decoder_destroy(codec_state **cs)
585{
586        codec_id_t id;
587        assert(*cs != NULL);
588        id = (*cs)->id;
589        if (codec_id_is_valid(id)) {
590                uint16_t ifs, fmt;
591                ifs = CODEC_GET_IFS_INDEX(id);
592                fmt = CODEC_GET_FMT_INDEX(id);
593                if (codec_table[ifs].cx_decoder_destroy) {
594                        /* Must also have a destructor */
595                        codec_table[ifs].cx_decoder_destroy(fmt,
596                                                               &(*cs)->state);
597                }
598                block_free(*cs, sizeof(codec_state));
599                *cs = NULL;
600        } else {
601                debug_msg("Destroying corrupted codec\n");
602                abort();
603        }
604}
605
606int
607codec_decode(codec_state *cs,
608             coded_unit  *in,
609             coded_unit  *out)
610{
611        const codec_format_t *cf;
612        codec_id_t           id;
613        uint16_t              ifs, fmt, rate, channels;
614        int                  success;
615
616        assert(cs  != NULL);
617        assert(out != NULL);
618        assert(in  != NULL);
619       
620        id = cs->id;
621        assert(in->id == cs->id);
622        assert(codec_is_native_coding(in->id) == FALSE);
623
624        ifs = CODEC_GET_IFS_INDEX(id);
625        fmt = CODEC_GET_FMT_INDEX(id);
626
627        /* Setup outgoing data block */
628        cf = codec_get_format(id);
629        assert(out->state == NULL);
630        assert(out->data  == NULL);
631        rate     = (uint16_t)cf->format.sample_rate;
632        channels = (uint16_t)cf->format.channels;
633        out->id       = codec_get_native_coding(rate, channels);
634        out->data_len = cf->format.bytes_per_block;
635        out->data     = (u_char*)block_alloc(out->data_len);
636
637        /* Decode */
638        xmemchk();
639        success = codec_table[ifs].cx_decode(fmt, cs->state, in, (sample*)out->data);
640        xmemchk();
641
642        return success;
643}
644
645int
646codec_decoder_can_repair (codec_id_t id)
647{
648        uint16_t ifs;
649        assert(codec_id_is_valid(id));
650        ifs = CODEC_GET_IFS_INDEX(id);
651        if (codec_table[ifs].cx_repair) {
652                return TRUE;
653        } else {
654                return FALSE;
655        }
656}
657
658int
659codec_decoder_repair(codec_id_t id, codec_state *cs,
660                     uint16_t consec_missing,
661                     coded_unit *prev,
662                     coded_unit *miss,
663                     coded_unit *next)
664{
665        uint16_t    ifs, fmt;
666
667        assert(codec_id_is_valid(id));
668        assert(id == cs->id);
669
670        ifs = CODEC_GET_IFS_INDEX(id);
671        fmt = CODEC_GET_FMT_INDEX(id);
672
673        if (miss->id != id) {
674                debug_msg("Wrong previous unit supplied for repair.  Probably a transition in stream.\n");
675                return FALSE;
676        }
677        miss->id = prev->id;
678
679        assert(codec_table[ifs].cx_repair != NULL);
680        return codec_table[ifs].cx_repair(fmt,
681                                          cs->state,
682                                          consec_missing,
683                                          prev, miss, next);
684}
685
686uint32_t
687codec_peek_frame_size(codec_id_t id, u_char *data, uint16_t blk_len)
688{
689        uint16_t    ifs, fmt;
690
691        assert(codec_id_is_valid(id));
692
693        ifs = CODEC_GET_IFS_INDEX(id);
694        fmt = CODEC_GET_FMT_INDEX(id);       
695
696        if (codec_table[ifs].cx_peek_size) {
697                return codec_table[ifs].cx_peek_size(fmt, data, (int)blk_len);
698        } else {
699                const codec_format_t *cf = codec_get_format(id);
700                return cf->mean_coded_frame_size;
701        }
702}
703
704/* Codec clear coded unit - not sure where this should go - away? :-) */
705int
706codec_clear_coded_unit(coded_unit *u)
707{
708        if (u->state_len) {
709                assert(u->state != NULL);
710                block_free(u->state, u->state_len);
711        }
712        if (u->data_len) {
713                assert(u->data != NULL);
714                block_free(u->data, u->data_len);
715        }
716        memset(u, 0, sizeof(coded_unit));
717        return TRUE;
718}
719
720/* RTP related things like mapping and payload sanity checking ***************/
721
722int
723payload_is_valid(u_char pt)
724{
725        /* Per rfc1890.txt (actually 72-95 is unassigned, but we use it anyway */
726        if (pt < 29 || (pt>=72 && pt <=127)) return TRUE;
727        return FALSE;
728}
729
730/* RTP Mapping interface -
731 * 2 maps one from payload to codec id and the other from codec id to
732 * to payload.
733 */
734
735#define NUM_PAYLOADS 128
736static codec_id_t payload_map[NUM_PAYLOADS];
737static u_char    *codec_map[NUM_CODEC_INTERFACES];
738
739static void
740codec_map_init()
741{
742        uint16_t i,j;
743        const codec_format_t *fmt;
744
745        memset(payload_map, 0, NUM_PAYLOADS * sizeof(codec_id_t));
746        for(i = 0; i < NUM_CODEC_INTERFACES; i++) {
747                codec_map[i] = (u_char*)xmalloc(num_fmts_supported[i]);
748                memset(codec_map[i], CODEC_PAYLOAD_DYNAMIC, num_fmts_supported[i]);
749                for(j = 0; j < num_fmts_supported[i]; j++) {
750                        fmt = codec_table[i].cx_get_format(j);
751                        if (fmt->default_pt == CODEC_PAYLOAD_DYNAMIC) {
752                                continue;
753                        }
754                        codec_map_payload(CODEC_MAKE_ID(i,j), fmt->default_pt);
755                }
756        }
757}
758
759static void
760codec_map_exit()
761{
762        uint32_t i;
763        for(i = 0; i < NUM_CODEC_INTERFACES; i++) {
764                xfree(codec_map[i]);
765        }
766}
767
768int
769codec_map_payload(codec_id_t id, u_char pt)
770{
771        if (payload_is_valid(pt) && codec_id_is_valid(id)) {
772                if (payload_map[pt] != 0) {
773                        codec_unmap_payload(id, pt);
774                }
775                payload_map[pt] = id;
776                codec_map[CODEC_GET_IFS_INDEX(id)][CODEC_GET_FMT_INDEX(id)] = pt;
777                return TRUE;
778        }
779#ifdef DEBUG
780        {
781                const codec_format_t *cf;
782                cf = codec_get_format(id);
783                debug_msg("Failed to map payload for %s\n", cf->long_name);
784        }
785#endif /* DEBUG */
786        return FALSE;
787}
788
789u_char
790codec_get_payload(codec_id_t id)
791{
792        u_char pt;
793
794        assert(codec_id_is_valid(id));
795        pt = codec_map[CODEC_GET_IFS_INDEX(id)][CODEC_GET_FMT_INDEX(id)];
796        if (payload_is_valid(pt)) {
797                assert(codec_get_by_payload(pt) == id);
798                return pt;
799        }
800        return CODEC_PAYLOAD_DYNAMIC;
801}
802
803int 
804codec_unmap_payload(codec_id_t id, u_char pt)
805{
806        if (payload_is_valid(pt) &&
807            codec_id_is_valid(id) &&
808            payload_map[pt] == id) {
809                payload_map[pt] = 0;
810                codec_map[CODEC_GET_IFS_INDEX(id)][CODEC_GET_FMT_INDEX(id)] = CODEC_PAYLOAD_DYNAMIC;
811                return TRUE;
812        }
813        debug_msg("Failed to unmap payload\n");
814        return FALSE;
815}
816
817codec_id_t
818codec_get_by_payload (u_char pt)
819{
820        if (payload_is_valid(pt)) {
821#ifdef DEBUG
822                if (payload_map[pt] == 0) {
823                        debug_msg("No codec for payload %d\n", pt);
824                }
825#endif       
826                return payload_map[pt];
827        } else {
828                debug_msg("codec_get_by_payload - invalid payload (%d)\n", pt);
829                return 0;
830        }
831}
832
833/* For compatibility only */
834codec_id_t
835codec_get_first_mapped_with(uint16_t sample_rate, uint16_t channels)
836{
837        const codec_format_t *cf;
838        int pt;
839       
840        for(pt = 0; pt < NUM_PAYLOADS; pt++) {
841                if (payload_map[pt]) {
842                        cf = codec_get_format(payload_map[pt]);
843                        if (cf->format.sample_rate == sample_rate &&
844                            cf->format.channels    == channels) {
845                                return payload_map[pt];
846                        }
847                }
848        }
849        debug_msg("No mapped codecs compatible (%d, %d)\n",
850                  sample_rate, channels);
851        return 0;
852}
853
854
855codec_id_t
856codec_get_by_name(const char *name)
857{
858        const codec_format_t *cf;
859        uint16_t ifs, fmt;
860
861        for(ifs = 0; ifs < NUM_CODEC_INTERFACES; ifs++) {
862                for(fmt = 0; fmt < num_fmts_supported[ifs]; fmt++) {
863                        cf = codec_table[ifs].cx_get_format(fmt);
864                        if (!strcasecmp(cf->long_name, name)) {
865                                return CODEC_MAKE_ID(ifs,fmt);
866                        }
867                }
868        }
869
870        return 0;
871}
872
873
874codec_id_t
875codec_get_matching(const char *short_name, uint16_t freq, uint16_t channels)
876{
877        /* This has been changed to try really hard to find a matching codec.
878         * The reason is that it's now called as part of the command-line     
879         * parsing, and so has to cope with user entered codec names. Also, it
880         * should recognise the names sdr gives the codecs, for compatibility
881         * with rat-v3.0.                                                [csp]
882         */
883
884        /* This is not quite as inefficient as it looks, since stage 1 will
885         * almost always find a match.                                     
886         */
887
888        const codec_format_t  *cf = NULL;
889        codec_id_t             cid = 0;
890        uint32_t                i, codecs;
891        char                  *long_name;
892
893        /* Stage 1: Try the designated short names... */
894        codecs = codec_get_number_of_codecs();
895        for(i = 0; i < codecs; i++) {
896                cid = codec_get_codec_number(i);
897                cf  = codec_get_format(cid);
898                if (cf->format.sample_rate == freq  &&
899                    cf->format.channels == channels &&
900                    !strcasecmp(short_name, cf->short_name)) {
901                        return cid;
902                }
903        }
904
905        /* Stage 2: Try to generate a matching name... */
906        long_name = (char *) xmalloc(strlen(short_name) + 12);
907        sprintf(long_name, "%s-%dK-%s", short_name, freq/1000, channels==1?"MONO":"STEREO");
908        for(i = 0; i < codecs; i++) {
909                cid = codec_get_codec_number(i);
910                cf  = codec_get_format(cid);
911                if (cf->format.sample_rate == freq  &&
912                    cf->format.channels == channels &&
913                    !strcasecmp(long_name, cf->long_name)) {
914                        xfree(long_name);
915                        return cid;
916                }
917        }
918
919        /* Stage 3: Nasty hack... PCM->PCMU for compatibility with sdr
920         * and old rat versions
921         */
922        if (strncasecmp(short_name, "pcm", 3) == 0) {
923                sprintf(long_name, "PCMU-%dK-%s", freq/1000, channels==1?"MONO":"STEREO");
924                for(i = 0; i < codecs; i++) {
925                        cid = codec_get_codec_number(i);
926                        cf  = codec_get_format(cid);
927                        if (cf->format.sample_rate == freq  &&
928                            cf->format.channels == channels &&
929                            !strcasecmp(long_name, cf->long_name)) {
930                                xfree(long_name);
931                                return cid;
932                        }
933                }
934        }
935
936        xfree(long_name);
937
938        debug_msg("Unable to find codec \"%s\" at rate %d channels %d\n", short_name, freq, channels);
939        return 0;
940}
941
942
943/* These constants are what are supported as native codings */
944
945static uint16_t sampling_rates[] = {8000, 11025, 16000, 22050, 32000, 44100, 48000};
946static uint16_t num_sampling_rates = sizeof(sampling_rates)/sizeof(sampling_rates[0]);
947static uint16_t max_channels = 2;
948
949/* The following three functions are a hack so we can have encode and
950 * decode functions take coded_units as input and output.  This makes
951 * paths cleaner since we don't have two data types for coded and raw
952 * units.  */
953
954codec_id_t
955codec_get_native_coding(uint16_t sample_rate, uint16_t channels)
956{
957        codec_id_t cid;
958        uint32_t i, index;
959
960        for (i = 0; i < num_sampling_rates; i++) {
961                if (sampling_rates[i] == sample_rate) {
962                        break;
963                }
964        }
965        assert(i != num_sampling_rates);
966        assert(channels <= max_channels);
967        index = i * max_channels + (channels - 1);
968        /* There is no codec corresponding to this but make it
969         * have right form we set it interfaces to the number
970         * of interfaces, i.e. one more than is legal.
971         */
972        cid = CODEC_MAKE_ID(NUM_CODEC_INTERFACES, index);
973        return cid;
974}
975
976int
977codec_is_native_coding(codec_id_t cid)
978{
979        return (CODEC_GET_IFS_INDEX(cid) == NUM_CODEC_INTERFACES &&
980                CODEC_GET_FMT_INDEX(cid) < num_sampling_rates * max_channels);
981}
982
983int 
984codec_get_native_info(codec_id_t cid,
985                      uint16_t   *p_rate,
986                      uint16_t   *p_channels)
987{
988        uint32_t i, c, index;
989
990        if (codec_is_native_coding(cid)) {
991                index = CODEC_GET_FMT_INDEX(cid);
992                /* Calculate and verify index in table of acceptable rates */
993                i = index / max_channels;
994                if (p_rate != NULL) {
995                        *p_rate = sampling_rates[i];
996                }
997                /* Calculate and verify number of channels */
998                c = (index % max_channels) + 1;
999                if (p_channels != NULL) {
1000                        *p_channels = (uint16_t)c;
1001                }
1002                return TRUE;
1003        }
1004        return FALSE;
1005}
1006
1007/* Layered codecs ***********************************************************/
1008uint8_t
1009codec_can_layer(codec_id_t id)
1010{
1011        uint16_t ifs;
1012
1013        ifs = CODEC_GET_IFS_INDEX(id);
1014
1015        assert(codec_id_is_valid(id));               
1016        assert(ifs < NUM_CODEC_INTERFACES);
1017
1018        if (codec_table[ifs].cx_can_layer) {
1019                return codec_table[ifs].cx_can_layer();
1020        }
1021        return 1;
1022
1023}
1024
1025int
1026codec_get_layer(codec_id_t id, coded_unit *cu_whole, uint8_t layer, uint16_t *markers, coded_unit *cu_layer)
1027{
1028        uint16_t ifs, fmt;
1029               
1030        ifs = CODEC_GET_IFS_INDEX(id);
1031        fmt = CODEC_GET_FMT_INDEX(id);       
1032
1033        if (codec_table[ifs].cx_get_layer) {
1034                return codec_table[ifs].cx_get_layer(fmt, cu_whole, layer, markers, cu_layer);
1035        }
1036        return FALSE;
1037}
1038
1039int
1040codec_combine_layer (codec_id_t id, coded_unit *cu_layer, coded_unit *cu_whole, uint8_t nelem, uint16_t *markers)
1041{
1042        uint16_t ifs, fmt;
1043               
1044        ifs = CODEC_GET_IFS_INDEX(id);
1045        fmt = CODEC_GET_FMT_INDEX(id);       
1046               
1047        assert(codec_table[ifs].cx_combine_layer);
1048        return codec_table[ifs].cx_combine_layer(fmt, cu_layer, cu_whole, nelem, markers);
1049}
Note: See TracBrowser for help on using the browser.