← Back to branch summary

~ubuntu-branches/ubuntu/wily/sflphone/wily

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.2.1/pjmedia/src/pjmedia-codec/g7221.c

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2015-01-07 14:51:16 UTC
  • mfrom: (4.3.5 sid)
  • Revision ID: package-import@ubuntu.com-20150107145116-yxnafinf4lrdvrmx
Tags: 1.4.1-0.1ubuntu1
* Merge with Debian, remaining changes:
 - Drop soprano, nepomuk build-dep
* Drop ubuntu patches, now upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.2.1/pjmedia/src/pjmedia-codec/g7221.c
 
1
/* $Id: g7221.c 4001 2012-03-30 07:53:36Z bennylp $ */
 
2
/* 
 
3
 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
 
4
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
 
5
 *
 
6
 * This program is free software; you can redistribute it and/or modify
 
7
 * it under the terms of the GNU General Public License as published by
 
8
 * the Free Software Foundation; either version 2 of the License, or
 
9
 * (at your option) any later version.
 
10
 *
 
11
 * This program is distributed in the hope that it will be useful,
 
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
14
 * GNU General Public License for more details.
 
15
 *
 
16
 * You should have received a copy of the GNU General Public License
 
17
 * along with this program; if not, write to the Free Software
 
18
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 
19
 */
 
20
#include <pjmedia-codec/g7221.h>
 
21
#include <pjmedia-codec/g7221_sdp_match.h>
 
22
#include <pjmedia/codec.h>
 
23
#include <pjmedia/errno.h>
 
24
#include <pjmedia/endpoint.h>
 
25
#include <pjmedia/port.h>
 
26
#include <pjmedia/silencedet.h>
 
27
#include <pj/assert.h>
 
28
#include <pj/log.h>
 
29
#include <pj/math.h>
 
30
#include <pj/pool.h>
 
31
#include <pj/string.h>
 
32
#include <pj/os.h>
 
33
 
 
34
/*
 
35
 * Only build this file if PJMEDIA_HAS_G7221_CODEC != 0
 
36
 */
 
37
#if defined(PJMEDIA_HAS_G7221_CODEC) && PJMEDIA_HAS_G7221_CODEC!=0
 
38
 
 
39
#include "../../../third_party/g7221/common/defs.h"
 
40
 
 
41
#define THIS_FILE           "g7221.c"
 
42
 
 
43
/* Codec tag, it is the SDP encoding name and also MIME subtype name */
 
44
#define CODEC_TAG           "G7221"
 
45
 
 
46
/* Sampling rates definition */
 
47
#define WB_SAMPLE_RATE      16000
 
48
#define UWB_SAMPLE_RATE     32000
 
49
 
 
50
/* Maximum number of samples per frame. */
 
51
#define MAX_SAMPLES_PER_FRAME (UWB_SAMPLE_RATE * 20 / 1000)
 
52
 
 
53
/* Maximum number of codec params. */
 
54
#define MAX_CODEC_MODES     8
 
55
#define START_RSV_MODES_IDX 6
 
56
 
 
57
 
 
58
/* Prototypes for G722.1 codec factory */
 
59
static pj_status_t test_alloc( pjmedia_codec_factory *factory, 
 
60
                               const pjmedia_codec_info *id );
 
61
static pj_status_t default_attr( pjmedia_codec_factory *factory, 
 
62
                                 const pjmedia_codec_info *id, 
 
63
                                 pjmedia_codec_param *attr );
 
64
static pj_status_t enum_codecs( pjmedia_codec_factory *factory, 
 
65
                                unsigned *count, 
 
66
                                pjmedia_codec_info codecs[]);
 
67
static pj_status_t alloc_codec( pjmedia_codec_factory *factory, 
 
68
                                const pjmedia_codec_info *id, 
 
69
                                pjmedia_codec **p_codec);
 
70
static pj_status_t dealloc_codec( pjmedia_codec_factory *factory, 
 
71
                                  pjmedia_codec *codec );
 
72
 
 
73
/* Prototypes for G722.1 codec implementation. */
 
74
static pj_status_t codec_init( pjmedia_codec *codec, 
 
75
                               pj_pool_t *pool );
 
76
static pj_status_t codec_open( pjmedia_codec *codec, 
 
77
                               pjmedia_codec_param *attr );
 
78
static pj_status_t codec_close( pjmedia_codec *codec );
 
79
static pj_status_t codec_modify(pjmedia_codec *codec, 
 
80
                                const pjmedia_codec_param *attr );
 
81
static pj_status_t codec_parse( pjmedia_codec *codec,
 
82
                                void *pkt,
 
83
                                pj_size_t pkt_size,
 
84
                                const pj_timestamp *ts,
 
85
                                unsigned *frame_cnt,
 
86
                                pjmedia_frame frames[]);
 
87
static pj_status_t codec_encode( pjmedia_codec *codec, 
 
88
                                 const struct pjmedia_frame *input,
 
89
                                 unsigned output_buf_len,
 
90
                                 struct pjmedia_frame *output);
 
91
static pj_status_t codec_decode( pjmedia_codec *codec,
 
92
                                 const struct pjmedia_frame *input,
 
93
                                 unsigned output_buf_len, 
 
94
                                 struct pjmedia_frame *output);
 
95
static pj_status_t codec_recover( pjmedia_codec *codec, 
 
96
                                  unsigned output_buf_len, 
 
97
                                  struct pjmedia_frame *output);
 
98
 
 
99
/* Definition for G722.1 codec operations. */
 
100
static pjmedia_codec_op codec_op = 
 
