← Back to branch summary

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

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.0.1/pjmedia/src/pjmedia-codec/ipp_codecs.c

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (1.1.11)
  • mto: This revision was merged to the branch mainline in revision 24.
  • Revision ID: package-import@ubuntu.com-20140128182336-3xenud1kbnwmf3mz
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.0.1/pjmedia/src/pjmedia-codec/ipp_codecs.c
1
 
/* $Id: ipp_codecs.c 4002 2012-03-30 08:05:43Z 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/ipp_codecs.h>
21
 
#include <pjmedia-codec/amr_sdp_match.h>
22
 
#include <pjmedia-codec/g7221_sdp_match.h>
23
 
#include <pjmedia/codec.h>
24
 
#include <pjmedia/errno.h>
25
 
#include <pjmedia/endpoint.h>
26
 
#include <pjmedia/plc.h>
27
 
#include <pjmedia/port.h>
28
 
#include <pjmedia/silencedet.h>
29
 
#include <pj/assert.h>
30
 
#include <pj/log.h>
31
 
#include <pj/math.h>
32
 
#include <pj/pool.h>
33
 
#include <pj/string.h>
34
 
#include <pj/os.h>
35
 
 
36
 
 
37
 
/*
38
 
 * Only build this file if PJMEDIA_HAS_INTEL_IPP != 0
39
 
 */
40
 
#if defined(PJMEDIA_HAS_INTEL_IPP) && PJMEDIA_HAS_INTEL_IPP != 0
41
 
 
42
 
#include <usc.h>
43
 
#include <ippversion.h>
44
 
 
45
 
#define THIS_FILE   "ipp_codecs.c"
46
 
 
47
 
 
48
 
/* Prototypes for IPP codecs factory */
49
 
static pj_status_t ipp_test_alloc( pjmedia_codec_factory *factory,
50
 
                                   const pjmedia_codec_info *id );
51
 
static pj_status_t ipp_default_attr( pjmedia_codec_factory *factory,
52
 
                                     const pjmedia_codec_info *id,
53
 
                                     pjmedia_codec_param *attr );
54
 
static pj_status_t ipp_enum_codecs( pjmedia_codec_factory *factory,
55
 
                                    unsigned *count,
56
 
                                    pjmedia_codec_info codecs[]);
57
 
static pj_status_t ipp_alloc_codec( pjmedia_codec_factory *factory,
58
 
                                    const pjmedia_codec_info *id,
59
 
                                    pjmedia_codec **p_codec);
60
 
static pj_status_t ipp_dealloc_codec( pjmedia_codec_factory *factory,
61
 
                                      pjmedia_codec *codec );
62
 
 
63
 
/* Prototypes for IPP codecs implementation. */
64
 
static pj_status_t  ipp_codec_init( pjmedia_codec *codec,
65
 
                                    pj_pool_t *pool );
66
 
static pj_status_t  ipp_codec_open( pjmedia_codec *codec,
67
 
                                    pjmedia_codec_param *attr );
68
 
static pj_status_t  ipp_codec_close( pjmedia_codec *codec );
69
 
static pj_status_t  ipp_codec_modify(pjmedia_codec *codec,
70
 
                                     const pjmedia_codec_param *attr );
71
 
static pj_status_t  ipp_codec_parse( pjmedia_codec *codec,
72
 
                                     void *pkt,
73
 
                                     pj_size_t pkt_size,
74
 
                                     const pj_timestamp *ts,
75
 
                                     unsigned *frame_cnt,
76
 
                                     pjmedia_frame frames[]);
77
 
static pj_status_t  ipp_codec_encode( pjmedia_codec *codec,
78
 
                                      const struct pjmedia_frame *input,
79
 
                                      unsigned output_buf_len,
80
 
                                      struct pjmedia_frame *output);
81
 
static pj_status_t  ipp_codec_decode( pjmedia_codec *codec,
82
 
                                      const struct pjmedia_frame *input,
83
 
                                      unsigned output_buf_len,
84
 
                                      struct pjmedia_frame *output);
85
 
static pj_status_t  ipp_codec_recover(pjmedia_codec *codec,
86
 
                                      unsigned output_buf_len,
87
 
                                      struct pjmedia_frame *output);
88
 
 
89
 
/* Definition for IPP codecs operations. */
90
 
static pjmedia_codec_op ipp_op =
91
 
{
92
 
    &ipp_codec_init,
93
 
    &ipp_codec_open,
94
 
    &ipp_codec_close,
95
 
    &ipp_codec_modify,
96
 
    &ipp_codec_parse,
97
 
    &ipp_codec_encode,
98
 
    &ipp_codec_decode,
99
 
    &ipp_codec_recover
100
 
};
101
 
 
102
 
/* Definition for IPP codecs factory operations. */
103
 
static pjmedia_codec_factory_op ipp_factory_op =
104
 
{
105
 
    &ipp_test_alloc,
106
 
    &ipp_default_attr,
107
 
    &ipp_enum_codecs,
108
 
    &ipp_alloc_codec,
109
 
    &ipp_dealloc_codec,
110
 
    &pjmedia_codec_ipp_deinit
111
 
};
112
 
 
113
 
/* IPP codecs factory */
114
 
static struct ipp_factory {
115
 
    pjmedia_codec_factory    base;
116
 
    pjmedia_endpt           *endpt;
117
 
    pj_pool_t               *pool;
118
 
    pj_mutex_t              *mutex;
119
 
    unsigned                 g7221_pcm_shift;
120
 
} ipp_factory;
121
 
 
122
 
/* IPP codecs private data. */
123
 
typedef struct ipp_private {
124
 
    int                  codec_idx;         /**< Codec index.               */
125
 
    void                *codec_setting;     /**< Specific codec setting.    */
126
 
    pj_pool_t           *pool;              /**< Pool for each instance.    */
127
 
 
128
 
    USC_Handle           enc;               /**< Encoder state.             */
129
 
    USC_Handle           dec;               /**< Decoder state.             */
130
 
    USC_CodecInfo       *info;              /**< Native codec info.         */
131
 
    pj_uint16_t          frame_size;        /**< Bitstream frame size.      */
132
 
 
133
 
    pj_bool_t            plc_enabled;       /**< PLC enabled flag.          */
134
 
    pjmedia_plc         *plc;               /**< PJMEDIA PLC engine, NULL if
135
 
                                                 codec has internal PLC.    */
136
 
 
137
 
    pj_bool_t            vad_enabled;       /**< VAD enabled flag.          */
138
 
    pjmedia_silence_det *vad;               /**< PJMEDIA VAD engine, NULL if
139
 
                                                 codec has internal VAD.    */
140
 
    pj_timestamp         last_tx;           /**< Timestamp of last transmit.*/
141
 
 
142
 
    unsigned             g7221_pcm_shift;   /**< G722.1 PCM level adjustment*/
143
 
} ipp_private_t;
144
 
 
145
 
 
146
 
/* USC codec implementations. */
147
 
extern USC_Fxns USC_G729AFP_Fxns;
148
 
extern USC_Fxns USC_G729I_Fxns;
149
 
extern USC_Fxns USC_G723_Fxns;
150
 
extern USC_Fxns USC_G726_Fxns;
151
 
extern USC_Fxns USC_G728_Fxns;
152
 
extern USC_Fxns USC_G722_Fxns;
153
 
extern USC_Fxns USC_GSMAMR_Fxns;
154
 
extern USC_Fxns USC_AMRWB_Fxns;
155
 
extern USC_Fxns USC_AMRWBE_Fxns;
156
 
 
157
 
 
158
 
/* CUSTOM CALLBACKS */
159
 
 
160
 
/* This callback is useful for translating RTP frame into USC frame, e.g:
161
 
 * reassigning frame attributes, reorder bitstream. Default behaviour of
162
 
 * the translation is just setting the USC frame buffer & its size as
163
 
 * specified in RTP frame, setting USC frame frametype to 0, setting bitrate
164
 
 * of USC frame to bitrate info of codec_data. Implement this callback when
165
 
 * the default behaviour is unapplicable.
166
 
 */
167
 
typedef void (*predecode_cb)(ipp_private_t *codec_data,
168
 
                             const pjmedia_frame *rtp_frame,
169
 
                             USC_Bitstream *usc_frame);
170
 
 
171
 
/* Parse frames from a packet. Default behaviour of frame parsing is
172
 
 * just separating frames based on calculating frame length derived
173
 
 * from bitrate. Implement this callback when the default behaviour is
174
 
 * unapplicable.
175
 
 */
176
 
typedef pj_status_t (*parse_cb)(ipp_private_t *codec_data, void *pkt,
177
 
                                pj_size_t pkt_size, const pj_timestamp *ts,
178
 
                                unsigned *frame_cnt, pjmedia_frame frames[]);
179
 
 
180
 
/* Pack frames into a packet. Default behaviour of packing frames is
181
 
 * just stacking the frames with octet aligned without adding any
182
 
 * payload header. Implement this callback when the default behaviour is
183
 
 * unapplicable.
184
 
 */
185
 
typedef pj_status_t (*pack_cb)(ipp_private_t *codec_data, void *pkt,
186
 
                               pj_size_t *pkt_size, pj_size_t max_pkt_size);
187
 
 
188
 
 
189
 
 
190
 
/* Custom callback implementations. */
191
 
static    void predecode_g723( ipp_private_t *codec_data,
192
 
                               const pjmedia_frame *rtp_frame,
193
 
                               USC_Bitstream *usc_frame);
194
 
static pj_status_t parse_g723( ipp_private_t *codec_data, void *pkt,
195
 
                               pj_size_t pkt_size, const pj_timestamp *ts,
196
 
                               unsigned *frame_cnt, pjmedia_frame frames[]);
197
 
 
198
 
static void predecode_g729( ipp_private_t *codec_data,
199
 
                            const pjmedia_frame *rtp_frame,
200
 
                            USC_Bitstream *usc_frame);
201
 
 
202
 
static    void predecode_amr( ipp_private_t *codec_data,
203
 
                              const pjmedia_frame *rtp_frame,
204
 
                              USC_Bitstream *usc_frame);
205
 
