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