101
{
 
102
    &codec_init,
 
103
    &codec_open,
 
104
    &codec_close,
 
105
    &codec_modify,
 
106
    &codec_parse,
 
107
    &codec_encode,
 
108
    &codec_decode,
 
109
    &codec_recover
 
110
};
 
111
 
 
112
/* Definition for G722.1 codec factory operations. */
 
113
static pjmedia_codec_factory_op codec_factory_op =
 
114
{
 
115
    &test_alloc,
 
116
    &default_attr,
 
117
    &enum_codecs,
 
118
    &alloc_codec,
 
119
    &dealloc_codec,
 
120
    &pjmedia_codec_g7221_deinit
 
121
};
 
122
 
 
123
 
 
124
/* Structure of G722.1 mode */
 
125
typedef struct codec_mode
 
126
{
 
127
    pj_bool_t        enabled;           /* Is this mode enabled?            */
 
128
    pj_uint8_t       pt;                /* Payload type.                    */
 
129
    unsigned         sample_rate;       /* Default sampling rate to be used.*/
 
130
    unsigned         bitrate;           /* Bitrate.                         */
 
131
    char             bitrate_str[8];    /* Bitrate in string.               */
 
132
} codec_mode;
 
133
 
 
134
 
 
135
/* G722.1 codec factory */
 
136
static struct codec_factory {
 
137
    pjmedia_codec_factory    base;          /**< Base class.                */
 
138
    pjmedia_endpt           *endpt;         /**< PJMEDIA endpoint instance. */
 
139
    pj_pool_t               *pool;          /**< Codec factory pool.        */
 
140
    pj_mutex_t              *mutex;         /**< Codec factory mutex.       */
 
141
 
 
142
    int                      pcm_shift;     /**< Level adjustment           */
 
143
    unsigned                 mode_count;    /**< Number of G722.1 modes.    */
 
144
    codec_mode               modes[MAX_CODEC_MODES]; /**< The G722.1 modes. */
 
145
    unsigned                 mode_rsv_start;/**< Start index of G722.1 non-
 
146
                                                 standard modes, currently
 
147
                                                 there can only be up to two 
 
148
                                                 non-standard modes enabled
 
149
                                                 at the same time.          */
 
150
} codec_factory;
 
151
 
 
152
/* G722.1 codec private data. */
 
153
typedef struct codec_private {
 
154
    pj_pool_t           *pool;              /**< Pool for each instance.    */
 
155
    pj_bool_t            plc_enabled;       /**< PLC enabled?               */
 
156
    pj_bool_t            vad_enabled;       /**< VAD enabled?               */
 
157
    pjmedia_silence_det *vad;               /**< PJMEDIA VAD instance.      */
 
158
    pj_timestamp         last_tx;           /**< Timestamp of last transmit.*/
 
159
 
 
160
    /* ITU ref implementation seems to leave the codec engine states to be
 
161
     * managed by the application, so here we go.
 
162
     */
 
163
 
 
164
    /* Common engine state */
 
165
    pj_uint16_t          samples_per_frame; /**< Samples per frame.         */
 
166
    pj_uint16_t          bitrate;           /**< Coded stream bitrate.      */
 
167
    pj_uint16_t          frame_size;        /**< Coded frame size.          */
 
168
    pj_uint16_t          frame_size_bits;   /**< Coded frame size in bits.  */
 
169
    pj_uint16_t          number_of_regions; /**< Number of regions.         */
 
170
    int                  pcm_shift;         /**< Adjustment for PCM in/out  */
 
171
    
 
172
    /* Encoder specific state */
 
173
    Word16              *enc_frame;         /**< 16bit to 14bit buffer      */
 
174
    Word16              *enc_old_frame;
 
175
    
 
176
    /* Decoder specific state */
 
177
    Word16              *dec_old_frame;
 
178
    Rand_Obj             dec_randobj;
 
179
    Word16               dec_old_mag_shift;
 
180
    Word16              *dec_old_mlt_coefs;
 
181
} codec_private_t;
 
182
 
 
183
/* 
 
184
 * Helper function for looking up mode based on payload type.
 
185
 */
 
186
static codec_mode* lookup_mode(unsigned pt)
 
187
{
 
188
    codec_mode* mode = NULL;
 
189
    unsigned i;
 
190
 
 
191
    for (i = 0; i < codec_factory.mode_count; ++i) {
 
192
        mode = &codec_factory.modes[i];
 
193
        if (mode->pt == pt)
 
194
            break;
 
195
    }
 
196
 
 
197
    return mode;
 
198
}
 
199
 
 
200
/* 
 
201
 * Helper function to validate G722.1 mode. Valid modes are defined as:
 
202
 * 1. sample rate must be 16kHz or 32kHz,
 
203
 * 2. bitrate:
 
204
 *    - for sampling rate 16kHz: 16000 to 32000 bps, it must be a multiple 
 
205
 *      of 400 (to keep RTP payload octed-aligned)
 
206
 *    - for sampling rate 32kHz: 24000 to 48000 bps, it must be a multiple 
 
207
 *      of 400 (to keep RTP payload octed-aligned)
 
208
 */
 
209
static pj_bool_t validate_mode(unsigned sample_rate, unsigned bitrate)
 
210
{
 
211
    if (sample_rate == WB_SAMPLE_RATE) {
 
212
        if (bitrate < 16000 || bitrate > 32000 ||
 
213
            ((bitrate-16000) % 400 != 0))
 
214
        {
 
215
            return PJ_FALSE;
 
216
        }
 
217
    } else if (sample_rate == UWB_SAMPLE_RATE) {
 
218
        if (bitrate < 24000 || bitrate > 48000 ||
 
219
            ((bitrate-24000) % 400 != 0))
 
220
        {
 
221
            return PJ_FALSE;
 
222
        }
 
223
    } else {
 
224
        return PJ_FALSE;
 
225
    }
 
226
 
 
227
    return PJ_TRUE;
 
228
}
 