static pj_status_t parse_amr( ipp_private_t *codec_data, void *pkt,
206
 
                              pj_size_t pkt_size, const pj_timestamp *ts,
207
 
                              unsigned *frame_cnt, pjmedia_frame frames[]);
208
 
static  pj_status_t pack_amr( ipp_private_t *codec_data, void *pkt,
209
 
                              pj_size_t *pkt_size, pj_size_t max_pkt_size);
210
 
 
211
 
static    void predecode_g7221( ipp_private_t *codec_data,
212
 
                                const pjmedia_frame *rtp_frame,
213
 
                                USC_Bitstream *usc_frame);
214
 
static  pj_status_t pack_g7221( ipp_private_t *codec_data, void *pkt,
215
 
                                pj_size_t *pkt_size, pj_size_t max_pkt_size);
216
 
 
217
 
/* IPP codec implementation descriptions. */
218
 
static struct ipp_codec {
219
 
    int              enabled;           /* Is this codec enabled?           */
220
 
    const char      *name;              /* Codec name.                      */
221
 
    pj_uint8_t       pt;                /* Payload type.                    */
222
 
    USC_Fxns        *fxns;              /* USC callback functions.          */
223
 
    unsigned         clock_rate;        /* Codec's clock rate.              */
224
 
    unsigned         channel_count;     /* Codec's channel count.           */
225
 
    unsigned         samples_per_frame; /* Codec's samples count.           */
226
 
 
227
 
    unsigned         def_bitrate;       /* Default bitrate of this codec.   */
228
 
    unsigned         max_bitrate;       /* Maximum bitrate of this codec.   */
229
 
    pj_uint8_t       frm_per_pkt;       /* Default num of frames per packet.*/
230
 
    int              has_native_vad;    /* Codec has internal VAD?          */
231
 
    int              has_native_plc;    /* Codec has internal PLC?          */
232
 
 
233
 
    predecode_cb     predecode;         /* Callback to translate RTP frame
234
 
                                           into USC frame.                  */
235
 
    parse_cb         parse;             /* Callback to parse bitstream.     */
236
 
    pack_cb          pack;              /* Callback to pack bitstream.      */
237
 
 
238
 
    pjmedia_codec_fmtp dec_fmtp;        /* Decoder's fmtp params.           */
239
 
}
240
 
 
241
 
ipp_codec[] =
242
 
{
243
 
#   if PJMEDIA_HAS_INTEL_IPP_CODEC_AMR
244
 
    {1, "AMR",      PJMEDIA_RTP_PT_AMR,       &USC_GSMAMR_Fxns,  8000, 1, 160,
245
 
                    7400, 12200, 2, 1, 1,
246
 
                    &predecode_amr, &parse_amr, &pack_amr,
247
 
                    {1, {{{"octet-align", 11}, {"1", 1}}} }
248
 
    },
249
 
#   endif
250
 
 
251
 
#   if PJMEDIA_HAS_INTEL_IPP_CODEC_AMRWB
252
 
    {1, "AMR-WB",   PJMEDIA_RTP_PT_AMRWB,     &USC_AMRWB_Fxns,  16000, 1, 320,
253
 
                    15850, 23850, 2, 1, 1,
254
 
                    &predecode_amr, &parse_amr, &pack_amr,
255
 
                    {1, {{{"octet-align", 11}, {"1", 1}}} }
256
 
    },
257
 
#   endif
258
 
 
259
 
#   if PJMEDIA_HAS_INTEL_IPP_CODEC_G729
260
 
#       if defined(PJ_HAS_FLOATING_POINT) && (PJ_HAS_FLOATING_POINT != 0)
261
 
    {1, "G729",     PJMEDIA_RTP_PT_G729,      &USC_G729AFP_Fxns, 8000, 1,  80,
262
 
                    8000, 11800, 2, 1, 1,
263
 
                    &predecode_g729, NULL, NULL
264
 
    },
265
 
#       else
266
 
    {1, "G729",     PJMEDIA_RTP_PT_G729,      &USC_G729I_Fxns,   8000, 1,  80,
267
 
                    8000, 11800, 2, 1, 1,
268
 
                    &predecode_g729, NULL, NULL
269
 
    },
270
 
#       endif
271
 
#   endif
272
 
 
273
 
#   if PJMEDIA_HAS_INTEL_IPP_CODEC_G723_1
274
 
    /* This is actually G.723.1 */
275
 
    {1, "G723",     PJMEDIA_RTP_PT_G723,      &USC_G723_Fxns,    8000, 1, 240,
276
 
                    6300,  6300, 1, 1, 1,
277
 
                    &predecode_g723, &parse_g723, NULL
278
 
    },
279
 
#   endif
280
 
 
281
 
#   if PJMEDIA_HAS_INTEL_IPP_CODEC_G726
282
 
    {0, "G726-16",  PJMEDIA_RTP_PT_G726_16,   &USC_G726_Fxns,    8000, 1,  80,
283
 
                    16000, 16000, 2, 0, 0,
284
 
                    NULL, NULL, NULL
285
 
    },
286
 
    {0, "G726-24",  PJMEDIA_RTP_PT_G726_24,   &USC_G726_Fxns,    8000, 1,  80,
287
 
                    24000, 24000, 2, 0, 0,
288
 
                    NULL, NULL, NULL
289
 
    },
290
 
    {1, "G726-32",  PJMEDIA_RTP_PT_G726_32,   &USC_G726_Fxns,    8000, 1,  80,
291
 
                    32000, 32000, 2, 0, 0,
292
 
                    NULL, NULL, NULL
293
 
    },
294
 
    {0, "G726-40",  PJMEDIA_RTP_PT_G726_40,   &USC_G726_Fxns,    8000, 1,  80,
295
 
                    40000, 40000, 2, 0, 0,
296
 
                    NULL, NULL, NULL
297
 
    },
298
 
    /* Old definition of G726-32 */
299
 
    {1, "G721",     PJMEDIA_RTP_PT_G721,      &USC_G726_Fxns,    8000, 1,  80,
300
 
                    32000, 32000, 2, 0, 0,
301
 
                    NULL, NULL, NULL
302
 
    },
303
 
#   endif
304
 
 
305
 
#   if PJMEDIA_HAS_INTEL_IPP_CODEC_G728
306
 
    {1, "G728",     PJMEDIA_RTP_PT_G728,      &USC_G728_Fxns,    8000, 1,  80,
307
 
                    16000, 16000, 2, 0, 1,
308
 
                    NULL, NULL, NULL
309
 
    },
310
 
#   endif
311
 
 
312
 
#   if PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1
313
 
    {0, "G7221",    PJMEDIA_RTP_PT_G722_1_16, &USC_G722_Fxns,   16000, 1, 320,
314
 
                    16000, 16000, 1, 0, 1,
315
 
                    predecode_g7221, NULL, pack_g7221,
316
 
                    {1, {{{"bitrate", 7}, {"16000", 5}}} }
317
 
    },
318
 
    {1, "G7221",    PJMEDIA_RTP_PT_G722_1_24, &USC_G722_Fxns,   16000, 1, 320,
319
 
                    24000, 24000, 1, 0, 1,
320
 
                    predecode_g7221, NULL, pack_g7221,
321
 
                    {1, {{{"bitrate", 7}, {"24000", 5}}} }
322
 
    },
323
 
    {1, "G7221",    PJMEDIA_RTP_PT_G722_1_32, &USC_G722_Fxns,   16000, 1, 320,
324
 
                    32000, 32000, 1, 0, 1,
325
 
                    predecode_g7221, NULL, pack_g7221,
326
 
                    {1, {{{"bitrate", 7}, {"32000", 5}}} }
327
 
    },
328
 
#   endif
329
 
};
330
 
 
331
 
 
332
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_G729
333
 
 
334
 
static void predecode_g729( ipp_private_t *codec_data,
335
 
                            const pjmedia_frame *rtp_frame,
336
 
                            USC_Bitstream *usc_frame)
337
 
{
338
 
    switch (rtp_frame->size) {
339
 
    case 2:
340
 
        /* SID */
341
 
        usc_frame->frametype = 1;
342
 
        usc_frame->bitrate = codec_data->info->params.modes.bitrate;
343
 
        break;
344
 
    case 8:
345
 
        /* G729D */
346
 
        usc_frame->frametype = 2;
347
 
        usc_frame->bitrate = 6400;
348
 
        break;
349
 
    case 10:
350
 
        /* G729 */
351
 
        usc_frame->frametype = 3;
352
 
        usc_frame->bitrate = 8000;
353
 
        break;
354
 
    case 15:
355
 
        /* G729E */
356
 
        usc_frame->frametype = 4;
357
 
        usc_frame->bitrate = 11800;
358
 
        break;
359
 
    default:
360
 
        usc_frame->frametype = 0;
361
 
        usc_frame->bitrate = 0;
362
 
        break;
363
 
    }
364
 
 
365
 
    usc_frame->pBuffer = rtp_frame->buf;
366
 
    usc_frame->nbytes = rtp_frame->size;
367
 
}
368
 
 
369
 
#endif /* PJMEDIA_HAS_INTEL_IPP_CODEC_G729 */
370
 
 
371
 
 
372
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_G723_1
373
 
 
374
 
static    void predecode_g723( ipp_private_t *codec_data,
375
 
                               const pjmedia_frame *rtp_frame,
376
 
                               USC_Bitstream *usc_frame)
377
 
{
378
 
    int i, HDR = 0;
379
 
    pj_uint8_t *f = (pj_uint8_t*)rtp_frame->buf;
380
 
 
381
 
    PJ_UNUSED_ARG(codec_data);
382
 
 
383
 
    for (i = 0; i < 2; ++i){
384
 
        int tmp;
385
 
        tmp = (f[0] >> (i & 0x7)) & 1;
386
 
        HDR +=  tmp << i ;
387
 
    }
388
 
 
389
 
    usc_frame->pBuffer = rtp_frame->buf;
390
 
    usc_frame->nbytes = rtp_frame->size;
391
 
    usc_frame->bitrate = HDR == 0? 6300 : 5300;
392
 
    usc_frame->frametype = 0;
393
 
}
394
 
 
395
 
