Mercurial > libavcodec.hg
comparison libamr.c @ 5101:c3f2379b80db libavcodec
Give all wrappers for external libraries names starting with lib.
author | diego |
---|---|
date | Wed, 06 Jun 2007 00:14:18 +0000 |
parents | amr.c@3df69e140c33 |
children | 0281d8efb050 |
comparison
equal
deleted
inserted
replaced
5100:daff9ebd2e0b | 5101:c3f2379b80db |
---|---|
1 /* | |
2 * AMR Audio decoder stub | |
3 * Copyright (c) 2003 the ffmpeg project | |
4 * | |
5 * This file is part of FFmpeg. | |
6 * | |
7 * FFmpeg is free software; you can redistribute it and/or | |
8 * modify it under the terms of the GNU Lesser General Public | |
9 * License as published by the Free Software Foundation; either | |
10 * version 2.1 of the License, or (at your option) any later version. | |
11 * | |
12 * FFmpeg is distributed in the hope that it will be useful, | |
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
18 * License along with FFmpeg; if not, write to the Free Software | |
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | |
20 */ | |
21 | |
22 /** @file | |
23 * Adaptive Multi-Rate (AMR) Audio decoder stub. | |
24 * | |
25 * This code implements both an AMR-NarrowBand (AMR-NB) and an AMR-WideBand | |
26 * (AMR-WB) audio encoder/decoder through external reference code from | |
27 * http://www.3gpp.org/. The license of the code from 3gpp is unclear so you | |
28 * have to download the code separately. Two versions exists: One fixed-point | |
29 * and one floating-point. For some reason the float encoder is significantly | |
30 * faster at least on a P4 1.5GHz (0.9s instead of 9.9s on a 30s audio clip | |
31 * at MR102). Both float and fixed point are supported for AMR-NB, but only | |
32 * float for AMR-WB. | |
33 * | |
34 * \section AMR-NB | |
35 * | |
36 * \subsection Float | |
37 * The float version (default) can be downloaded from: | |
38 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.104/26104-610.zip | |
39 * | |
40 * \subsection Fixed-point | |
41 * The fixed-point (TS26.073) can be downloaded from: | |
42 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.073/26073-600.zip | |
43 * | |
44 * \subsection Specification | |
45 * The specification for AMR-NB can be found in TS 26.071 | |
46 * (http://www.3gpp.org/ftp/Specs/html-info/26071.htm) and some other | |
47 * info at http://www.3gpp.org/ftp/Specs/html-info/26-series.htm. | |
48 * | |
49 * \section AMR-WB | |
50 * | |
51 * \subsection Float | |
52 * The reference code can be downloaded from: | |
53 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.204/26204-600.zip | |
54 * | |
55 * \subsection Fixed-point | |
56 * If someone wants to use the fixed point version it can be downloaded from: | |
57 * http://www.3gpp.org/ftp/Specs/archive/26_series/26.173/26173-571.zip. | |
58 * | |
59 * \subsection Specification | |
60 * The specification for AMR-WB can be found in TS 26.171 | |
61 * (http://www.3gpp.org/ftp/Specs/html-info/26171.htm) and some other | |
62 * info at http://www.3gpp.org/ftp/Specs/html-info/26-series.htm. | |
63 * | |
64 */ | |
65 | |
66 #include "avcodec.h" | |
67 | |
68 #ifdef CONFIG_LIBAMR_NB_FIXED | |
69 | |
70 #define MMS_IO | |
71 | |
72 #include "amr/sp_dec.h" | |
73 #include "amr/d_homing.h" | |
74 #include "amr/typedef.h" | |
75 #include "amr/sp_enc.h" | |
76 #include "amr/sid_sync.h" | |
77 #include "amr/e_homing.h" | |
78 | |
79 #else | |
80 #include <amrnb/interf_dec.h> | |
81 #include <amrnb/interf_enc.h> | |
82 #endif | |
83 | |
84 static const char *nb_bitrate_unsupported = | |
85 "bitrate not supported: use one of 4.75k, 5.15k, 5.9k, 6.7k, 7.4k, 7.95k, 10.2k or 12.2k\n"; | |
86 static const char *wb_bitrate_unsupported = | |
87 "bitrate not supported: use one of 6.6k, 8.85k, 12.65k, 14.25k, 15.85k, 18.25k, 19.85k, 23.05k, or 23.85k\n"; | |
88 | |
89 /* Common code for fixed and float version*/ | |
90 typedef struct AMR_bitrates | |
91 { | |
92 int rate; | |
93 enum Mode mode; | |
94 } AMR_bitrates; | |
95 | |
96 /* Match desired bitrate */ | |
97 static int getBitrateMode(int bitrate) | |
98 { | |
99 /* make the correspondance between bitrate and mode */ | |
100 AMR_bitrates rates[]={ {4750,MR475}, | |
101 {5150,MR515}, | |
102 {5900,MR59}, | |
103 {6700,MR67}, | |
104 {7400,MR74}, | |
105 {7950,MR795}, | |
106 {10200,MR102}, | |
107 {12200,MR122}, | |
108 }; | |
109 int i; | |
110 | |
111 for(i=0;i<8;i++) | |
112 { | |
113 if(rates[i].rate==bitrate) | |
114 { | |
115 return(rates[i].mode); | |
116 } | |
117 } | |
118 /* no bitrate matching, return an error */ | |
119 return -1; | |
120 } | |
121 | |
122 static void amr_decode_fix_avctx(AVCodecContext * avctx) | |
123 { | |
124 const int is_amr_wb = 1 + (avctx->codec_id == CODEC_ID_AMR_WB); | |
125 | |
126 if(avctx->sample_rate == 0) | |
127 { | |
128 avctx->sample_rate = 8000 * is_amr_wb; | |
129 } | |
130 | |
131 if(avctx->channels == 0) | |
132 { | |
133 avctx->channels = 1; | |
134 } | |
135 | |
136 avctx->frame_size = 160 * is_amr_wb; | |
137 } | |
138 | |
139 #ifdef CONFIG_LIBAMR_NB_FIXED | |
140 /* fixed point version*/ | |
141 /* frame size in serial bitstream file (frame type + serial stream + flags) */ | |
142 #define SERIAL_FRAMESIZE (1+MAX_SERIAL_SIZE+5) | |
143 | |
144 typedef struct AMRContext { | |
145 int frameCount; | |
146 Speech_Decode_FrameState *speech_decoder_state; | |
147 enum RXFrameType rx_type; | |
148 enum Mode mode; | |
149 Word16 reset_flag; | |
150 Word16 reset_flag_old; | |
151 | |
152 int enc_bitrate; | |
153 Speech_Encode_FrameState *enstate; | |
154 sid_syncState *sidstate; | |
155 enum TXFrameType tx_frametype; | |
156 } AMRContext; | |
157 | |
158 static int amr_nb_decode_init(AVCodecContext * avctx) | |
159 { | |
160 AMRContext *s = avctx->priv_data; | |
161 | |
162 s->frameCount=0; | |
163 s->speech_decoder_state=NULL; | |
164 s->rx_type = (enum RXFrameType)0; | |
165 s->mode= (enum Mode)0; | |
166 s->reset_flag=0; | |
167 s->reset_flag_old=1; | |
168 | |
169 if(Speech_Decode_Frame_init(&s->speech_decoder_state, "Decoder")) | |
170 { | |
171 av_log(avctx, AV_LOG_ERROR, "Speech_Decode_Frame_init error\n"); | |
172 return -1; | |
173 } | |
174 | |
175 amr_decode_fix_avctx(avctx); | |
176 | |
177 if(avctx->channels > 1) | |
178 { | |
179 av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n"); | |
180 return -1; | |
181 } | |
182 | |
183 return 0; | |
184 } | |
185 | |
186 static int amr_nb_encode_init(AVCodecContext * avctx) | |
187 { | |
188 AMRContext *s = avctx->priv_data; | |
189 | |
190 s->frameCount=0; | |
191 s->speech_decoder_state=NULL; | |
192 s->rx_type = (enum RXFrameType)0; | |
193 s->mode= (enum Mode)0; | |
194 s->reset_flag=0; | |
195 s->reset_flag_old=1; | |
196 | |
197 if(avctx->sample_rate!=8000) | |
198 { | |
199 av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n"); | |
200 return -1; | |
201 } | |
202 | |
203 if(avctx->channels!=1) | |
204 { | |
205 av_log(avctx, AV_LOG_ERROR, "Only mono supported\n"); | |
206 return -1; | |
207 } | |
208 | |
209 avctx->frame_size=160; | |
210 avctx->coded_frame= avcodec_alloc_frame(); | |
211 | |
212 if(Speech_Encode_Frame_init(&s->enstate, 0, "encoder") || sid_sync_init (&s->sidstate)) | |
213 { | |
214 av_log(avctx, AV_LOG_ERROR, "Speech_Encode_Frame_init error\n"); | |
215 return -1; | |
216 } | |
217 | |
218 if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0) | |
219 { | |
220 av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported); | |
221 return -1; | |
222 } | |
223 | |
224 return 0; | |
225 } | |
226 | |
227 static int amr_nb_encode_close(AVCodecContext * avctx) | |
228 { | |
229 AMRContext *s = avctx->priv_data; | |
230 | |
231 Speech_Encode_Frame_exit(&s->enstate); | |
232 sid_sync_exit (&s->sidstate); | |
233 av_freep(&avctx->coded_frame); | |
234 return 0; | |
235 } | |
236 | |
237 static int amr_nb_decode_close(AVCodecContext * avctx) | |
238 { | |
239 AMRContext *s = avctx->priv_data; | |
240 | |
241 Speech_Decode_Frame_exit(&s->speech_decoder_state); | |
242 return 0; | |
243 } | |
244 | |
245 static int amr_nb_decode_frame(AVCodecContext * avctx, | |
246 void *data, int *data_size, | |
247 uint8_t * buf, int buf_size) | |
248 { | |
249 AMRContext *s = avctx->priv_data; | |
250 uint8_t*amrData=buf; | |
251 int offset=0; | |
252 UWord8 toc, q, ft; | |
253 Word16 serial[SERIAL_FRAMESIZE]; /* coded bits */ | |
254 Word16 *synth; | |
255 UWord8 *packed_bits; | |
256 static Word16 packed_size[16] = {12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0}; | |
257 int i; | |
258 | |
259 //printf("amr_decode_frame data_size=%i buf=0x%X buf_size=%d frameCount=%d!!\n",*data_size,buf,buf_size,s->frameCount); | |
260 | |
261 synth=data; | |
262 | |
263 toc=amrData[offset]; | |
264 /* read rest of the frame based on ToC byte */ | |
265 q = (toc >> 2) & 0x01; | |
266 ft = (toc >> 3) & 0x0F; | |
267 | |
268 //printf("offset=%d, packet_size=%d amrData= 0x%X %X %X %X\n",offset,packed_size[ft],amrData[offset],amrData[offset+1],amrData[offset+2],amrData[offset+3]); | |
269 | |
270 offset++; | |
271 | |
272 packed_bits=amrData+offset; | |
273 | |
274 offset+=packed_size[ft]; | |
275 | |
276 //Unsort and unpack bits | |
277 s->rx_type = UnpackBits(q, ft, packed_bits, &s->mode, &serial[1]); | |
278 | |
279 //We have a new frame | |
280 s->frameCount++; | |
281 | |
282 if (s->rx_type == RX_NO_DATA) | |
283 { | |
284 s->mode = s->speech_decoder_state->prev_mode; | |
285 } | |
286 else { | |
287 s->speech_decoder_state->prev_mode = s->mode; | |
288 } | |
289 | |
290 /* if homed: check if this frame is another homing frame */ | |
291 if (s->reset_flag_old == 1) | |
292 { | |
293 /* only check until end of first subframe */ | |
294 s->reset_flag = decoder_homing_frame_test_first(&serial[1], s->mode); | |
295 } | |
296 /* produce encoder homing frame if homed & input=decoder homing frame */ | |
297 if ((s->reset_flag != 0) && (s->reset_flag_old != 0)) | |
298 { | |
299 for (i = 0; i < L_FRAME; i++) | |
300 { | |
301 synth[i] = EHF_MASK; | |
302 } | |
303 } | |
304 else | |
305 { | |
306 /* decode frame */ | |
307 Speech_Decode_Frame(s->speech_decoder_state, s->mode, &serial[1], s->rx_type, synth); | |
308 } | |
309 | |
310 //Each AMR-frame results in 160 16-bit samples | |
311 *data_size=160*2; | |
312 | |
313 /* if not homed: check whether current frame is a homing frame */ | |
314 if (s->reset_flag_old == 0) | |
315 { | |
316 /* check whole frame */ | |
317 s->reset_flag = decoder_homing_frame_test(&serial[1], s->mode); | |
318 } | |
319 /* reset decoder if current frame is a homing frame */ | |
320 if (s->reset_flag != 0) | |
321 { | |
322 Speech_Decode_Frame_reset(s->speech_decoder_state); | |
323 } | |
324 s->reset_flag_old = s->reset_flag; | |
325 | |
326 return offset; | |
327 } | |
328 | |
329 | |
330 static int amr_nb_encode_frame(AVCodecContext *avctx, | |
331 unsigned char *frame/*out*/, int buf_size, void *data/*in*/) | |
332 { | |
333 short serial_data[250] = {0}; | |
334 AMRContext *s = avctx->priv_data; | |
335 int written; | |
336 | |
337 s->reset_flag = encoder_homing_frame_test(data); | |
338 | |
339 Speech_Encode_Frame(s->enstate, s->enc_bitrate, data, &serial_data[1], &s->mode); | |
340 | |
341 /* add frame type and mode */ | |
342 sid_sync (s->sidstate, s->mode, &s->tx_frametype); | |
343 | |
344 written = PackBits(s->mode, s->enc_bitrate, s->tx_frametype, &serial_data[1], frame); | |
345 | |
346 if (s->reset_flag != 0) | |
347 { | |
348 Speech_Encode_Frame_reset(s->enstate); | |
349 sid_sync_reset(s->sidstate); | |
350 } | |
351 return written; | |
352 } | |
353 | |
354 | |
355 #elif defined(CONFIG_LIBAMR_NB) /* Float point version*/ | |
356 | |
357 typedef struct AMRContext { | |
358 int frameCount; | |
359 void * decState; | |
360 int *enstate; | |
361 int enc_bitrate; | |
362 } AMRContext; | |
363 | |
364 static int amr_nb_decode_init(AVCodecContext * avctx) | |
365 { | |
366 AMRContext *s = avctx->priv_data; | |
367 | |
368 s->frameCount=0; | |
369 s->decState=Decoder_Interface_init(); | |
370 if(!s->decState) | |
371 { | |
372 av_log(avctx, AV_LOG_ERROR, "Decoder_Interface_init error\r\n"); | |
373 return -1; | |
374 } | |
375 | |
376 amr_decode_fix_avctx(avctx); | |
377 | |
378 if(avctx->channels > 1) | |
379 { | |
380 av_log(avctx, AV_LOG_ERROR, "amr_nb: multichannel decoding not supported\n"); | |
381 return -1; | |
382 } | |
383 | |
384 return 0; | |
385 } | |
386 | |
387 static int amr_nb_encode_init(AVCodecContext * avctx) | |
388 { | |
389 AMRContext *s = avctx->priv_data; | |
390 | |
391 s->frameCount=0; | |
392 | |
393 if(avctx->sample_rate!=8000) | |
394 { | |
395 av_log(avctx, AV_LOG_ERROR, "Only 8000Hz sample rate supported\n"); | |
396 return -1; | |
397 } | |
398 | |
399 if(avctx->channels!=1) | |
400 { | |
401 av_log(avctx, AV_LOG_ERROR, "Only mono supported\n"); | |
402 return -1; | |
403 } | |
404 | |
405 avctx->frame_size=160; | |
406 avctx->coded_frame= avcodec_alloc_frame(); | |
407 | |
408 s->enstate=Encoder_Interface_init(0); | |
409 if(!s->enstate) | |
410 { | |
411 av_log(avctx, AV_LOG_ERROR, "Encoder_Interface_init error\n"); | |
412 return -1; | |
413 } | |
414 | |
415 if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0) | |
416 { | |
417 av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported); | |
418 return -1; | |
419 } | |
420 | |
421 return 0; | |
422 } | |
423 | |
424 static int amr_nb_decode_close(AVCodecContext * avctx) | |
425 { | |
426 AMRContext *s = avctx->priv_data; | |
427 | |
428 Decoder_Interface_exit(s->decState); | |
429 return 0; | |
430 } | |
431 | |
432 static int amr_nb_encode_close(AVCodecContext * avctx) | |
433 { | |
434 AMRContext *s = avctx->priv_data; | |
435 | |
436 Encoder_Interface_exit(s->enstate); | |
437 av_freep(&avctx->coded_frame); | |
438 return 0; | |
439 } | |
440 | |
441 static int amr_nb_decode_frame(AVCodecContext * avctx, | |
442 void *data, int *data_size, | |
443 uint8_t * buf, int buf_size) | |
444 { | |
445 AMRContext *s = avctx->priv_data; | |
446 uint8_t*amrData=buf; | |
447 static short block_size[16]={ 12, 13, 15, 17, 19, 20, 26, 31, 5, 0, 0, 0, 0, 0, 0, 0 }; | |
448 enum Mode dec_mode; | |
449 int packet_size; | |
450 | |
451 /* av_log(NULL,AV_LOG_DEBUG,"amr_decode_frame buf=%p buf_size=%d frameCount=%d!!\n",buf,buf_size,s->frameCount); */ | |
452 | |
453 dec_mode = (buf[0] >> 3) & 0x000F; | |
454 packet_size = block_size[dec_mode]+1; | |
455 | |
456 if(packet_size > buf_size) { | |
457 av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size); | |
458 return -1; | |
459 } | |
460 | |
461 s->frameCount++; | |
462 /* av_log(NULL,AV_LOG_DEBUG,"packet_size=%d amrData= 0x%X %X %X %X\n",packet_size,amrData[0],amrData[1],amrData[2],amrData[3]); */ | |
463 /* call decoder */ | |
464 Decoder_Interface_Decode(s->decState, amrData, data, 0); | |
465 *data_size=160*2; | |
466 | |
467 return packet_size; | |
468 } | |
469 | |
470 static int amr_nb_encode_frame(AVCodecContext *avctx, | |
471 unsigned char *frame/*out*/, int buf_size, void *data/*in*/) | |
472 { | |
473 AMRContext *s = avctx->priv_data; | |
474 int written; | |
475 | |
476 if((s->enc_bitrate=getBitrateMode(avctx->bit_rate))<0) | |
477 { | |
478 av_log(avctx, AV_LOG_ERROR, nb_bitrate_unsupported); | |
479 return -1; | |
480 } | |
481 | |
482 written = Encoder_Interface_Encode(s->enstate, | |
483 s->enc_bitrate, | |
484 data, | |
485 frame, | |
486 0); | |
487 /* av_log(NULL,AV_LOG_DEBUG,"amr_nb_encode_frame encoded %u bytes, bitrate %u, first byte was %#02x\n",written, s->enc_bitrate, frame[0] ); */ | |
488 | |
489 return written; | |
490 } | |
491 | |
492 #endif | |
493 | |
494 #if defined(CONFIG_LIBAMR_NB) || defined(CONFIG_LIBAMR_NB_FIXED) | |
495 | |
496 AVCodec libamr_nb_decoder = | |
497 { | |
498 "libamr_nb", | |
499 CODEC_TYPE_AUDIO, | |
500 CODEC_ID_AMR_NB, | |
501 sizeof(AMRContext), | |
502 amr_nb_decode_init, | |
503 NULL, | |
504 amr_nb_decode_close, | |
505 amr_nb_decode_frame, | |
506 }; | |
507 | |
508 AVCodec libamr_nb_encoder = | |
509 { | |
510 "libamr_nb", | |
511 CODEC_TYPE_AUDIO, | |
512 CODEC_ID_AMR_NB, | |
513 sizeof(AMRContext), | |
514 amr_nb_encode_init, | |
515 amr_nb_encode_frame, | |
516 amr_nb_encode_close, | |
517 NULL, | |
518 }; | |
519 | |
520 #endif | |
521 | |
522 /* -----------AMR wideband ------------*/ | |
523 #ifdef CONFIG_LIBAMR_WB | |
524 | |
525 #ifdef _TYPEDEF_H | |
526 //To avoid duplicate typedefs from typdef in amr-nb | |
527 #define typedef_h | |
528 #endif | |
529 | |
530 #include <amrwb/enc_if.h> | |
531 #include <amrwb/dec_if.h> | |
532 #include <amrwb/if_rom.h> | |
533 | |
534 /* Common code for fixed and float version*/ | |
535 typedef struct AMRWB_bitrates | |
536 { | |
537 int rate; | |
538 int mode; | |
539 } AMRWB_bitrates; | |
540 | |
541 static int getWBBitrateMode(int bitrate) | |
542 { | |
543 /* make the correspondance between bitrate and mode */ | |
544 AMRWB_bitrates rates[]={ {6600,0}, | |
545 {8850,1}, | |
546 {12650,2}, | |
547 {14250,3}, | |
548 {15850,4}, | |
549 {18250,5}, | |
550 {19850,6}, | |
551 {23050,7}, | |
552 {23850,8}, | |
553 }; | |
554 int i; | |
555 | |
556 for(i=0;i<9;i++) | |
557 { | |
558 if(rates[i].rate==bitrate) | |
559 { | |
560 return(rates[i].mode); | |
561 } | |
562 } | |
563 /* no bitrate matching, return an error */ | |
564 return -1; | |
565 } | |
566 | |
567 | |
568 typedef struct AMRWBContext { | |
569 int frameCount; | |
570 void *state; | |
571 int mode; | |
572 Word16 allow_dtx; | |
573 } AMRWBContext; | |
574 | |
575 static int amr_wb_encode_init(AVCodecContext * avctx) | |
576 { | |
577 AMRWBContext *s = avctx->priv_data; | |
578 | |
579 s->frameCount=0; | |
580 | |
581 if(avctx->sample_rate!=16000) | |
582 { | |
583 av_log(avctx, AV_LOG_ERROR, "Only 16000Hz sample rate supported\n"); | |
584 return -1; | |
585 } | |
586 | |
587 if(avctx->channels!=1) | |
588 { | |
589 av_log(avctx, AV_LOG_ERROR, "Only mono supported\n"); | |
590 return -1; | |
591 } | |
592 | |
593 if((s->mode=getWBBitrateMode(avctx->bit_rate))<0) | |
594 { | |
595 av_log(avctx, AV_LOG_ERROR, wb_bitrate_unsupported); | |
596 return -1; | |
597 } | |
598 | |
599 avctx->frame_size=320; | |
600 avctx->coded_frame= avcodec_alloc_frame(); | |
601 | |
602 s->state = E_IF_init(); | |
603 s->allow_dtx=0; | |
604 | |
605 return 0; | |
606 } | |
607 | |
608 static int amr_wb_encode_close(AVCodecContext * avctx) | |
609 { | |
610 AMRWBContext *s = avctx->priv_data; | |
611 | |
612 E_IF_exit(s->state); | |
613 av_freep(&avctx->coded_frame); | |
614 s->frameCount++; | |
615 return 0; | |
616 } | |
617 | |
618 static int amr_wb_encode_frame(AVCodecContext *avctx, | |
619 unsigned char *frame/*out*/, int buf_size, void *data/*in*/) | |
620 { | |
621 AMRWBContext *s = avctx->priv_data; | |
622 int size; | |
623 | |
624 if((s->mode=getWBBitrateMode(avctx->bit_rate))<0) | |
625 { | |
626 av_log(avctx, AV_LOG_ERROR, wb_bitrate_unsupported); | |
627 return -1; | |
628 } | |
629 size = E_IF_encode(s->state, s->mode, data, frame, s->allow_dtx); | |
630 return size; | |
631 } | |
632 | |
633 static int amr_wb_decode_init(AVCodecContext * avctx) | |
634 { | |
635 AMRWBContext *s = avctx->priv_data; | |
636 | |
637 s->frameCount=0; | |
638 s->state = D_IF_init(); | |
639 | |
640 amr_decode_fix_avctx(avctx); | |
641 | |
642 if(avctx->channels > 1) | |
643 { | |
644 av_log(avctx, AV_LOG_ERROR, "amr_wb: multichannel decoding not supported\n"); | |
645 return -1; | |
646 } | |
647 | |
648 return 0; | |
649 } | |
650 | |
651 static int amr_wb_decode_frame(AVCodecContext * avctx, | |
652 void *data, int *data_size, | |
653 uint8_t * buf, int buf_size) | |
654 { | |
655 AMRWBContext *s = avctx->priv_data; | |
656 uint8_t*amrData=buf; | |
657 int mode; | |
658 int packet_size; | |
659 | |
660 if(buf_size==0) { | |
661 /* nothing to do */ | |
662 return 0; | |
663 } | |
664 | |
665 mode = (amrData[0] >> 3) & 0x000F; | |
666 packet_size = block_size[mode]; | |
667 | |
668 if(packet_size > buf_size) { | |
669 av_log(avctx, AV_LOG_ERROR, "amr frame too short (%u, should be %u)\n", buf_size, packet_size+1); | |
670 return -1; | |
671 } | |
672 | |
673 s->frameCount++; | |
674 D_IF_decode( s->state, amrData, data, _good_frame); | |
675 *data_size=320*2; | |
676 return packet_size; | |
677 } | |
678 | |
679 static int amr_wb_decode_close(AVCodecContext * avctx) | |
680 { | |
681 AMRWBContext *s = avctx->priv_data; | |
682 | |
683 D_IF_exit(s->state); | |
684 return 0; | |
685 } | |
686 | |
687 AVCodec libamr_wb_decoder = | |
688 { | |
689 "libamr_wb", | |
690 CODEC_TYPE_AUDIO, | |
691 CODEC_ID_AMR_WB, | |
692 sizeof(AMRWBContext), | |
693 amr_wb_decode_init, | |
694 NULL, | |
695 amr_wb_decode_close, | |
696 amr_wb_decode_frame, | |
697 }; | |
698 | |
699 AVCodec libamr_wb_encoder = | |
700 { | |
701 "libamr_wb", | |
702 CODEC_TYPE_AUDIO, | |
703 CODEC_ID_AMR_WB, | |
704 sizeof(AMRWBContext), | |
705 amr_wb_encode_init, | |
706 amr_wb_encode_frame, | |
707 amr_wb_encode_close, | |
708 NULL, | |
709 }; | |
710 | |
711 #endif //CONFIG_LIBAMR_WB |