229
 
 
230
#if defined(PJ_IS_LITTLE_ENDIAN) && PJ_IS_LITTLE_ENDIAN!=0
 
231
PJ_INLINE(void) swap_bytes(pj_uint16_t *buf, unsigned count)
 
232
{
 
233
    pj_uint16_t *end = buf + count;
 
234
    while (buf != end) {
 
235
        *buf = (pj_uint16_t)((*buf << 8) | (*buf >> 8));
 
236
        ++buf;
 
237
    }
 
238
}
 
239
#else
 
240
#define swap_bytes(buf, count)
 
241
#endif
 
242
 
 
243
/*
 
244
 * Initialize and register G722.1 codec factory to pjmedia endpoint.
 
245
 */
 
246
PJ_DEF(pj_status_t) pjmedia_codec_g7221_init( pjmedia_endpt *endpt )
 
247
{
 
248
    pjmedia_codec_mgr *codec_mgr;
 
249
    codec_mode *mode;
 
250
    pj_str_t codec_name;
 
251
    pj_status_t status;
 
252
 
 
253
    if (codec_factory.pool != NULL) {
 
254
        /* Already initialized. */
 
255
        return PJ_SUCCESS;
 
256
    }
 
257
 
 
258
    /* Initialize codec modes, by default all standard bitrates are enabled */
 
259
    codec_factory.mode_count = 0;
 
260
    codec_factory.pcm_shift = PJMEDIA_G7221_DEFAULT_PCM_SHIFT;
 
261
 
 
262
    mode = &codec_factory.modes[codec_factory.mode_count++];
 
263
    mode->enabled = PJ_TRUE;
 
264
    mode->pt = PJMEDIA_RTP_PT_G722_1_24;
 
265
    mode->sample_rate = WB_SAMPLE_RATE;
 
266
    mode->bitrate = 24000;
 
267
    pj_utoa(mode->bitrate, mode->bitrate_str);
 
268
 
 
269
    mode = &codec_factory.modes[codec_factory.mode_count++];
 
270
    mode->enabled = PJ_TRUE;
 
271
    mode->pt = PJMEDIA_RTP_PT_G722_1_32;
 
272
    mode->sample_rate = WB_SAMPLE_RATE;
 
273
    mode->bitrate = 32000;
 
274
    pj_utoa(mode->bitrate, mode->bitrate_str);
 
275
 
 
276
    mode = &codec_factory.modes[codec_factory.mode_count++];
 
277
    mode->enabled = PJ_TRUE;
 
278
    mode->pt = PJMEDIA_RTP_PT_G7221C_24;
 
279
    mode->sample_rate = UWB_SAMPLE_RATE;
 
280
    mode->bitrate = 24000;
 
281
    pj_utoa(mode->bitrate, mode->bitrate_str);
 
282
 
 
283
    mode = &codec_factory.modes[codec_factory.mode_count++];
 
284
    mode->enabled = PJ_TRUE;
 
285
    mode->pt = PJMEDIA_RTP_PT_G7221C_32;
 
286
    mode->sample_rate = UWB_SAMPLE_RATE;
 
287
    mode->bitrate = 32000;
 
288
    pj_utoa(mode->bitrate, mode->bitrate_str);
 
289
 
 
290
    mode = &codec_factory.modes[codec_factory.mode_count++];
 
291
    mode->enabled = PJ_TRUE;
 
292
    mode->pt = PJMEDIA_RTP_PT_G7221C_48;
 
293
    mode->sample_rate = UWB_SAMPLE_RATE;
 
294
    mode->bitrate = 48000;
 
295
    pj_utoa(mode->bitrate, mode->bitrate_str);
 
296
 
 
297
    /* Non-standard bitrates */
 
298
 
 
299
    /* Bitrate 16kbps is non-standard but rather commonly used. */
 
300
    mode = &codec_factory.modes[codec_factory.mode_count++];
 
301
    mode->enabled = PJ_FALSE;
 
302
    mode->pt = PJMEDIA_RTP_PT_G722_1_16;
 
303
    mode->sample_rate = WB_SAMPLE_RATE;
 
304
    mode->bitrate = 16000;
 
305
    pj_utoa(mode->bitrate, mode->bitrate_str);
 
306
 
 
307
    /* Reserved two modes for non-standard bitrates */
 
308
    codec_factory.mode_rsv_start = codec_factory.mode_count;
 
309
    mode = &codec_factory.modes[codec_factory.mode_count++];
 
310
    mode->enabled = PJ_FALSE;
 
311
    mode->pt = PJMEDIA_RTP_PT_G7221_RSV1;
 
312
 
 
313
    mode = &codec_factory.modes[codec_factory.mode_count++];
 
314
    mode->enabled = PJ_FALSE;
 
315
    mode->pt = PJMEDIA_RTP_PT_G7221_RSV2;
 
316
 
 
317
    pj_assert(codec_factory.mode_count <= MAX_CODEC_MODES);
 
318
 
 
319
    /* Create G722.1 codec factory. */
 
320
    codec_factory.base.op = &codec_factory_op;
 
321
    codec_factory.base.factory_data = NULL;
 
322
    codec_factory.endpt = endpt;
 
323
 
 
324
    codec_factory.pool = pjmedia_endpt_create_pool(endpt, "G722.1 codec",
 
325
                                                   4000, 4000);
 
326
    if (!codec_factory.pool)
 
327
        return PJ_ENOMEM;
 
328
 
 
329
    /* Create mutex. */
 
330
    status = pj_mutex_create_simple(codec_factory.pool, "G722.1 codec",
 
331
                                    &codec_factory.mutex);
 
332
    if (status != PJ_SUCCESS)
 
333
        goto on_error;
 
334
 
 
335
    /* Get the codec manager. */
 
336
    codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
 
337
    if (!codec_mgr) {
 
338
        status = PJ_EINVALIDOP;
 
339
        goto on_error;
 
340
    }
 
341
 
 
342
    /* Register format match callback. */
 
343
    pj_cstr(&codec_name, CODEC_TAG);
 
344
    status = pjmedia_sdp_neg_register_fmt_match_cb(
 
345
                                        &codec_name,
 
346
                                        &pjmedia_codec_g7221_match_sdp);
 
347
    if (status != PJ_SUCCESS)
 
348
        goto on_error;
 
349
 
 
350
    /* Register codec factory to endpoint. */
 
351
    status = pjmedia_codec_mgr_register_factory(codec_mgr, 
 
352
                                                &codec_factory.base);
 
353
    if (status != PJ_SUCCESS)
 
354
        goto on_error;
 
355
 
 
356
    /* Done. */
 
357
    return PJ_SUCCESS;
 
358
 
 
359
on_error:
 
360
    if (codec_factory.mutex) {
 
361
        pj_mutex_destroy(codec_factory.mutex);
 
362
        codec_factory.mutex = NULL;
 
363
    }
 
364
 
 
365
    pj_pool_release(codec_factory.pool);
 
366
    codec_factory.pool = NULL;
 
367
    return status;
 
368
}
 