static pj_status_t parse_g723(ipp_private_t *codec_data, void *pkt,
396
 
                              pj_size_t pkt_size, const pj_timestamp *ts,
397
 
                              unsigned *frame_cnt, pjmedia_frame frames[])
398
 
{
399
 
    unsigned count = 0;
400
 
    pj_uint8_t *f = (pj_uint8_t*)pkt;
401
 
 
402
 
    while (pkt_size && count < *frame_cnt) {
403
 
        int framesize, i, j;
404
 
        int HDR = 0;
405
 
 
406
 
        for (i = 0; i < 2; ++i){
407
 
            j = (f[0] >> (i & 0x7)) & 1;
408
 
            HDR +=  j << i ;
409
 
        }
410
 
 
411
 
        if (HDR == 0)
412
 
            framesize = 24;
413
 
        else if (HDR == 1)
414
 
            framesize = 20;
415
 
        else if (HDR == 2)
416
 
            framesize = 4;
417
 
        else if (HDR == 3)
418
 
            framesize = 1;
419
 
        else {
420
 
            pj_assert(!"Unknown G723.1 frametype, packet may be corrupted!");
421
 
            return PJMEDIA_CODEC_EINMODE;
422
 
        }
423
 
 
424
 
        frames[count].type = PJMEDIA_FRAME_TYPE_AUDIO;
425
 
        frames[count].buf = f;
426
 
        frames[count].size = framesize;
427
 
        frames[count].timestamp.u64 = ts->u64 + count *
428
 
                        ipp_codec[codec_data->codec_idx].samples_per_frame;
429
 
 
430
 
        f += framesize;
431
 
        pkt_size -= framesize;
432
 
 
433
 
        ++count;
434
 
    }
435
 
 
436
 
    *frame_cnt = count;
437
 
    return PJ_SUCCESS;
438
 
}
439
 
 
440
 
#endif /* PJMEDIA_HAS_INTEL_IPP_CODEC_G723_1 */
441
 
 
442
 
 
443
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_AMR || PJMEDIA_HAS_INTEL_IPP_CODEC_AMRWB
444
 
 
445
 
#include <pjmedia-codec/amr_helper.h>
446
 
 
447
 
typedef struct amr_settings_t {
448
 
    pjmedia_codec_amr_pack_setting enc_setting;
449
 
    pjmedia_codec_amr_pack_setting dec_setting;
450
 
    pj_int8_t enc_mode;
451
 
} amr_settings_t;
452
 
 
453
 
 
454
 
/* Rearrange AMR bitstream and convert RTP frame into USC frame:
455
 
 * - make the start_bit to be 0
456
 
 * - if it is speech frame, reorder bitstream from sensitivity bits order
457
 
 *   to encoder bits order.
458
 
 * - set the appropriate value of usc_frame.
459
 
 */
460
 
static void predecode_amr( ipp_private_t *codec_data,
461
 
                           const pjmedia_frame *rtp_frame,
462
 
                           USC_Bitstream *usc_frame)
463
 
{
464
 
    pjmedia_frame frame;
465
 
    pjmedia_codec_amr_bit_info *info;
466
 
    pjmedia_codec_amr_pack_setting *setting;
467
 
 
468
 
    setting = &((amr_settings_t*)codec_data->codec_setting)->dec_setting;
469
 
 
470
 
    frame = *rtp_frame;
471
 
    pjmedia_codec_amr_predecode(rtp_frame, setting, &frame);
472
 
    info = (pjmedia_codec_amr_bit_info*) &frame.bit_info;
473
 
 
474
 
    usc_frame->pBuffer = frame.buf;
475
 
    usc_frame->nbytes = frame.size;
476
 
    if (info->mode != -1) {
477
 
        usc_frame->bitrate = setting->amr_nb?
478
 
                             pjmedia_codec_amrnb_bitrates[info->mode]:
479
 
                             pjmedia_codec_amrwb_bitrates[info->mode];
480
 
    } else {
481
 
        usc_frame->bitrate = 0;
482
 
    }
483
 
 
484
 
    if (frame.size > 5) {
485
 
        /* Speech */
486
 
        if (info->good_quality)
487
 
            usc_frame->frametype = 0;
488
 
        else
489
 
            usc_frame->frametype = setting->amr_nb ? 5 : 6;
490
 
    } else if (frame.size == 5) {
491
 
        /* SID */
492
 
        if (info->good_quality) {
493
 
            usc_frame->frametype = info->STI? 2 : 1;
494
 
        } else {
495
 
            usc_frame->frametype = setting->amr_nb ? 6 : 7;
496
 
        }
497
 
    } else {
498
 
        /* no data */
499
 
        usc_frame->frametype = 3;
500
 
    }
501
 
}
502
 
 
503
 
/* Pack AMR payload */
504
 
static pj_status_t pack_amr(ipp_private_t *codec_data, void *pkt,
505
 
                            pj_size_t *pkt_size, pj_size_t max_pkt_size)
506
 
{
507
 
    enum {MAX_FRAMES_PER_PACKET = PJMEDIA_MAX_FRAME_DURATION_MS / 20};
508
 
 
509
 
    pjmedia_frame frames[MAX_FRAMES_PER_PACKET];
510
 
    unsigned nframes = 0;
511
 
    pjmedia_codec_amr_bit_info *info;
512
 
    pj_uint8_t *r; /* Read cursor */
513
 
    pj_uint8_t SID_FT;
514
 
    pjmedia_codec_amr_pack_setting *setting;
515
 
    const pj_uint8_t *framelen_tbl;
516
 
 
517
 
    setting = &((amr_settings_t*)codec_data->codec_setting)->enc_setting;
518
 
    framelen_tbl = setting->amr_nb? pjmedia_codec_amrnb_framelen:
519
 
                                    pjmedia_codec_amrwb_framelen;
520
 
 
521
 
    SID_FT = (pj_uint8_t)(setting->amr_nb? 8 : 9);
522
 
 
523
 
    /* Align pkt buf right */
524
 
    r = (pj_uint8_t*)pkt + max_pkt_size - *pkt_size;
525
 
    pj_memmove(r, pkt, *pkt_size);
526
 
 
527
 
    /* Get frames */
528
 
    for (;;) {
529
 
        pj_bool_t eof;
530
 
        pj_uint16_t info_;
531
 
 
532
 
        info_ = *((pj_uint16_t*)r);
533
 
        eof = ((info_ & 0x40) != 0);
534
 
 
535
 
        info = (pjmedia_codec_amr_bit_info*) &frames[nframes].bit_info;
536
 
        pj_bzero(info, sizeof(*info));
537
 
        info->frame_type = (pj_uint8_t)(info_ & 0x0F);
538
 
        info->good_quality = (pj_uint8_t)((info_ & 0x80) == 0);
539
 
        info->mode = (pj_int8_t) ((info_ >> 8) & 0x0F);
540
 
        info->STI = (pj_uint8_t)((info_ >> 5) & 1);
541
 
 
542
 
        frames[nframes].buf = r + 2;
543
 
        frames[nframes].size = info->frame_type <= SID_FT ?
544
 
                               framelen_tbl[info->frame_type] : 0;
545
 
 
546
 
        r += frames[nframes].size + 2;
547
 
 
548
 
        /* Last frame */
549
 
        if (++nframes >= MAX_FRAMES_PER_PACKET || eof)
550
 
            break;
551
 
    }
552
 
 
553
 
    /* Pack */
554
 
    *pkt_size = max_pkt_size;
555
 
    return pjmedia_codec_amr_pack(frames, nframes, setting, pkt, pkt_size);
556
 
}
557
 
 
558
 
 
559
 
/* Parse AMR payload into frames. */
560
 
static pj_status_t parse_amr(ipp_private_t *codec_data, void *pkt,
561
 
                             pj_size_t pkt_size, const pj_timestamp *ts,
562
 
                             unsigned *frame_cnt, pjmedia_frame frames[])
563
 
{
564
 
    amr_settings_t* s = (amr_settings_t*)codec_data->codec_setting;
565
 
    pjmedia_codec_amr_pack_setting *setting;
566
 
    pj_status_t status;
567
 
    pj_uint8_t cmr;
568
 
 
569
 
    setting = &s->dec_setting;
570
 
 
571
 
    status = pjmedia_codec_amr_parse(pkt, pkt_size, ts, setting, frames,
572
 
                                     frame_cnt, &cmr);
573
 
    if (status != PJ_SUCCESS)
574
 
        return status;
575
 
 
576
 
    /* Check Change Mode Request. */
577
 
    if (((setting->amr_nb && cmr <= 7) || (!setting->amr_nb && cmr <= 8)) &&
578
 
        s->enc_mode != cmr)
579
 
    {
580
 
        struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
581
 
 
582
 
        s->enc_mode = cmr;
583
 
        codec_data->info->params.modes.bitrate = s->enc_setting.amr_nb?
584
 
                                pjmedia_codec_amrnb_bitrates[s->enc_mode] :
585
 
                                pjmedia_codec_amrwb_bitrates[s->enc_mode];
586
 
        ippc->fxns->std.Control(&codec_data->info->params.modes,
587
 
                                codec_data->enc);
588
 
 
589
 
        PJ_LOG(4,(THIS_FILE, "AMR%s switched encoding mode to: %d (%dbps)",
590
 
                  (s->enc_setting.amr_nb?"":"-WB"),
591
 
                  s->enc_mode,
592
 
                  codec_data->info->params.modes.bitrate));
593
 
    }
594
 
 
595
 
    return PJ_SUCCESS;
596
 
}
597
 
 
598
 
#endif /* PJMEDIA_HAS_INTEL_IPP_CODEC_AMR */
599
 
 
600
 
 
601
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1
602
 
 
603
 
static void predecode_g7221( ipp_private_t *codec_data,
604
 
                             const pjmedia_frame *rtp_frame,
605
 
                             USC_Bitstream *usc_frame)
606
 
