1 /*
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 /******************************************************************
12
13 iLBC Speech Coder ANSI-C Source Code
14
15 iLBCInterface.c
16
17 ******************************************************************/
18
19 #include "ilbc.h"
20 #include "defines.h"
21 #include "init_encode.h"
22 #include "encode.h"
23 #include "init_decode.h"
24 #include "decode.h"
25 #include <stdlib.h>
26
WebRtcIlbcfix_EncoderAssign(IlbcEncoderInstance ** iLBC_encinst,int16_t * ILBCENC_inst_Addr,int16_t * size)27 int16_t WebRtcIlbcfix_EncoderAssign(IlbcEncoderInstance** iLBC_encinst,
28 int16_t* ILBCENC_inst_Addr,
29 int16_t* size) {
30 *iLBC_encinst=(IlbcEncoderInstance*)ILBCENC_inst_Addr;
31 *size=sizeof(IlbcEncoder)/sizeof(int16_t);
32 if (*iLBC_encinst!=NULL) {
33 return(0);
34 } else {
35 return(-1);
36 }
37 }
38
WebRtcIlbcfix_DecoderAssign(IlbcDecoderInstance ** iLBC_decinst,int16_t * ILBCDEC_inst_Addr,int16_t * size)39 int16_t WebRtcIlbcfix_DecoderAssign(IlbcDecoderInstance** iLBC_decinst,
40 int16_t* ILBCDEC_inst_Addr,
41 int16_t* size) {
42 *iLBC_decinst=(IlbcDecoderInstance*)ILBCDEC_inst_Addr;
43 *size=sizeof(IlbcDecoder)/sizeof(int16_t);
44 if (*iLBC_decinst!=NULL) {
45 return(0);
46 } else {
47 return(-1);
48 }
49 }
50
WebRtcIlbcfix_EncoderCreate(IlbcEncoderInstance ** iLBC_encinst)51 int16_t WebRtcIlbcfix_EncoderCreate(IlbcEncoderInstance **iLBC_encinst) {
52 *iLBC_encinst=(IlbcEncoderInstance*)malloc(sizeof(IlbcEncoder));
53 if (*iLBC_encinst!=NULL) {
54 WebRtcSpl_Init();
55 return(0);
56 } else {
57 return(-1);
58 }
59 }
60
WebRtcIlbcfix_DecoderCreate(IlbcDecoderInstance ** iLBC_decinst)61 int16_t WebRtcIlbcfix_DecoderCreate(IlbcDecoderInstance **iLBC_decinst) {
62 *iLBC_decinst=(IlbcDecoderInstance*)malloc(sizeof(IlbcDecoder));
63 if (*iLBC_decinst!=NULL) {
64 WebRtcSpl_Init();
65 return(0);
66 } else {
67 return(-1);
68 }
69 }
70
WebRtcIlbcfix_EncoderFree(IlbcEncoderInstance * iLBC_encinst)71 int16_t WebRtcIlbcfix_EncoderFree(IlbcEncoderInstance *iLBC_encinst) {
72 free(iLBC_encinst);
73 return(0);
74 }
75
WebRtcIlbcfix_DecoderFree(IlbcDecoderInstance * iLBC_decinst)76 int16_t WebRtcIlbcfix_DecoderFree(IlbcDecoderInstance *iLBC_decinst) {
77 free(iLBC_decinst);
78 return(0);
79 }
80
WebRtcIlbcfix_EncoderInit(IlbcEncoderInstance * iLBCenc_inst,int16_t mode)81 int16_t WebRtcIlbcfix_EncoderInit(IlbcEncoderInstance* iLBCenc_inst,
82 int16_t mode) {
83 if ((mode==20)||(mode==30)) {
84 WebRtcIlbcfix_InitEncode((IlbcEncoder*) iLBCenc_inst, mode);
85 return(0);
86 } else {
87 return(-1);
88 }
89 }
90
WebRtcIlbcfix_Encode(IlbcEncoderInstance * iLBCenc_inst,const int16_t * speechIn,size_t len,uint8_t * encoded)91 int WebRtcIlbcfix_Encode(IlbcEncoderInstance* iLBCenc_inst,
92 const int16_t* speechIn,
93 size_t len,
94 uint8_t* encoded) {
95 size_t pos = 0;
96 size_t encpos = 0;
97
98 if ((len != ((IlbcEncoder*)iLBCenc_inst)->blockl) &&
99 #ifdef SPLIT_10MS
100 (len != 80) &&
101 #endif
102 (len != 2*((IlbcEncoder*)iLBCenc_inst)->blockl) &&
103 (len != 3*((IlbcEncoder*)iLBCenc_inst)->blockl))
104 {
105 /* A maximum of 3 frames/packet is allowed */
106 return(-1);
107 } else {
108
109 /* call encoder */
110 while (pos<len) {
111 WebRtcIlbcfix_EncodeImpl((uint16_t*)&encoded[2 * encpos], &speechIn[pos],
112 (IlbcEncoder*)iLBCenc_inst);
113 #ifdef SPLIT_10MS
114 pos += 80;
115 if(((IlbcEncoder*)iLBCenc_inst)->section == 0)
116 #else
117 pos += ((IlbcEncoder*)iLBCenc_inst)->blockl;
118 #endif
119 encpos += ((IlbcEncoder*)iLBCenc_inst)->no_of_words;
120 }
121 return (int)(encpos*2);
122 }
123 }
124
WebRtcIlbcfix_DecoderInit(IlbcDecoderInstance * iLBCdec_inst,int16_t mode)125 int16_t WebRtcIlbcfix_DecoderInit(IlbcDecoderInstance* iLBCdec_inst,
126 int16_t mode) {
127 if ((mode==20)||(mode==30)) {
128 WebRtcIlbcfix_InitDecode((IlbcDecoder*) iLBCdec_inst, mode, 1);
129 return(0);
130 } else {
131 return(-1);
132 }
133 }
WebRtcIlbcfix_DecoderInit20Ms(IlbcDecoderInstance * iLBCdec_inst)134 void WebRtcIlbcfix_DecoderInit20Ms(IlbcDecoderInstance* iLBCdec_inst) {
135 WebRtcIlbcfix_InitDecode((IlbcDecoder*) iLBCdec_inst, 20, 1);
136 }
WebRtcIlbcfix_Decoderinit30Ms(IlbcDecoderInstance * iLBCdec_inst)137 void WebRtcIlbcfix_Decoderinit30Ms(IlbcDecoderInstance* iLBCdec_inst) {
138 WebRtcIlbcfix_InitDecode((IlbcDecoder*) iLBCdec_inst, 30, 1);
139 }
140
141
WebRtcIlbcfix_Decode(IlbcDecoderInstance * iLBCdec_inst,const uint8_t * encoded,size_t len,int16_t * decoded,int16_t * speechType)142 int WebRtcIlbcfix_Decode(IlbcDecoderInstance* iLBCdec_inst,
143 const uint8_t* encoded,
144 size_t len,
145 int16_t* decoded,
146 int16_t* speechType)
147 {
148 size_t i=0;
149 /* Allow for automatic switching between the frame sizes
150 (although you do get some discontinuity) */
151 if ((len==((IlbcDecoder*)iLBCdec_inst)->no_of_bytes)||
152 (len==2*((IlbcDecoder*)iLBCdec_inst)->no_of_bytes)||
153 (len==3*((IlbcDecoder*)iLBCdec_inst)->no_of_bytes)) {
154 /* ok, do nothing */
155 } else {
156 /* Test if the mode has changed */
157 if (((IlbcDecoder*)iLBCdec_inst)->mode==20) {
158 if ((len==NO_OF_BYTES_30MS)||
159 (len==2*NO_OF_BYTES_30MS)||
160 (len==3*NO_OF_BYTES_30MS)) {
161 WebRtcIlbcfix_InitDecode(
162 ((IlbcDecoder*)iLBCdec_inst), 30,
163 ((IlbcDecoder*)iLBCdec_inst)->use_enhancer);
164 } else {
165 /* Unsupported frame length */
166 return(-1);
167 }
168 } else {
169 if ((len==NO_OF_BYTES_20MS)||
170 (len==2*NO_OF_BYTES_20MS)||
171 (len==3*NO_OF_BYTES_20MS)) {
172 WebRtcIlbcfix_InitDecode(
173 ((IlbcDecoder*)iLBCdec_inst), 20,
174 ((IlbcDecoder*)iLBCdec_inst)->use_enhancer);
175 } else {
176 /* Unsupported frame length */
177 return(-1);
178 }
179 }
180 }
181
182 while ((i*((IlbcDecoder*)iLBCdec_inst)->no_of_bytes)<len) {
183 WebRtcIlbcfix_DecodeImpl(
184 &decoded[i * ((IlbcDecoder*)iLBCdec_inst)->blockl],
185 (const uint16_t*)&encoded
186 [2 * i * ((IlbcDecoder*)iLBCdec_inst)->no_of_words],
187 (IlbcDecoder*)iLBCdec_inst, 1);
188 i++;
189 }
190 /* iLBC does not support VAD/CNG yet */
191 *speechType=1;
192 return (int)(i*((IlbcDecoder*)iLBCdec_inst)->blockl);
193 }
194
WebRtcIlbcfix_Decode20Ms(IlbcDecoderInstance * iLBCdec_inst,const uint8_t * encoded,size_t len,int16_t * decoded,int16_t * speechType)195 int WebRtcIlbcfix_Decode20Ms(IlbcDecoderInstance* iLBCdec_inst,
196 const uint8_t* encoded,
197 size_t len,
198 int16_t* decoded,
199 int16_t* speechType)
200 {
201 size_t i=0;
202 if ((len==((IlbcDecoder*)iLBCdec_inst)->no_of_bytes)||
203 (len==2*((IlbcDecoder*)iLBCdec_inst)->no_of_bytes)||
204 (len==3*((IlbcDecoder*)iLBCdec_inst)->no_of_bytes)) {
205 /* ok, do nothing */
206 } else {
207 return(-1);
208 }
209
210 while ((i*((IlbcDecoder*)iLBCdec_inst)->no_of_bytes)<len) {
211 WebRtcIlbcfix_DecodeImpl(
212 &decoded[i * ((IlbcDecoder*)iLBCdec_inst)->blockl],
213 (const uint16_t*)&encoded
214 [2 * i * ((IlbcDecoder*)iLBCdec_inst)->no_of_words],
215 (IlbcDecoder*)iLBCdec_inst, 1);
216 i++;
217 }
218 /* iLBC does not support VAD/CNG yet */
219 *speechType=1;
220 return (int)(i*((IlbcDecoder*)iLBCdec_inst)->blockl);
221 }
222
WebRtcIlbcfix_Decode30Ms(IlbcDecoderInstance * iLBCdec_inst,const uint8_t * encoded,size_t len,int16_t * decoded,int16_t * speechType)223 int WebRtcIlbcfix_Decode30Ms(IlbcDecoderInstance* iLBCdec_inst,
224 const uint8_t* encoded,
225 size_t len,
226 int16_t* decoded,
227 int16_t* speechType)
228 {
229 size_t i=0;
230 if ((len==((IlbcDecoder*)iLBCdec_inst)->no_of_bytes)||
231 (len==2*((IlbcDecoder*)iLBCdec_inst)->no_of_bytes)||
232 (len==3*((IlbcDecoder*)iLBCdec_inst)->no_of_bytes)) {
233 /* ok, do nothing */
234 } else {
235 return(-1);
236 }
237
238 while ((i*((IlbcDecoder*)iLBCdec_inst)->no_of_bytes)<len) {
239 WebRtcIlbcfix_DecodeImpl(
240 &decoded[i * ((IlbcDecoder*)iLBCdec_inst)->blockl],
241 (const uint16_t*)&encoded
242 [2 * i * ((IlbcDecoder*)iLBCdec_inst)->no_of_words],
243 (IlbcDecoder*)iLBCdec_inst, 1);
244 i++;
245 }
246 /* iLBC does not support VAD/CNG yet */
247 *speechType=1;
248 return (int)(i*((IlbcDecoder*)iLBCdec_inst)->blockl);
249 }
250
WebRtcIlbcfix_DecodePlc(IlbcDecoderInstance * iLBCdec_inst,int16_t * decoded,size_t noOfLostFrames)251 size_t WebRtcIlbcfix_DecodePlc(IlbcDecoderInstance* iLBCdec_inst,
252 int16_t* decoded,
253 size_t noOfLostFrames) {
254 size_t i;
255 uint16_t dummy;
256
257 for (i=0;i<noOfLostFrames;i++) {
258 /* call decoder */
259 WebRtcIlbcfix_DecodeImpl(
260 &decoded[i * ((IlbcDecoder*)iLBCdec_inst)->blockl], &dummy,
261 (IlbcDecoder*)iLBCdec_inst, 0);
262 }
263 return (noOfLostFrames*((IlbcDecoder*)iLBCdec_inst)->blockl);
264 }
265
WebRtcIlbcfix_NetEqPlc(IlbcDecoderInstance * iLBCdec_inst,int16_t * decoded,size_t noOfLostFrames)266 size_t WebRtcIlbcfix_NetEqPlc(IlbcDecoderInstance* iLBCdec_inst,
267 int16_t* decoded,
268 size_t noOfLostFrames) {
269 /* Two input parameters not used, but needed for function pointers in NetEQ */
270 (void)(decoded = NULL);
271 (void)(noOfLostFrames = 0);
272
273 WebRtcSpl_MemSetW16(((IlbcDecoder*)iLBCdec_inst)->enh_buf, 0, ENH_BUFL);
274 ((IlbcDecoder*)iLBCdec_inst)->prev_enh_pl = 2;
275
276 return (0);
277 }
278
WebRtcIlbcfix_version(char * version)279 void WebRtcIlbcfix_version(char *version)
280 {
281 strcpy((char*)version, "1.1.1");
282 }
283