369
 
 
370
 
 
371
/**
 
372
 * Enable and disable G722.1 modes, including non-standard modes.
 
373
 */
 
374
PJ_DEF(pj_status_t) pjmedia_codec_g7221_set_mode(unsigned sample_rate, 
 
375
                                                 unsigned bitrate, 
 
376
                                                 pj_bool_t enabled)
 
377
{
 
378
    unsigned i;
 
379
 
 
380
    /* Validate mode */
 
381
    if (!validate_mode(sample_rate, bitrate))
 
382
        return PJMEDIA_CODEC_EINMODE;
 
383
 
 
384
    /* Look up in factory modes table */
 
385
    for (i = 0; i < codec_factory.mode_count; ++i) {
 
386
        if (codec_factory.modes[i].sample_rate == sample_rate &&
 
387
            codec_factory.modes[i].bitrate == bitrate)
 
388
        {
 
389
            codec_factory.modes[i].enabled = enabled;
 
390
            return PJ_SUCCESS;
 
391
        }
 
392
    }
 
393
 
 
394
    /* Mode not found in modes table, this may be a request to enable
 
395
     * a non-standard G722.1 mode.
 
396
     */
 
397
 
 
398
    /* Non-standard mode need to be initialized first before user 
 
399
     * can disable it.
 
400
     */
 
401
    if (!enabled)
 
402
        return PJ_ENOTFOUND;
 
403
 
 
404
    /* Initialize a non-standard mode, look for available space. */
 
405
    for (i = codec_factory.mode_rsv_start; 
 
406
         i < codec_factory.mode_count; ++i) 
 
407
    {
 
408
        if (!codec_factory.modes[i].enabled)
 
409
        {
 
410
            codec_mode *mode = &codec_factory.modes[i];
 
411
            mode->enabled = PJ_TRUE;
 
412
            mode->sample_rate = sample_rate;
 
413
            mode->bitrate = bitrate;
 
414
            pj_utoa(mode->bitrate, mode->bitrate_str);
 
415
 
 
416
            return PJ_SUCCESS;
 
417
        }
 
418
    }
 
419
    
 
420
    /* No space for non-standard mode. */
 
421
    return PJ_ETOOMANY;
 
422
}
 
423
 
 
424
 
 
425
/*
 
426
 * Set level adjustment.
 
427
 */
 
428
PJ_DEF(pj_status_t)  pjmedia_codec_g7221_set_pcm_shift(int val)
 
429
{
 
430
    codec_factory.pcm_shift = val;
 
431
    return PJ_SUCCESS;
 
432
}
 
433
 
 
434
/*
 
435
 * Unregister G722.1 codec factory from pjmedia endpoint.
 
436
 */
 
437
PJ_DEF(pj_status_t) pjmedia_codec_g7221_deinit(void)
 
438
{
 
439
    pjmedia_codec_mgr *codec_mgr;
 
440
    pj_status_t status;
 
441
 
 
442
    if (codec_factory.pool == NULL) {
 
443
        /* Already deinitialized */
 
444
        return PJ_SUCCESS;
 
445
    }
 
446
 
 
447
    pj_mutex_lock(codec_factory.mutex);
 
448
 
 
449
    /* Get the codec manager. */
 
450
    codec_mgr = pjmedia_endpt_get_codec_mgr(codec_factory.endpt);
 
451
    if (!codec_mgr) {
 
452
        pj_pool_release(codec_factory.pool);
 
453
        codec_factory.pool = NULL;
 
454
        return PJ_EINVALIDOP;
 
455
    }
 
456
 
 
457
    /* Unregister G722.1 codec factory. */
 
458
    status = pjmedia_codec_mgr_unregister_factory(codec_mgr,
 
459
                                                  &codec_factory.base);
 
460
    
 
461
    /* Destroy mutex. */
 
462
    pj_mutex_destroy(codec_factory.mutex);
 
463
 
 
464
    /* Destroy pool. */
 
465
    pj_pool_release(codec_factory.pool);
 
466
    codec_factory.pool = NULL;
 
467
 
 
468
    return status;
 
469
}
 