{
607
 
    usc_frame->pBuffer = (char*)rtp_frame->buf;
608
 
    usc_frame->nbytes = rtp_frame->size;
609
 
    usc_frame->frametype = 0;
610
 
    usc_frame->bitrate = codec_data->info->params.modes.bitrate;
611
 
 
612
 
#if defined(PJ_IS_LITTLE_ENDIAN) && PJ_IS_LITTLE_ENDIAN!=0
613
 
    {
614
 
        pj_uint16_t *p, *p_end;
615
 
 
616
 
        p = (pj_uint16_t*)rtp_frame->buf;
617
 
        p_end = p + rtp_frame->size/2;
618
 
        while (p < p_end) {
619
 
            *p = pj_ntohs(*p);
620
 
            ++p;
621
 
        }
622
 
    }
623
 
#endif
624
 
}
625
 
 
626
 
static pj_status_t pack_g7221( ipp_private_t *codec_data, void *pkt,
627
 
                               pj_size_t *pkt_size, pj_size_t max_pkt_size)
628
 
{
629
 
    PJ_UNUSED_ARG(codec_data);
630
 
    PJ_UNUSED_ARG(max_pkt_size);
631
 
 
632
 
#if defined(PJ_IS_LITTLE_ENDIAN) && PJ_IS_LITTLE_ENDIAN!=0
633
 
    {
634
 
        pj_uint16_t *p, *p_end;
635
 
 
636
 
        p = (pj_uint16_t*)pkt;
637
 
        p_end = p + *pkt_size/2;
638
 
        while (p < p_end) {
639
 
            *p = pj_htons(*p);
640
 
            ++p;
641
 
        }
642
 
    }
643
 
#else
644
 
    PJ_UNUSED_ARG(pkt);
645
 
    PJ_UNUSED_ARG(pkt_size);
646
 
#endif
647
 
 
648
 
    return PJ_SUCCESS;
649
 
}
650
 
 
651
 
 
652
 
#include <pjmedia-codec/g7221.h>
653
 
 
654
 
 
655
 
PJ_DEF(pj_status_t) pjmedia_codec_g7221_set_pcm_shift(int val)
656
 
{
657
 
    PJ_ASSERT_RETURN(val >= 0, PJ_EINVAL);
658
 
 
659
 
    ipp_factory.g7221_pcm_shift = val;
660
 
    return PJ_SUCCESS;
661
 
}
662
 
 
663
 
 
664
 
#endif /* PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1 */
665
 
 
666
 
/*
667
 
 * Initialize and register IPP codec factory to pjmedia endpoint.
668
 
 */
669
 
PJ_DEF(pj_status_t) pjmedia_codec_ipp_init( pjmedia_endpt *endpt )
670
 
{
671
 
    pjmedia_codec_mgr *codec_mgr;
672
 
    pj_str_t codec_name;
673
 
    pj_status_t status;
674
 
 
675
 
    if (ipp_factory.pool != NULL) {
676
 
        /* Already initialized. */
677
 
        return PJ_SUCCESS;
678
 
    }
679
 
 
680
 
    /* Create IPP codec factory. */
681
 
    ipp_factory.base.op = &ipp_factory_op;
682
 
    ipp_factory.base.factory_data = NULL;
683
 
    ipp_factory.endpt = endpt;
684
 
    ipp_factory.g7221_pcm_shift = PJMEDIA_G7221_DEFAULT_PCM_SHIFT;
685
 
 
686
 
    ipp_factory.pool = pjmedia_endpt_create_pool(endpt, "IPP codecs", 4000, 4000);
687
 
    if (!ipp_factory.pool)
688
 
        return PJ_ENOMEM;
689
 
 
690
 
    /* Create mutex. */
691
 
    status = pj_mutex_create_simple(ipp_factory.pool, "IPP codecs",
692
 
                                    &ipp_factory.mutex);
693
 
    if (status != PJ_SUCCESS)
694
 
        goto on_error;
695
 
 
696
 
    /* Get the codec manager. */
697
 
    codec_mgr = pjmedia_endpt_get_codec_mgr(endpt);
698
 
    if (!codec_mgr) {
699
 
        status = PJ_EINVALIDOP;
700
 
        goto on_error;
701
 
    }
702
 
 
703
 
    /* Register format match callback. */
704
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1
705
 
    pj_cstr(&codec_name, "G7221");
706
 
    status = pjmedia_sdp_neg_register_fmt_match_cb(
707
 
                                        &codec_name,
708
 
                                        &pjmedia_codec_g7221_match_sdp);
709
 
    if (status != PJ_SUCCESS)
710
 
        goto on_error;
711
 
#endif
712
 
 
713
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_AMR
714
 
    pj_cstr(&codec_name, "AMR");
715
 
    status = pjmedia_sdp_neg_register_fmt_match_cb(
716
 
                                        &codec_name,
717
 
                                        &pjmedia_codec_amr_match_sdp);
718
 
    if (status != PJ_SUCCESS)
719
 
        goto on_error;
720
 
#endif
721
 
 
722
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_AMRWB
723
 
    pj_cstr(&codec_name, "AMR-WB");
724
 
    status = pjmedia_sdp_neg_register_fmt_match_cb(
725
 
                                        &codec_name,
726
 
                                        &pjmedia_codec_amr_match_sdp);
727
 
    if (status != PJ_SUCCESS)
728
 
        goto on_error;
729
 
#endif
730
 
 
731
 
    /* Suppress compile warning */
732
 
    PJ_UNUSED_ARG(codec_name);
733
 
 
734
 
    /* Register codec factory to endpoint. */
735
 
    status = pjmedia_codec_mgr_register_factory(codec_mgr,
736
 
                                                &ipp_factory.base);
737
 
    if (status != PJ_SUCCESS)
738
 
        goto on_error;
739
 
 
740
 
    /* Done. */
741
 
    return PJ_SUCCESS;
742
 
 
743
 
on_error:
744
 
    pj_pool_release(ipp_factory.pool);
745
 
    ipp_factory.pool = NULL;
746
 
    return status;
747
 
}
748
 
 
749
 
/*
750
 
 * Unregister IPP codecs factory from pjmedia endpoint.
751
 
 */
752
 
PJ_DEF(pj_status_t) pjmedia_codec_ipp_deinit(void)
753
 
{
754
 
    pjmedia_codec_mgr *codec_mgr;
755
 
    pj_status_t status;
756
 
 
757
 
    if (ipp_factory.pool == NULL) {
758
 
        /* Already deinitialized */
759
 
        return PJ_SUCCESS;
760
 
    }
761
 
 
762
 
    pj_mutex_lock(ipp_factory.mutex);
763
 
 
764
 
    /* Get the codec manager. */
765
 
    codec_mgr = pjmedia_endpt_get_codec_mgr(ipp_factory.endpt);
766
 
    if (!codec_mgr) {
767
 
        pj_pool_release(ipp_factory.pool);
768
 
        ipp_factory.pool = NULL;
769
 
        return PJ_EINVALIDOP;
770
 
    }
771
 
 
772
 
    /* Unregister IPP codecs factory. */
773
 
    status = pjmedia_codec_mgr_unregister_factory(codec_mgr,
774
 
                                                  &ipp_factory.base);
775
 
 
776
 
    /* Destroy mutex. */
777
 
    pj_mutex_destroy(ipp_factory.mutex);
778
 
 
779
 
    /* Destroy pool. */
780
 
    pj_pool_release(ipp_factory.pool);
781
 
    ipp_factory.pool = NULL;
782
 
 
783
 
    return status;
784
 
}
785
 
 
786
 
 
787
 
/*
788
 
 * Check if factory can allocate the specified codec.
789
 
 */
790
 
static pj_status_t ipp_test_alloc( pjmedia_codec_factory *factory,
791
 
                                   const pjmedia_codec_info *info )
792
 
{
793
 
    unsigned i;
794
 
 
795
 
    PJ_UNUSED_ARG(factory);
796
 
 
797
 
    /* Type MUST be audio. */
798
 
    if (info->type != PJMEDIA_TYPE_AUDIO)
799
 
        return PJMEDIA_CODEC_EUNSUP;
800
 
 
801
 
    for (i = 0; i < PJ_ARRAY_SIZE(ipp_codec); ++i) {
802
 
        pj_str_t name = pj_str((char*)ipp_codec[i].name);
803
 
        if ((pj_stricmp(&info->encoding_name, &name) == 0) &&
804
 
            (info->clock_rate == (unsigned)ipp_codec[i].clock_rate) &&
805
 
            (info->channel_cnt == (unsigned)ipp_codec[i].channel_count) &&
806
 
            (ipp_codec[i].enabled))
807
 
        {
808
 
            return PJ_SUCCESS;
809
 
        }
810
 
    }
811
 
 
812
 
    /* Unsupported, or mode is disabled. */
813
 
    return PJMEDIA_CODEC_EUNSUP;
814
 
}
815
 
 
816
 
/*
817
 
 * Generate default attribute.
818
 
 */
819
 
static pj_status_t ipp_default_attr (pjmedia_codec_factory *factory,
820
 
                                      const pjmedia_codec_info *id,
821
 
                                      pjmedia_codec_param *attr )
822
 
