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