470
 
 
471
/* 
 
472
 * Check if factory can allocate the specified codec. 
 
473
 */
 
474
static pj_status_t test_alloc( pjmedia_codec_factory *factory, 
 
475
                               const pjmedia_codec_info *info )
 
476
{
 
477
    PJ_UNUSED_ARG(factory);
 
478
 
 
479
    /* Type MUST be audio. */
 
480
    if (info->type != PJMEDIA_TYPE_AUDIO)
 
481
        return PJMEDIA_CODEC_EUNSUP;
 
482
 
 
483
    /* Check encoding name. */
 
484
    if (pj_stricmp2(&info->encoding_name, CODEC_TAG) != 0)
 
485
        return PJMEDIA_CODEC_EUNSUP;
 
486
 
 
487
    /* Check clock-rate */
 
488
    if (info->clock_rate != WB_SAMPLE_RATE && 
 
489
        info->clock_rate != UWB_SAMPLE_RATE)
 
490
    {
 
491
        return PJMEDIA_CODEC_EUNSUP;
 
492
    }
 
493
 
 
494
    return PJ_SUCCESS;
 
495
}
 
496
 
 
497
/*
 
498
 * Generate default attribute.
 
499
 */
 
500
static pj_status_t default_attr ( pjmedia_codec_factory *factory, 
 
501
                                  const pjmedia_codec_info *id, 
 
502
                                  pjmedia_codec_param *attr )
 
503
{
 
504
    codec_mode *mode;
 
505
 
 
506
    PJ_ASSERT_RETURN(factory==&codec_factory.base, PJ_EINVAL);
 
507
 
 
508
    pj_bzero(attr, sizeof(pjmedia_codec_param));
 
509
 
 
510
    mode = lookup_mode(id->pt);
 
511
    if (mode == NULL || !mode->enabled)
 
512
        return PJMEDIA_CODEC_EUNSUP;
 
513
 
 
514
    attr->info.pt = (pj_uint8_t)id->pt;
 
515
    attr->info.channel_cnt = 1;
 
516
    attr->info.clock_rate = mode->sample_rate;
 
517
    attr->info.max_bps = mode->bitrate;
 
518
    attr->info.avg_bps = mode->bitrate;
 
519
    attr->info.pcm_bits_per_sample = 16;
 
520
    attr->info.frm_ptime = 20;
 
521
 
 
522
    /* Default flags. */
 
523
    attr->setting.plc = 1;
 
524
    attr->setting.vad = 0;
 
525
    attr->setting.frm_per_pkt = 1;
 
526
 
 
527
    /* Default FMTP setting */
 
528
    attr->setting.dec_fmtp.cnt = 1;
 
529
    attr->setting.dec_fmtp.param[0].name = pj_str("bitrate");
 
530
    attr->setting.dec_fmtp.param[0].val = pj_str(mode->bitrate_str);
 
531
 
 
532
    return PJ_SUCCESS;
 
533
}
 
534
 
 
535
/*
 
536
 * Enum codecs supported by this factory.
 
537
 */
 
538
static pj_status_t enum_codecs( pjmedia_codec_factory *factory, 
 
539
                                unsigned *count, 
 
540
                                pjmedia_codec_info codecs[])
 
541
{
 
542
    unsigned i, max_cnt;
 
543
 
 
544
    PJ_ASSERT_RETURN(factory==&codec_factory.base, PJ_EINVAL);
 
545
    PJ_ASSERT_RETURN(codecs && *count > 0, PJ_EINVAL);
 
546
 
 
547
    max_cnt = *count;
 
548
    *count = 0;
 
549
    
 
550
    for (i=0; (i < codec_factory.mode_count) && (*count < max_cnt); ++i)
 
551
    {
 
552
        if (!codec_factory.modes[i].enabled)
 
553
            continue;
 
554
 
 
555
        pj_bzero(&codecs[*count], sizeof(pjmedia_codec_info));
 
556
        codecs[*count].encoding_name = pj_str((char*)CODEC_TAG);
 
557
        codecs[*count].pt = codec_factory.modes[i].pt;
 
558
        codecs[*count].type = PJMEDIA_TYPE_AUDIO;
 
559
        codecs[*count].clock_rate = codec_factory.modes[i].sample_rate;
 
560
        codecs[*count].channel_cnt = 1;
 
561
 
 
562
        ++ *count;
 
563
    }
 
564
 
 
565
    return PJ_SUCCESS;
 
566
}
 
567
 
 
568
/*
 
569
 * Allocate a new codec instance.
 
570
 */
 
571
static pj_status_t alloc_codec( pjmedia_codec_factory *factory, 
 
572
                                const pjmedia_codec_info *id,
 
573
                                pjmedia_codec **p_codec)
 