{
823
 
    unsigned i;
824
 
 
825
 
    PJ_ASSERT_RETURN(factory==&ipp_factory.base, PJ_EINVAL);
826
 
 
827
 
    pj_bzero(attr, sizeof(pjmedia_codec_param));
828
 
 
829
 
    for (i = 0; i < PJ_ARRAY_SIZE(ipp_codec); ++i) {
830
 
        pj_str_t name = pj_str((char*)ipp_codec[i].name);
831
 
        if ((pj_stricmp(&id->encoding_name, &name) == 0) &&
832
 
            (id->clock_rate == (unsigned)ipp_codec[i].clock_rate) &&
833
 
            (id->channel_cnt == (unsigned)ipp_codec[i].channel_count) &&
834
 
            (id->pt == (unsigned)ipp_codec[i].pt))
835
 
        {
836
 
            attr->info.pt = (pj_uint8_t)id->pt;
837
 
            attr->info.channel_cnt = ipp_codec[i].channel_count;
838
 
            attr->info.clock_rate = ipp_codec[i].clock_rate;
839
 
            attr->info.avg_bps = ipp_codec[i].def_bitrate;
840
 
            attr->info.max_bps = ipp_codec[i].max_bitrate;
841
 
            attr->info.pcm_bits_per_sample = 16;
842
 
            attr->info.frm_ptime =  (pj_uint16_t)
843
 
                                    (ipp_codec[i].samples_per_frame * 1000 /
844
 
                                    ipp_codec[i].channel_count /
845
 
                                    ipp_codec[i].clock_rate);
846
 
            attr->setting.frm_per_pkt = ipp_codec[i].frm_per_pkt;
847
 
 
848
 
            /* Default flags. */
849
 
            attr->setting.plc = 1;
850
 
            attr->setting.penh= 0;
851
 
            attr->setting.vad = 1;
852
 
            attr->setting.cng = attr->setting.vad;
853
 
            attr->setting.dec_fmtp = ipp_codec[i].dec_fmtp;
854
 
 
855
 
            if (attr->setting.vad == 0) {
856
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_G729
857
 
                if (id->pt == PJMEDIA_RTP_PT_G729) {
858
 
                    /* Signal G729 Annex B is being disabled */
859
 
                    attr->setting.dec_fmtp.cnt = 1;
860
 
                    pj_strset2(&attr->setting.dec_fmtp.param[0].name, "annexb");
861
 
                    pj_strset2(&attr->setting.dec_fmtp.param[0].val, "no");
862
 
                }
863
 
#endif
864
 
            }
865
 
 
866
 
            return PJ_SUCCESS;
867
 
        }
868
 
    }
869
 
 
870
 
    return PJMEDIA_CODEC_EUNSUP;
871
 
}
872
 
 
873
 
/*
874
 
 * Enum codecs supported by this factory.
875
 
 */
876
 
static pj_status_t ipp_enum_codecs(pjmedia_codec_factory *factory,
877
 
                                    unsigned *count,
878
 
                                    pjmedia_codec_info codecs[])
879
 
{
880
 
    unsigned max;
881
 
    unsigned i;
882
 
 
883
 
    PJ_UNUSED_ARG(factory);
884
 
    PJ_ASSERT_RETURN(codecs && *count > 0, PJ_EINVAL);
885
 
 
886
 
    max = *count;
887
 
 
888
 
    for (i = 0, *count = 0; i < PJ_ARRAY_SIZE(ipp_codec) && *count < max; ++i)
889
 
    {
890
 
        if (!ipp_codec[i].enabled)
891
 
            continue;
892
 
 
893
 
        pj_bzero(&codecs[*count], sizeof(pjmedia_codec_info));
894
 
        codecs[*count].encoding_name = pj_str((char*)ipp_codec[i].name);
895
 
        codecs[*count].pt = ipp_codec[i].pt;
896
 
        codecs[*count].type = PJMEDIA_TYPE_AUDIO;
897
 
        codecs[*count].clock_rate = ipp_codec[i].clock_rate;
898
 
        codecs[*count].channel_cnt = ipp_codec[i].channel_count;
899
 
 
900
 
        ++*count;
901
 
    }
902
 
 
903
 
    return PJ_SUCCESS;
904
 
}
905
 
 
906
 
/*
907
 
 * Allocate a new codec instance.
908
 
 */
909
 
static pj_status_t ipp_alloc_codec( pjmedia_codec_factory *factory,
910
 
                                    const pjmedia_codec_info *id,
911
 
                                    pjmedia_codec **p_codec)
912
 
{
913
 
    ipp_private_t *codec_data;
914
 
    pjmedia_codec *codec;
915
 
    int idx;
916
 
    pj_pool_t *pool;
917
 
    unsigned i;
918
 
 
919
 
    PJ_ASSERT_RETURN(factory && id && p_codec, PJ_EINVAL);
920
 
    PJ_ASSERT_RETURN(factory == &ipp_factory.base, PJ_EINVAL);
921
 
 
922
 
    pj_mutex_lock(ipp_factory.mutex);
923
 
 
924
 
    /* Find codec's index */
925
 
    idx = -1;
926
 
    for (i = 0; i < PJ_ARRAY_SIZE(ipp_codec); ++i) {
927
 
        pj_str_t name = pj_str((char*)ipp_codec[i].name);
928
 
        if ((pj_stricmp(&id->encoding_name, &name) == 0) &&
929
 
            (id->clock_rate == (unsigned)ipp_codec[i].clock_rate) &&
930
 
            (id->channel_cnt == (unsigned)ipp_codec[i].channel_count) &&
931
 
            (ipp_codec[i].enabled))
932
 
        {
933
 
            idx = i;
934
 
            break;
935
 
        }
936
 
    }
937
 
    if (idx == -1) {
938
 
        *p_codec = NULL;
939
 
        return PJMEDIA_CODEC_EFAILED;
940
 
    }
941
 
 
942
 
    /* Create pool for codec instance */
943
 
    pool = pjmedia_endpt_create_pool(ipp_factory.endpt, "IPPcodec", 512, 512);
944
 
    codec = PJ_POOL_ZALLOC_T(pool, pjmedia_codec);
945
 
    PJ_ASSERT_RETURN(codec != NULL, PJ_ENOMEM);
946
 
    codec->op = &ipp_op;
947
 
    codec->factory = factory;
948
 
    codec->codec_data = PJ_POOL_ZALLOC_T(pool, ipp_private_t);
949
 
    codec_data = (ipp_private_t*) codec->codec_data;
950
 
 
951
 
    /* Create PLC if codec has no internal PLC */
952
 
    if (!ipp_codec[idx].has_native_plc) {
953
 
        pj_status_t status;
954
 
        status = pjmedia_plc_create(pool, ipp_codec[idx].clock_rate,
955
 
                                    ipp_codec[idx].samples_per_frame, 0,
956
 
                                    &codec_data->plc);
957
 
        if (status != PJ_SUCCESS) {
958
 
            pj_pool_release(pool);
959
 
            pj_mutex_unlock(ipp_factory.mutex);
960
 
            return status;
961
 
        }
962
 
    }
963
 
 
964
 
    /* Create silence detector if codec has no internal VAD */
965
 
    if (!ipp_codec[idx].has_native_vad) {
966
 
        pj_status_t status;
967
 
        status = pjmedia_silence_det_create(pool,
968
 
                                            ipp_codec[idx].clock_rate,
969
 
                                            ipp_codec[idx].samples_per_frame,
970
 
                                            &codec_data->vad);
971
 
        if (status != PJ_SUCCESS) {
972
 
            pj_pool_release(pool);
973
 
            pj_mutex_unlock(ipp_factory.mutex);
974
 
            return status;
975
 
        }
976
 
    }
977
 
 
978
 
    codec_data->pool = pool;
979
 
    codec_data->codec_idx = idx;
980
 
 
981
 
    pj_mutex_unlock(ipp_factory.mutex);
982
 
 
983
 
    *p_codec = codec;
984
 
    return PJ_SUCCESS;
985
 
}
986
 
 
987
 
/*
988
 
 * Free codec.
989
 
 */
990
 
static pj_status_t ipp_dealloc_codec( pjmedia_codec_factory *factory,
991
 
                                      pjmedia_codec *codec )
992
 
{
993
 
    ipp_private_t *codec_data;
994
 
 
995
 
    PJ_ASSERT_RETURN(factory && codec, PJ_EINVAL);
996
 
    PJ_ASSERT_RETURN(factory == &ipp_factory.base, PJ_EINVAL);
997
 
 
998
 
    /* Close codec, if it's not closed. */
999
 
    codec_data = (ipp_private_t*) codec->codec_data;
1000
 
    if (codec_data->enc != NULL || codec_data->dec != NULL) {
1001
 
        ipp_codec_close(codec);
1002
 
    }
1003
 
 
1004
 
    pj_pool_release(codec_data->pool);
1005
 
 
1006
 
    return PJ_SUCCESS;
1007
 
}
1008
 
 
1009
 
/*
1010
 
 * Init codec.
1011
 
 */
1012
 
static pj_status_t ipp_codec_init( pjmedia_codec *codec,
1013
 
                                   pj_pool_t *pool )
1014
 
{
1015
 
    PJ_UNUSED_ARG(codec);
1016
 
    PJ_UNUSED_ARG(pool);
1017
 
    return PJ_SUCCESS;
1018
 
}
1019
 
 
1020
 
/*
1021
 
 * Open codec.
1022
 
 */
1023
 
static pj_status_t ipp_codec_open( pjmedia_codec *codec,
1024
 
                                   pjmedia_codec_param *attr )
1025
 
{
1026
 
    ipp_private_t *codec_data = (ipp_private_t*) codec->codec_data;
1027
 
    struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
1028
 
    int info_size;
1029
 
    pj_pool_t *pool;
1030
 
    int i, j;
1031
 
    USC_MemBank *membanks;
1032
 
    int nb_membanks;
1033
 
 
1034
 
    pool = codec_data->pool;
1035
 
 
1036
 
    /* Get the codec info size */
1037
 
    if (USC_NoError != ippc->fxns->std.GetInfoSize(&info_size)) {
1038
 
        PJ_LOG(1,(THIS_FILE, "Error getting codec info size"));
1039
 
        goto on_error;
1040
 
    }
1041
 
    /* Get the codec info */
1042
 
    codec_data->info = pj_pool_zalloc(pool, info_size);
1043
 
    if (USC_NoError != ippc->fxns->std.GetInfo((USC_Handle)NULL,
1044
 
                                               codec_data->info))
1045
 
    {
1046
 
        PJ_LOG(1,(THIS_FILE, "Error getting codec info"));
1047
 
        goto on_error;
1048
 
    }
1049
 
 
1050
 
    /* PREPARING THE ENCODER */
1051
 
 
1052
 
    /* Setting the encoder params */
1053
 
    codec_data->info->params.direction = USC_ENCODE;
1054
 
    codec_data->info->params.modes.vad = attr->setting.vad &&
1055
 
                                         ippc->has_native_vad;
1056
 
    codec_data->info->params.modes.bitrate = attr->info.avg_bps;
1057
 
    codec_data->info->params.law = 0; /* Linear PCM input */
1058
 
 
1059
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_G729
1060
 
    if (ippc->pt == PJMEDIA_RTP_PT_G729) {
1061
 
        /* Check if G729 Annex B is signaled to be disabled */
1062
 
        for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) {
1063
 
            if (pj_stricmp2(&attr->setting.enc_fmtp.param[i].name, "annexb")==0)
1064
 
            {
1065
 
                if (pj_stricmp2(&attr->setting.enc_fmtp.param[i].val, "no")==0)
1066
 
                {
1067
 
                    attr->setting.vad = 0;
1068
 
                    codec_data->info->params.modes.vad = 0;
1069
 
                }
1070
 
                break;
1071
 
            }
1072
 
        }
1073
 
    }
1074
 
#endif
1075
 
 
1076
 
    /* Get number of memory blocks needed by the encoder */
1077
 
    if (USC_NoError != ippc->fxns->std.NumAlloc(&codec_data->info->params,
1078
 
                                                &nb_membanks))
1079
 
    {
1080
 
        PJ_LOG(1,(THIS_FILE, "Error getting no of memory blocks of encoder"));
1081
 
        goto on_error;
1082
 
    }
1083
 
 
1084
 
    /* Allocate memory blocks table */
1085
 
    membanks = (USC_MemBank*) pj_pool_zalloc(pool,
1086
 
                                             sizeof(USC_MemBank) * nb_membanks);
1087
 
    /* Get size of each memory block */
1088
 
    if (USC_NoError != ippc->fxns->std.MemAlloc(&codec_data->info->params,
1089
 
                                                membanks))
1090
 
    {
1091
 
        PJ_LOG(1,(THIS_FILE, "Error getting memory blocks size of encoder"));
1092
 
        goto on_error;
1093
 
    }
1094
 
 
1095
 
    /* Allocate memory for each block */
1096
 
    for (i = 0; i < nb_membanks; i++) {
1097
 
        membanks[i].pMem = (char*) pj_pool_zalloc(pool, membanks[i].nbytes);
1098
 
    }
1099
 
 
1100
 
    /* Create encoder instance */
1101
 
    if (USC_NoError != ippc->fxns->std.Init(&codec_data->info->params,
1102
 
                                            membanks,
1103
 
                                            &codec_data->enc))
1104
 
    {
1105
 
        PJ_LOG(1,(THIS_FILE, "Error initializing encoder"));
1106
 
        goto on_error;
1107
 
    }
1108
 
 
1109
 
    /* PREPARING THE DECODER */
1110
 
 
1111
 
    /* Setting the decoder params */
1112
 
    codec_data->info->params.direction = USC_DECODE;
1113
 
 
1114
 
    /* Not sure if VAD affects decoder, just try to be safe */
1115
 
    //codec_data->info->params.modes.vad = ippc->has_native_vad;
1116
 
 
1117
 
    /* Get number of memory blocks needed by the decoder */
1118
 
    if (USC_NoError != ippc->fxns->std.NumAlloc(&codec_data->info->params,
1119
 
                                                 &nb_membanks))
1120
 
    {
1121
 
        PJ_LOG(1,(THIS_FILE, "Error getting no of memory blocks of decoder"));
1122
 
        goto on_error;
1123
 
    }
1124
 
 
1125
 
    /* Allocate memory blocks table */
1126
 
    membanks = (USC_MemBank*) pj_pool_zalloc(pool,
1127
 
                                             sizeof(USC_MemBank) * nb_membanks);
1128
 
    /* Get size of each memory block */
1129
 
    if (USC_NoError != ippc->fxns->std.MemAlloc(&codec_data->info->params,
1130
 
                                                membanks))
1131
 
    {
1132
 
        PJ_LOG(1,(THIS_FILE, "Error getting memory blocks size of decoder"));
1133
 
        goto on_error;
1134
 
    }
1135
 
 
1136
 
    /* Allocate memory for each block */
1137
 
    for (i = 0; i < nb_membanks; i++) {
1138
 
        membanks[i].pMem = (char*) pj_pool_zalloc(pool, membanks[i].nbytes);
1139
 
    }
1140
 
 
1141
 
    /* Create decoder instance */
1142
 
    if (USC_NoError != ippc->fxns->std.Init(&codec_data->info->params,
1143
 
                                            membanks, &codec_data->dec))
1144
 
    {
1145
 
        PJ_LOG(1,(THIS_FILE, "Error initializing decoder"));
1146
 
        goto on_error;
1147
 
    }
1148
 
 
1149
 
    /* Update codec info */
1150
 
    ippc->fxns->std.GetInfo((USC_Handle)codec_data->enc, codec_data->info);
1151
 
 
1152
 
    /* Get bitstream size */
1153
 
    i = codec_data->info->params.modes.bitrate * ippc->samples_per_frame;
1154
 
    j = ippc->clock_rate << 3;
1155
 
    codec_data->frame_size = (pj_uint16_t)(i / j);
1156
 
    if (i % j) ++codec_data->frame_size;
1157
 
 
1158
 
    codec_data->vad_enabled = (attr->setting.vad != 0);
1159
 
    codec_data->plc_enabled = (attr->setting.plc != 0);
1160
 
 
1161
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_AMR
1162
 
    /* Init AMR settings */
1163
 
    if (ippc->pt == PJMEDIA_RTP_PT_AMR || ippc->pt == PJMEDIA_RTP_PT_AMRWB) {
1164
 
        amr_settings_t *s;
1165
 
        pj_uint8_t octet_align = 0;
1166
 
        pj_int8_t enc_mode;
1167
 
 
1168
 
        enc_mode = pjmedia_codec_amr_get_mode(
1169
 
                                codec_data->info->params.modes.bitrate);
1170
 
        pj_assert(enc_mode >= 0 && enc_mode <= 8);
1171
 
 
1172
 
        /* Check AMR specific attributes */
1173
 
 
1174
 
        for (i = 0; i < attr->setting.dec_fmtp.cnt; ++i) {
1175
 
            /* octet-align, one of the parameters that must have same value
1176
 
             * in offer & answer (RFC 4867 Section 8.3.1). Just check fmtp
1177
 
             * in the decoder side, since it's value is guaranteed to fulfil
1178
 
             * above requirement (by SDP negotiator).
1179
 
             */
1180
 
            const pj_str_t STR_FMTP_OCTET_ALIGN = {"octet-align", 11};
1181
 
 
1182
 
            if (pj_stricmp(&attr->setting.dec_fmtp.param[i].name,
1183
 
                           &STR_FMTP_OCTET_ALIGN) == 0)
1184
 
            {
1185
 
                octet_align=(pj_uint8_t)
1186
 
                            pj_strtoul(&attr->setting.dec_fmtp.param[i].val);
1187
 
                break;
1188
 
            }
1189
 
        }
1190
 
 
1191
 
        for (i = 0; i < attr->setting.enc_fmtp.cnt; ++i) {
1192
 
            /* mode-set, encoding mode is chosen based on local default mode
1193
 
             * setting:
1194
 
             * - if local default mode is included in the mode-set, use it
1195
 
             * - otherwise, find the closest mode to local default mode;
1196
 
             *   if there are two closest modes, prefer to use the higher
1197
 
             *   one, e.g: local default mode is 4, the mode-set param
1198
 
             *   contains '2,3,5,6', then 5 will be chosen.
1199
 
             */
1200
 
            const pj_str_t STR_FMTP_MODE_SET = {"mode-set", 8};
1201
 
 
1202
 
            if (pj_stricmp(&attr->setting.enc_fmtp.param[i].name,
1203
 
                           &STR_FMTP_MODE_SET) == 0)
1204
 
            {
1205
 
                const char *p;
1206
 
                pj_size_t l;
1207
 
                pj_int8_t diff = 99;
1208
 
 
1209
 
                p = pj_strbuf(&attr->setting.enc_fmtp.param[i].val);
1210
 
                l = pj_strlen(&attr->setting.enc_fmtp.param[i].val);
1211
 
 
1212
 
                while (l--) {
1213
 
                    if ((ippc->pt==PJMEDIA_RTP_PT_AMR && *p>='0' && *p<='7') ||
1214
 
                        (ippc->pt==PJMEDIA_RTP_PT_AMRWB && *p>='0' && *p<='8'))
1215
 
                    {
1216
 
                        pj_int8_t tmp = (pj_int8_t)(*p - '0' - enc_mode);
1217
 
 
1218
 
                        if (PJ_ABS(diff) > PJ_ABS(tmp) ||
1219
 
                            (PJ_ABS(diff) == PJ_ABS(tmp) && tmp > diff))
1220
 
                        {
1221
 
                            diff = tmp;
1222
 
                            if (diff == 0) break;
1223
 
                        }
1224
 
                    }
1225
 
                    ++p;
1226
 
                }
1227
 
 
1228
 
                if (diff == 99)
1229
 
                    goto on_error;
1230
 
 
1231
 
                enc_mode = (pj_int8_t)(enc_mode + diff);
1232
 
 
1233
 
                break;
1234
 
            }
1235
 
        }
1236
 
 
1237
 
        /* Initialize AMR specific settings */
1238
 
        s = PJ_POOL_ZALLOC_T(pool, amr_settings_t);
1239
 
        codec_data->codec_setting = s;
1240
 
 
1241
 
        s->enc_setting.amr_nb = (pj_uint8_t)(ippc->pt == PJMEDIA_RTP_PT_AMR);
1242
 
        s->enc_setting.octet_aligned = octet_align;
1243
 
        s->enc_setting.reorder = PJ_TRUE;
1244
 
        s->enc_setting.cmr = 15;
1245
 
 
1246
 
        s->dec_setting.amr_nb = (pj_uint8_t)(ippc->pt == PJMEDIA_RTP_PT_AMR);
1247
 
        s->dec_setting.octet_aligned = octet_align;
1248
 
        s->dec_setting.reorder = PJ_TRUE;
1249
 
 
1250
 
        /* Apply encoder mode/bitrate */
1251
 
        s->enc_mode = enc_mode;
1252
 
        codec_data->info->params.modes.bitrate = s->enc_setting.amr_nb?
1253
 
                                pjmedia_codec_amrnb_bitrates[s->enc_mode]:
1254
 
                                pjmedia_codec_amrwb_bitrates[s->enc_mode];
1255
 
        ippc->fxns->std.Control(&codec_data->info->params.modes,
1256
 
                                codec_data->enc);
1257
 
 
1258
 
        PJ_LOG(4,(THIS_FILE, "AMR%s encoding mode: %d (%dbps)",
1259
 
                  (s->enc_setting.amr_nb?"":"-WB"),
1260
 
                  s->enc_mode,
1261
 
                  codec_data->info->params.modes.bitrate));
1262
 
 
1263
 
        /* Return back bitrate info to application */
1264
 
        attr->info.avg_bps = codec_data->info->params.modes.bitrate;
1265
 
    }