574
{
 
575
    codec_private_t *codec_data;
 
576
    pjmedia_codec *codec;
 
577
    pj_pool_t *pool;
 
578
    pj_status_t status;
 
579
 
 
580
    PJ_ASSERT_RETURN(factory && id && p_codec, PJ_EINVAL);
 
581
    PJ_ASSERT_RETURN(factory == &codec_factory.base, PJ_EINVAL);
 
582
 
 
583
    pj_mutex_lock(codec_factory.mutex);
 
584
 
 
585
    /* Create pool for codec instance */
 
586
    pool = pjmedia_endpt_create_pool(codec_factory.endpt, "G7221", 512, 512);
 
587
    codec = PJ_POOL_ZALLOC_T(pool, pjmedia_codec);
 
588
    codec->op = &codec_op;
 
589
    codec->factory = factory;
 
590
    codec->codec_data = PJ_POOL_ZALLOC_T(pool, codec_private_t);
 
591
    codec_data = (codec_private_t*) codec->codec_data;
 
592
    codec_data->pool = pool;
 
593
 
 
594
    /* Create silence detector */
 
595
    status = pjmedia_silence_det_create(pool, id->clock_rate, 
 
596
                                        id->clock_rate * 20 / 1000,
 
597
                                        &codec_data->vad);
 
598
    if (status != PJ_SUCCESS) {
 
599
        pj_mutex_unlock(codec_factory.mutex);
 
600
        return status;
 
601
    }
 
602
 
 
603
    pj_mutex_unlock(codec_factory.mutex);
 
604
 
 
605
    *p_codec = codec;
 
606
    return PJ_SUCCESS;
 
607
}
 
608
 
 
609
/*
 
610
 * Free codec.
 
611
 */
 
612
static pj_status_t dealloc_codec( pjmedia_codec_factory *factory, 
 
613
                                  pjmedia_codec *codec )
 
614
{
 
615
    codec_private_t *codec_data;
 
616
    pj_pool_t *pool;
 
617
 
 
618
    PJ_ASSERT_RETURN(factory && codec, PJ_EINVAL);
 
619
    PJ_ASSERT_RETURN(factory == &codec_factory.base, PJ_EINVAL);
 
620
 
 
621
    /* Close codec, if it's not closed. */
 
622
    codec_data = (codec_private_t*) codec->codec_data;
 
623
    pool = codec_data->pool;
 
624
    codec_close(codec);
 
625
 
 
626
    /* Release codec pool */
 
627
    pj_pool_release(pool);
 
628
 
 
629
    return PJ_SUCCESS;
 
630
}
 
631
 
 
632
/*
 
633
 * Init codec.
 
634
 */
 
635
static pj_status_t codec_init( pjmedia_codec *codec, 
 
636
                               pj_pool_t *pool )
 
637
{
 
638
    PJ_UNUSED_ARG(codec);
 
639
    PJ_UNUSED_ARG(pool);
 
640
    return PJ_SUCCESS;
 
641
}
 
642
 
 
643
/*
 
644
 * Open codec.
 
645
 */
 
646
static pj_status_t codec_open( pjmedia_codec *codec, 
 
647
                               pjmedia_codec_param *attr )
 
648
{
 
649
    codec_private_t *codec_data = (codec_private_t*) codec->codec_data;
 
650
    pj_pool_t *pool;
 
651
    unsigned tmp;
 
652
 
 
653
    /* Validation mode first! */
 
654
    if (!validate_mode(attr->info.clock_rate, attr->info.avg_bps))
 
655
        return PJMEDIA_CODEC_EINMODE;
 
656
 
 
657
    pool = codec_data->pool;
 
658
 
 
659
    /* Initialize common state */
 
660
    codec_data->vad_enabled = (attr->setting.vad != 0);
 
661
    codec_data->plc_enabled = (attr->setting.plc != 0);
 
662
 
 
663
    codec_data->bitrate = (pj_uint16_t)attr->info.avg_bps;
 
664
    codec_data->frame_size_bits = (pj_uint16_t)(attr->info.avg_bps*20/1000);
 
665
    codec_data->frame_size = (pj_uint16_t)(codec_data->frame_size_bits>>3);
 
666
    codec_data->samples_per_frame = (pj_uint16_t)
 
667
                                    (attr->info.clock_rate*20/1000);
 
668
    codec_data->number_of_regions = (pj_uint16_t)
 
669
                                    (attr->info.clock_rate <= WB_SAMPLE_RATE?
 
670
                                     NUMBER_OF_REGIONS:MAX_NUMBER_OF_REGIONS);
 
671
    codec_data->pcm_shift = codec_factory.pcm_shift;
 
672
 
 
673
    /* Initialize encoder state */
 
674
    tmp = codec_data->samples_per_frame << 1;
 
675
    codec_data->enc_old_frame = (Word16*)pj_pool_zalloc(pool, tmp);
 
676
    codec_data->enc_frame = (Word16*)pj_pool_alloc(pool, tmp);
 
677
 
 
678
    /* Initialize decoder state */
 
679
    tmp = codec_data->samples_per_frame;
 
680
    codec_data->dec_old_frame = (Word16*)pj_pool_zalloc(pool, tmp);
 
681
 
 
682
    tmp = codec_data->samples_per_frame << 1;
 
683
    codec_data->dec_old_mlt_coefs = (Word16*)pj_pool_zalloc(pool, tmp);
 
684
 
 
685
    codec_data->dec_randobj.seed0 = 1;
 
686
    codec_data->dec_randobj.seed1 = 1;
 
687
    codec_data->dec_randobj.seed2 = 1;
 
688
    codec_data->dec_randobj.seed3 = 1;
 
689
 
 
690
    return PJ_SUCCESS;
 
691
}
 
692
 
 
693
/*
 
694
 * Close codec.
 
695
 */
 
696
static pj_status_t codec_close( pjmedia_codec *codec )
 
697
{
 
698
    PJ_UNUSED_ARG(codec);
 
699
 
 
700
    return PJ_SUCCESS;
 
701
}
 
702
 
 
703
 
 
704
/*
 
705
 * Modify codec settings.
 
706
 */
 
707
static pj_status_t codec_modify( pjmedia_codec *codec, 
 
708
                                 const pjmedia_codec_param *attr )
 
709
{
 
710
    codec_private_t *codec_data = (codec_private_t*) codec->codec_data;
 
711
 
 
712
    codec_data->vad_enabled = (attr->setting.vad != 0);
 
713
    codec_data->plc_enabled = (attr->setting.plc != 0);
 
714
 
 
715
    return PJ_SUCCESS;
 
716
}
 
717
 
 
718
/*
 
719
 * Get frames in the packet.
 
720
 */
 
721
static pj_status_t codec_parse( pjmedia_codec *codec,
 
722
                                void *pkt,
 
723
                                pj_size_t pkt_size,
 
724
                                const pj_timestamp *ts,
 
725
                                unsigned *frame_cnt,
 
726
                                pjmedia_frame frames[])
 
727
{
 
728
    codec_private_t *codec_data = (codec_private_t*) codec->codec_data;
 
729
    unsigned count = 0;
 
730
 
 
731
    PJ_ASSERT_RETURN(frame_cnt, PJ_EINVAL);
 
732
 
 
733
    /* Parse based on fixed frame size. */
 
734
    while (pkt_size >= codec_data->frame_size && count < *frame_cnt) {
 
735
        frames[count].type = PJMEDIA_FRAME_TYPE_AUDIO;
 
736
        frames[count].buf = pkt;
 
737
        frames[count].size = codec_data->frame_size;
 
738
        frames[count].timestamp.u64 = ts->u64 + 
 
739
                                      count * codec_data->samples_per_frame;
 
740
 
 
741
        pkt = (pj_uint8_t*)pkt + codec_data->frame_size;
 
742
        pkt_size -= codec_data->frame_size;
 
743
 
 
744
        ++count;
 
745
    }
 
746
 
 
747
    pj_assert(pkt_size == 0);
 
748
    *frame_cnt = count;
 
749
 
 
750
    return PJ_SUCCESS;
 
751
}
 
752
 
 
753
/*
 
754
 * Encode frames.
 
755
 */
 
756
static pj_status_t codec_encode( pjmedia_codec *codec, 
 
757
                                 const struct pjmedia_frame *input,
 
758
                                 unsigned output_buf_len, 
 
759
                                 struct pjmedia_frame *output)
 
760
{
 
761
    codec_private_t *codec_data = (codec_private_t*) codec->codec_data;
 
762
    unsigned nsamples, processed;
 
763
 
 
764
    /* Check frame in & out size */
 
765
    nsamples = input->size >> 1;
 
766
    PJ_ASSERT_RETURN(nsamples % codec_data->samples_per_frame == 0, 
 
767
                     PJMEDIA_CODEC_EPCMFRMINLEN);
 
768
    PJ_ASSERT_RETURN(output_buf_len >= codec_data->frame_size * nsamples /
 
769
                     codec_data->samples_per_frame,
 
770
                     PJMEDIA_CODEC_EFRMTOOSHORT);
 
771
 
 
772
    /* Apply silence detection if VAD is enabled */
 
773
    if (codec_data->vad_enabled) {
 
774
        pj_bool_t is_silence;
 
775
        pj_int32_t silence_duration;
 
776
 
 
777
        pj_assert(codec_data->vad);
 
778
 
 
779
        silence_duration = pj_timestamp_diff32(&codec_data->last_tx, 
 
780
                                               &input->timestamp);
 
781
 
 
782
        is_silence = pjmedia_silence_det_detect(codec_data->vad, 
 
783
                                                (const pj_int16_t*) input->buf,
 
784
                                                (input->size >> 1),
 
785
                                                NULL);
 
786
        if (is_silence &&
 
787
            (PJMEDIA_CODEC_MAX_SILENCE_PERIOD == -1 ||
 
788
             silence_duration < (PJMEDIA_CODEC_MAX_SILENCE_PERIOD *
 
789
                                 (int)codec_data->samples_per_frame / 20)))
 
790
        {
 
791
            output->type = PJMEDIA_FRAME_TYPE_NONE;
 
792
            output->buf = NULL;
 
793
            output->size = 0;
 
794
            output->timestamp = input->timestamp;
 
795
            return PJ_SUCCESS;
 
796
        } else {
 
797
            codec_data->last_tx = input->timestamp;
 
798
        }
 
799
    }
 
800
 
 
801
    processed = 0;
 
802
    output->size = 0;
 
803
    while (processed < nsamples) {
 
804
        Word16 mlt_coefs[MAX_SAMPLES_PER_FRAME];
 
805
        Word16 mag_shift;
 
806
        const Word16 *pcm_input;
 
807
        pj_int8_t *out_bits;
 
808
        
 
809
        pcm_input = (const Word16*)input->buf + processed;
 
810
        out_bits = (pj_int8_t*)output->buf + output->size;
 
811
 
 
812
        /* Encoder adjust the input signal level */
 
813
        if (codec_data->pcm_shift) {
 
814
            unsigned i;
 
815
            for (i=0; i<codec_data->samples_per_frame; ++i) {
 
816
                codec_data->enc_frame[i] = 
 
817
                        (Word16)(pcm_input[i] >> codec_data->pcm_shift);
 
818
            }
 
819
            pcm_input = codec_data->enc_frame;
 
820
        }
 
821
 
 
822
        /* Convert input samples to rmlt coefs */
 
823
        mag_shift = samples_to_rmlt_coefs(pcm_input,
 
824
                                          codec_data->enc_old_frame, 
 
825
                                          mlt_coefs, 
 
826
                                          codec_data->samples_per_frame);
 
827
 
 
828
        /* Encode the mlt coefs. Note that encoder output stream is
 
829
         * 16 bit array, so we need to take care about endianness.
 
830
         */
 
831
        encoder(codec_data->frame_size_bits,
 
832
                codec_data->number_of_regions,
 
833
                mlt_coefs,
 
834
                mag_shift,
 
835
                (Word16*)out_bits);
 
836
 
 
837
        /* Encoder output are in native host byte order, while ITU says
 
838
         * it must be in network byte order (MSB first).
 
839
         */
 
840
        swap_bytes((pj_uint16_t*)out_bits, codec_data->frame_size/2);
 
841
 
 
842
        processed += codec_data->samples_per_frame;
 
843
        output->size += codec_data->frame_size;
 
844
    }
 
845
 
 
846
    output->type = PJMEDIA_FRAME_TYPE_AUDIO;
 
847
    output->timestamp = input->timestamp;
 
848
 
 
849
    return PJ_SUCCESS;
 
850
}
 