1266
 
#endif
1267
 
 
1268
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1
1269
 
    if (ippc->pt >= PJMEDIA_RTP_PT_G722_1_16 &&
1270
 
        ippc->pt <= PJMEDIA_RTP_PT_G7221_RSV2)
1271
 
    {
1272
 
        codec_data->g7221_pcm_shift = ipp_factory.g7221_pcm_shift;
1273
 
    }
1274
 
#endif
1275
 
 
1276
 
    return PJ_SUCCESS;
1277
 
 
1278
 
on_error:
1279
 
    return PJMEDIA_CODEC_EFAILED;
1280
 
}
1281
 
 
1282
 
/*
1283
 
 * Close codec.
1284
 
 */
1285
 
static pj_status_t ipp_codec_close( pjmedia_codec *codec )
1286
 
{
1287
 
    PJ_UNUSED_ARG(codec);
1288
 
 
1289
 
    return PJ_SUCCESS;
1290
 
}
1291
 
 
1292
 
 
1293
 
/*
1294
 
 * Modify codec settings.
1295
 
 */
1296
 
static pj_status_t  ipp_codec_modify(pjmedia_codec *codec,
1297
 
                                     const pjmedia_codec_param *attr )
1298
 
{
1299
 
    ipp_private_t *codec_data = (ipp_private_t*) codec->codec_data;
1300
 
    struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
1301
 
 
1302
 
    codec_data->vad_enabled = (attr->setting.vad != 0);
1303
 
    codec_data->plc_enabled = (attr->setting.plc != 0);
1304
 
 
1305
 
    if (ippc->has_native_vad) {
1306
 
        USC_Modes modes;
1307
 
 
1308
 
        modes = codec_data->info->params.modes;
1309
 
        modes.vad = codec_data->vad_enabled;
1310
 
        ippc->fxns->std.Control(&modes, codec_data->enc);
1311
 
    }
1312
 
 
1313
 
    return PJ_SUCCESS;
1314
 
}
1315
 
 
1316
 
/*
1317
 
 * Get frames in the packet.
1318
 
 */
1319
 
static pj_status_t  ipp_codec_parse( pjmedia_codec *codec,
1320
 
                                     void *pkt,
1321
 
                                     pj_size_t pkt_size,
1322
 
                                     const pj_timestamp *ts,
1323
 
                                     unsigned *frame_cnt,
1324
 
                                     pjmedia_frame frames[])
1325
 
{
1326
 
    ipp_private_t *codec_data = (ipp_private_t*) codec->codec_data;
1327
 
    struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
1328
 
    unsigned count = 0;
1329
 
 
1330
 
    PJ_ASSERT_RETURN(frame_cnt, PJ_EINVAL);
1331
 
 
1332
 
    if (ippc->parse != NULL) {
1333
 
        return ippc->parse(codec_data, pkt,  pkt_size, ts, frame_cnt, frames);
1334
 
    }
1335
 
 
1336
 
    while (pkt_size >= codec_data->frame_size && count < *frame_cnt) {
1337
 
        frames[count].type = PJMEDIA_FRAME_TYPE_AUDIO;
1338
 
        frames[count].buf = pkt;
1339
 
        frames[count].size = codec_data->frame_size;
1340
 
        frames[count].timestamp.u64 = ts->u64 + count*ippc->samples_per_frame;
1341
 
 
1342
 
        pkt = ((char*)pkt) + codec_data->frame_size;
1343
 
        pkt_size -= codec_data->frame_size;
1344
 
 
1345
 
        ++count;
1346
 
    }
1347
 
 
1348
 
    if (pkt_size && count < *frame_cnt) {
1349
 
        frames[count].type = PJMEDIA_FRAME_TYPE_AUDIO;
1350
 
        frames[count].buf = pkt;
1351
 
        frames[count].size = pkt_size;
1352
 
        frames[count].timestamp.u64 = ts->u64 + count*ippc->samples_per_frame;
1353
 
        ++count;
1354
 
    }
1355
 
 
1356
 
    *frame_cnt = count;
1357
 
    return PJ_SUCCESS;
1358
 
}
1359
 
 
1360
 
/*
1361
 
 * Encode frames.
1362
 
 */
1363
 
static pj_status_t ipp_codec_encode( pjmedia_codec *codec,
1364
 
                                     const struct pjmedia_frame *input,
1365
 
                                     unsigned output_buf_len,
1366
 
                                     struct pjmedia_frame *output)
1367
 
{
1368
 
    ipp_private_t *codec_data = (ipp_private_t*) codec->codec_data;
1369
 
    struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
1370
 
    unsigned samples_per_frame;
1371
 
    unsigned nsamples;
1372
 
    pj_size_t tx = 0;
1373
 
    pj_int16_t *pcm_in   = (pj_int16_t*)input->buf;
1374
 
    pj_uint8_t  *bits_out = (pj_uint8_t*) output->buf;
1375
 
    pj_uint8_t pt;
1376
 
 
1377
 
    /* Invoke external VAD if codec has no internal VAD */
1378
 
    if (codec_data->vad && codec_data->vad_enabled) {
1379
 
        pj_bool_t is_silence;
1380
 
        pj_int32_t silence_duration;
1381
 
 
1382
 
        silence_duration = pj_timestamp_diff32(&codec_data->last_tx,
1383
 
                                               &input->timestamp);
1384
 
 
1385
 
        is_silence = pjmedia_silence_det_detect(codec_data->vad,
1386
 
                                                (const pj_int16_t*) input->buf,
1387
 
                                                (input->size >> 1),
1388
 
                                                NULL);
1389
 
        if (is_silence &&
1390
 
            (PJMEDIA_CODEC_MAX_SILENCE_PERIOD == -1 ||
1391
 
             silence_duration < (PJMEDIA_CODEC_MAX_SILENCE_PERIOD *
1392
 
                                 (int)ippc->clock_rate / 1000)))
1393
 
        {
1394
 
            output->type = PJMEDIA_FRAME_TYPE_NONE;
1395
 
            output->buf = NULL;
1396
 
            output->size = 0;
1397
 
            output->timestamp = input->timestamp;
1398
 
            return PJ_SUCCESS;
1399
 
        } else {
1400
 
            codec_data->last_tx = input->timestamp;
1401
 
        }
1402
 
    }
1403
 
 
1404
 
    nsamples = input->size >> 1;
1405
 
    samples_per_frame = ippc->samples_per_frame;
1406
 
    pt = ippc->pt;
1407
 
 
1408
 
    PJ_ASSERT_RETURN(nsamples % samples_per_frame == 0,
1409
 
                     PJMEDIA_CODEC_EPCMFRMINLEN);
1410
 
 
1411
 
    /* Encode the frames */
1412
 
    while (nsamples >= samples_per_frame) {
1413
 
        USC_PCMStream in;
1414
 
        USC_Bitstream out;
1415
 
 
1416
 
        in.bitrate = codec_data->info->params.modes.bitrate;
1417
 
        in.nbytes = samples_per_frame << 1;
1418
 
        in.pBuffer = (char*)pcm_in;
1419
 
        in.pcmType.bitPerSample = codec_data->info->params.pcmType.bitPerSample;
1420
 
        in.pcmType.nChannels = codec_data->info->params.pcmType.nChannels;
1421
 
        in.pcmType.sample_frequency = codec_data->info->params.pcmType.sample_frequency;
1422
 
 
1423
 
        out.pBuffer = (char*)bits_out;
1424
 
 
1425
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_AMR
1426
 
        /* For AMR: reserve two octets for AMR frame info */
1427
 
        if (pt == PJMEDIA_RTP_PT_AMR || pt == PJMEDIA_RTP_PT_AMRWB) {
1428
 
            out.pBuffer += 2;
1429
 
        }
1430
 
#endif
1431
 
 
1432
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1
1433
 
        /* For G722.1: adjust the encoder input signal level */
1434
 
        if (pt >= PJMEDIA_RTP_PT_G722_1_16 &&
1435
 
            pt <= PJMEDIA_RTP_PT_G7221_RSV2 &&
1436
 
            codec_data->g7221_pcm_shift)
1437
 
        {
1438
 
            unsigned i;
1439
 
            for (i = 0; i < samples_per_frame; ++i)
1440
 
                pcm_in[i] >>= codec_data->g7221_pcm_shift;
1441
 
        }
1442
 
#endif
1443
 
 
1444
 
        if (USC_NoError != ippc->fxns->Encode(codec_data->enc, &in, &out)) {
1445
 
            break;
1446
 
        }
1447
 
 
1448
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_AMR
1449
 
        /* For AMR: put info (frametype, degraded, last frame, mode) in the
1450
 
         * first two octets for payload packing.
1451
 
         */
1452
 
        if (pt == PJMEDIA_RTP_PT_AMR || pt == PJMEDIA_RTP_PT_AMRWB) {
1453
 
            pj_uint16_t *info = (pj_uint16_t*)bits_out;
1454
 
 
1455
 
            /* Two octets for AMR frame info, 0=LSB:
1456
 
             * bit 0-3  : frame type
1457
 
             * bit 5    : STI flag
1458
 
             * bit 6    : last frame flag
1459
 
             * bit 7    : quality flag
1460
 
             * bit 8-11 : mode
1461
 
             */
1462
 
            out.nbytes += 2;
1463
 
            if (out.frametype == 0 || out.frametype == 4 ||
1464
 
                (pt == PJMEDIA_RTP_PT_AMR && out.frametype == 5) ||
1465
 
                (pt == PJMEDIA_RTP_PT_AMRWB && out.frametype == 6))
1466
 
            {
1467
 
                /* Speech frame type */
1468
 
                *info = (char)pjmedia_codec_amr_get_mode(out.bitrate);
1469
 
                /* Quality */
1470
 
                if (out.frametype == 5 || out.frametype == 6)
1471
 
                    *info |= 0x80;
1472
 
            } else if (out.frametype == 1 || out.frametype == 2 ||
1473
 
                       (pt == PJMEDIA_RTP_PT_AMR && out.frametype == 6) ||
1474
 
                       (pt == PJMEDIA_RTP_PT_AMRWB && out.frametype == 7))
1475
 
            {
1476
 
                /* SID frame type */
1477
 
                *info = (pj_uint8_t)(pt == PJMEDIA_RTP_PT_AMRWB? 9 : 8);
1478
 
                /* Quality */
1479
 
                if (out.frametype == 6 || out.frametype == 7)
1480
 
                    *info |= 0x80;
1481
 
                /* STI */
1482
 
                if (out.frametype != 1)
1483
 
                    *info |= 0x20;
1484
 
            } else {
1485
 
                /* Untransmited */
1486
 
                *info = 15;
1487
 
                out.nbytes = 2;
1488
 
            }
1489
 
 
1490
 
            /* Mode */
1491
 
            *info |= (char)pjmedia_codec_amr_get_mode(out.bitrate) << 8;
1492
 
 
1493
 
            /* Last frame flag */
1494
 
            if (nsamples == samples_per_frame)
1495
 
                *info |= 0x40;
1496
 
        }
1497
 
#endif
1498
 
 
1499
 
        pcm_in += samples_per_frame;
1500
 
        nsamples -= samples_per_frame;
1501
 
        tx += out.nbytes;
1502
 
        bits_out += out.nbytes;
1503
 
 
1504
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_G729
1505
 
        if (pt == PJMEDIA_RTP_PT_G729) {
1506
 
            if (out.frametype == 1) {
1507
 
                /* SID */
1508
 
                break;
1509
 
            } else if (out.frametype == 0) {
1510
 
                /* Untransmitted */
1511
 
                tx -= out.nbytes;
1512
 
                break;
1513
 
            }
1514
 
        }
1515
 
#endif
1516
 
 
1517
 
    }
1518
 
 
1519
 
    if (ippc->pack != NULL) {
1520
 
        ippc->pack(codec_data, output->buf, &tx, output_buf_len);
1521
 
    }
1522
 
 
1523
 
    /* Check if we don't need to transmit the frame (DTX) */
1524
 
    if (tx == 0) {
1525
 
        output->buf = NULL;
1526
 
        output->size = 0;
1527
 
        output->timestamp.u64 = input->timestamp.u64;
1528
 
        output->type = PJMEDIA_FRAME_TYPE_NONE;
1529
 
        return PJ_SUCCESS;
1530
 
    }
1531
 
 
1532
 
    output->size = tx;
1533
 
    output->type = PJMEDIA_FRAME_TYPE_AUDIO;
1534
 
    output->timestamp = input->timestamp;
1535
 
 
1536
 
    return PJ_SUCCESS;
1537
 
}
1538
 
 
1539
 
/*
1540
 
 * Decode frame.
1541
 
 */
1542
 
static pj_status_t ipp_codec_decode( pjmedia_codec *codec,
1543
 
                                     const struct pjmedia_frame *input,
1544
 
                                     unsigned output_buf_len,
1545
 
                                     struct pjmedia_frame *output)
1546
 
{
1547
 
    ipp_private_t *codec_data = (ipp_private_t*) codec->codec_data;
1548
 
    struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
1549
 
    unsigned samples_per_frame;
1550
 
    USC_PCMStream out;
1551
 
    USC_Bitstream in;
1552
 
    pj_uint8_t pt;
1553
 
 
1554
 
    pt = ippc->pt;
1555
 
    samples_per_frame = ippc->samples_per_frame;
1556
 
 
1557
 
    PJ_ASSERT_RETURN(output_buf_len >= samples_per_frame << 1,
1558
 
                     PJMEDIA_CODEC_EPCMTOOSHORT);
1559
 
 
1560
 
    if (input->type == PJMEDIA_FRAME_TYPE_AUDIO) {
1561
 
        if (ippc->predecode) {
1562
 
            ippc->predecode(codec_data, input, &in);
1563
 
        } else {
1564
 
            /* Most IPP codecs have frametype==0 for speech frame */
1565
 
            in.pBuffer = (char*)input->buf;
1566
 
            in.nbytes = input->size;
1567
 
            in.frametype = 0;
1568
 
            in.bitrate = codec_data->info->params.modes.bitrate;
1569
 
        }
1570
 
 
1571
 
        out.pBuffer = output->buf;
1572
 
    }
1573
 
 
1574
 
    if (input->type != PJMEDIA_FRAME_TYPE_AUDIO ||
1575
 
        USC_NoError != ippc->fxns->Decode(codec_data->dec, &in, &out))
1576
 
    {
1577
 
        pjmedia_zero_samples((pj_int16_t*)output->buf, samples_per_frame);
1578
 
        output->size = samples_per_frame << 1;
1579
 
        output->timestamp.u64 = input->timestamp.u64;
1580
 
        output->type = PJMEDIA_FRAME_TYPE_AUDIO;
1581
 
        return PJ_SUCCESS;
1582
 
    }
1583
 
 
1584
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_G726
1585
 
    /* For G.726: amplify decoding result (USC G.726 encoder deamplified it) */
1586
 
    if (pt == PJMEDIA_RTP_PT_G726_16 || pt == PJMEDIA_RTP_PT_G726_24 ||
1587
 
        pt == PJMEDIA_RTP_PT_G726_32 || pt == PJMEDIA_RTP_PT_G726_40 ||
1588
 
        pt == PJMEDIA_RTP_PT_G721)
1589
 
    {
1590
 
        unsigned i;
1591
 
        pj_int16_t *s = (pj_int16_t*)output->buf;
1592
 
 
1593
 
        for (i = 0; i < samples_per_frame; ++i)
1594
 
            s[i] <<= 2;
1595
 
    }
1596
 
#endif
1597
 
 
1598
 
#if PJMEDIA_HAS_INTEL_IPP_CODEC_G722_1
1599
 
    /* For G722.1: adjust the decoder output signal level */
1600
 
    if (pt >= PJMEDIA_RTP_PT_G722_1_16 &&
1601
 
        pt <= PJMEDIA_RTP_PT_G7221_RSV2 &&
1602
 
        codec_data->g7221_pcm_shift)
1603
 
    {
1604
 
        unsigned i;
1605
 
        pj_int16_t *s = (pj_int16_t*)output->buf;
1606
 
 
1607
 
        for (i = 0; i < samples_per_frame; ++i)
1608
 
            s[i] <<= codec_data->g7221_pcm_shift;
1609
 
    }
1610
 
#endif
1611
 
 
1612
 
    output->type = PJMEDIA_FRAME_TYPE_AUDIO;
1613
 
    output->size = samples_per_frame << 1;
1614
 
    output->timestamp.u64 = input->timestamp.u64;
1615
 
 
1616
 
    /* Invoke external PLC if codec has no internal PLC */
1617
 
    if (codec_data->plc && codec_data->plc_enabled)
1618
 
        pjmedia_plc_save(codec_data->plc, (pj_int16_t*)output->buf);
1619
 
 
1620
 
    return PJ_SUCCESS;
1621
 
}
1622
 
 
1623
 
/*
1624
 
 * Recover lost frame.
1625
 
 */
1626
 
static pj_status_t  ipp_codec_recover(pjmedia_codec *codec,
1627
 
                                      unsigned output_buf_len,
1628
 
                                      struct pjmedia_frame *output)
1629
 
{
1630
 
    ipp_private_t *codec_data = (ipp_private_t*) codec->codec_data;
1631
 
    struct ipp_codec *ippc = &ipp_codec[codec_data->codec_idx];
1632
 
    unsigned samples_per_frame;
1633
 
 
1634
 
    PJ_UNUSED_ARG(output_buf_len);
1635
 
 
1636
 
    samples_per_frame = ippc->samples_per_frame;
1637
 
 
1638
 
    output->type = PJMEDIA_FRAME_TYPE_AUDIO;
1639
 
    output->size = samples_per_frame << 1;
1640
 
 
1641
 
    if (codec_data->plc_enabled) {
1642
 
        if (codec_data->plc) {
1643
 
            pjmedia_plc_generate(codec_data->plc, (pj_int16_t*)output->buf);
1644
 
        } else {
1645
 
            USC_PCMStream out;
1646
 
            out.pBuffer = output->buf;
1647
 
            ippc->fxns->Decode(codec_data->dec, NULL, &out);
1648
 
        }
1649
 
    } else {
1650
 
        pjmedia_zero_samples((pj_int16_t*)output->buf, samples_per_frame);
1651
 
    }
1652
 
 
1653
 
    return PJ_SUCCESS;
1654
 
}
1655
 
 
1656
 
 
1657
 
#if defined(_MSC_VER) && PJMEDIA_AUTO_LINK_IPP_LIBS
1658
 
#   pragma comment( lib, "ippcore.lib")
1659
 
#   pragma comment( lib, "ipps.lib")
1660
 
#   pragma comment( lib, "ippsc.lib")
1661
 
#   if defined(IPP_VERSION_MAJOR) && IPP_VERSION_MAJOR<=6
1662
 
#       pragma comment( lib, "ippsr.lib")
1663
 
#   endif
1664
 
//#   pragma comment( lib, "ippcorel.lib")
1665
 
//#   pragma comment( lib, "ippsemerged.lib")
1666
 
//#   pragma comment( lib, "ippsmerged.lib")
1667
 
//#   pragma comment( lib, "ippscemerged.lib")
1668
 
//#   pragma comment( lib, "ippscmerged.lib")
1669
 
//#   pragma comment( lib, "ippsremerged.lib")
1670
 
//#   pragma comment( lib, "ippsrmerged.lib")
1671
 
#   if defined(IPP_VERSION_MAJOR) && IPP_VERSION_MAJOR>=6
1672
 
#       pragma comment( lib, "speech.lib")
1673
 
#   else
1674
 
#       pragma comment( lib, "usc.lib")
1675
 
#   endif
1676
 
#endif
1677
 
 
1678
 
 
1679
 
#endif  /* PJMEDIA_HAS_INTEL_IPP */