851
 
 
852
/*
 
853
 * Decode frame.
 
854
 */
 
855
static pj_status_t codec_decode( pjmedia_codec *codec, 
 
856
                                 const struct pjmedia_frame *input,
 
857
                                 unsigned output_buf_len, 
 
858
                                 struct pjmedia_frame *output)
 
859
{
 
860
    codec_private_t *codec_data = (codec_private_t*) codec->codec_data;
 
861
    Word16 mlt_coefs[MAX_SAMPLES_PER_FRAME];
 
862
    Word16 mag_shift;
 
863
    Bit_Obj bitobj;
 
864
    Word16 frame_error_flag = 0;
 
865
 
 
866
    /* Check frame out length size */
 
867
    PJ_ASSERT_RETURN(output_buf_len >= 
 
868
                    (unsigned)(codec_data->samples_per_frame<<1),
 
869
                     PJMEDIA_CODEC_EPCMTOOSHORT);
 
870
 
 
871
    /* If input is NULL, perform PLC by settting frame_error_flag to 1 */
 
872
    if (input) {
 
873
        /* Check frame in length size */
 
874
        PJ_ASSERT_RETURN((pj_uint16_t)input->size == codec_data->frame_size,
 
875
                         PJMEDIA_CODEC_EFRMINLEN);
 
876
 
 
877
        /* Decoder requires input of 16-bits array in native host byte
 
878
         * order, while the frame received from the network are in
 
879
         * network byte order (MSB first).
 
880
         */
 
881
        swap_bytes((pj_uint16_t*)input->buf, codec_data->frame_size/2);
 
882
 
 
883
        bitobj.code_word_ptr = (Word16*)input->buf;
 
884
        bitobj.current_word =  *bitobj.code_word_ptr;
 
885
        bitobj.code_bit_count = 0;
 
886
        bitobj.number_of_bits_left = codec_data->frame_size_bits;
 
887
 
 
888
        output->timestamp = input->timestamp;
 
889
    } else {
 
890
        pj_bzero(&bitobj, sizeof(bitobj));
 
891
        frame_error_flag = 1;
 
892
    }
 
893
 
 
894
    /* Process the input frame to get mlt coefs */
 
895
    decoder(&bitobj,
 
896
            &codec_data->dec_randobj,
 
897
            codec_data->number_of_regions,
 
898
            mlt_coefs,
 
899
            &mag_shift,
 
900
            &codec_data->dec_old_mag_shift,
 
901
            codec_data->dec_old_mlt_coefs,
 
902
            frame_error_flag);
 
903
 
 
904
    /* Convert the mlt_coefs to PCM samples */
 
905
    rmlt_coefs_to_samples(mlt_coefs, 
 
906
                          codec_data->dec_old_frame, 
 
907
                          (Word16*)output->buf, 
 
908
                          codec_data->samples_per_frame, 
 
909
                          mag_shift);
 
910
 
 
911
    /* Decoder adjust PCM signal */
 
912
    if (codec_data->pcm_shift) {
 
913
        unsigned i;
 
914
        pj_int16_t *buf = (Word16*)output->buf;
 
915
 
 
916
        for (i=0; i<codec_data->samples_per_frame; ++i) {
 
917
            buf[i] <<= codec_data->pcm_shift;
 
918
        }
 
919
    }
 
920
 
 
921
    output->type = PJMEDIA_FRAME_TYPE_AUDIO;
 
922
    output->size = codec_data->samples_per_frame << 1;
 
923
 
 
924
    return PJ_SUCCESS;
 
925
}
 
926
 
 
927
/* 
 
928
 * Recover lost frame.
 
929
 */
 
930
static pj_status_t codec_recover( pjmedia_codec *codec, 
 
931
                                  unsigned output_buf_len, 
 
932
                                  struct pjmedia_frame *output)
 
933
{
 
934
    codec_private_t *codec_data = (codec_private_t*) codec->codec_data;
 
935
 
 
936
    /* Use native PLC when PLC is enabled. */
 
937
    if (codec_data->plc_enabled)
 
938
        return codec_decode(codec, NULL, output_buf_len, output);
 
939
 
 
940
    /* Otherwise just return zero-fill frame. */
 
941
    output->type = PJMEDIA_FRAME_TYPE_AUDIO;
 
942
    output->size = codec_data->samples_per_frame << 1;
 
943
 
 
944
    pjmedia_zero_samples((pj_int16_t*)output->buf, 
 
945
                         codec_data->samples_per_frame);
 
946
 
 
947
    return PJ_SUCCESS;
 
948
}
 
949
 
 
950
#endif  /* PJMEDIA_HAS_G7221_CODEC */