Audio: add adpcm decoder [3/4]
PD#OTT-42116
Problem:
add adpcm decoder for hal.
Solution:
add adpcm decoder for hal.
Verify:
yocto ap222.
Change-Id: I647b51b53364906f34aa5652cf7491795986d911
Signed-off-by: wei.wang1 <wei.wang1@amlogic.com>
diff --git a/libadpcm/adpcm_decode.c b/libadpcm/adpcm_decode.c
new file mode 100644
index 0000000..20684a4
--- /dev/null
+++ b/libadpcm/adpcm_decode.c
@@ -0,0 +1,951 @@
+/*
+ * Copyright (C) 2017 Amlogic, Inc. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ * * Description:
+ * adpcm decoder
+ */
+#define LOG_TAG "AdpcmDecoder"
+
+#include <stdio.h>
+#include <stdint.h>
+//#include <syslog.h>
+#include "adpcm.h"
+#include "adec-armdec-mgt.h"
+#include <sys/time.h>
+#include <stdint.h>
+#include <string.h>
+//#include <android/log.h>
+#include <cutils/log.h>
+#include <cutils/properties.h>
+
+#define LOG_TAG "AdpcmDecoder"
+//#define PRINTF(...) //__android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
+#define PRINTF( ...) //syslog(LOG_ERR, ##__VA_ARGS__)
+
+
+typedef struct {
+ int ValidDataLen;
+ int UsedDataLen;
+ unsigned char *BufStart;
+ unsigned char *pcur;
+} pcm_read_ctl_t;
+
+
+static int pcm_read_init(pcm_read_ctl_t *pcm_read_ctx, unsigned char* inbuf, int size)
+{
+ pcm_read_ctx->ValidDataLen = size;
+ pcm_read_ctx->UsedDataLen = 0;
+ pcm_read_ctx->BufStart = inbuf;
+ pcm_read_ctx->pcur = inbuf;
+ return 0;
+}
+
+static int pcm_read(pcm_read_ctl_t *pcm_read_ctx, unsigned char* outbuf, int size)
+{
+ int bytes_read = 0;
+ if (size <= pcm_read_ctx->ValidDataLen) {
+ memcpy(outbuf, pcm_read_ctx->pcur, size);
+ pcm_read_ctx->ValidDataLen -= size;
+ pcm_read_ctx->UsedDataLen += size;
+ pcm_read_ctx->pcur += size;
+ bytes_read = size;
+ }
+ return bytes_read;
+}
+
+struct t_wave_buf {
+ void *addr;
+ unsigned size;
+};
+static unsigned wave_timestamplen = 0;
+static unsigned wave_timestamp = 0;
+
+static int adpcm_step[89] = {
+ 7, 8, 9, 10, 11, 12, 13, 14, 16, 17,
+ 19, 21, 23, 25, 28, 31, 34, 37, 41, 45,
+ 50, 55, 60, 66, 73, 80, 88, 97, 107, 118,
+ 130, 143, 157, 173, 190, 209, 230, 253, 279, 307,
+ 337, 371, 408, 449, 494, 544, 598, 658, 724, 796,
+ 876, 963, 1060, 1166, 1282, 1411, 1552, 1707, 1878, 2066,
+ 2272, 2499, 2749, 3024, 3327, 3660, 4026, 4428, 4871, 5358,
+ 5894, 6484, 7132, 7845, 8630, 9493, 10442, 11487, 12635, 13899,
+ 15289, 16818, 18500, 20350, 22385, 24623, 27086, 29794, 32767
+};
+
+static int adpcm_index[16] = {
+ -1, -1, -1, -1, 2, 4, 6, 8,
+ -1, -1, -1, -1, 2, 4, 6, 8
+};
+
+// useful macros
+// clamp a number between 0 and 88
+#define CLAMP_0_TO_88(x) if ((x) < 0) (x) = 0; else if ((x) > 88) (x) = 88;
+#define CLAMP_0_TO_88_2(x) if ((x) < 0) return 0; else if ((x) > 88) return 88; return (x);
+
+// clamp a number within a signed 16-bit range
+#define CLAMP_S16(x) if (x < -32768) x = -32768; \
+ else if (x > 32767) x = 32767;
+#define CLAMP_S16_2(x) if ((x) < -32768) return -32768; \
+ else if ((x) > 32767) return 32767; \
+ return (x);
+// clamp a number above 16
+#define CLAMP_ABOVE_16(x) if (x < 16) x = 16;
+// sign extend a 16-bit value
+#define SE_16BIT(x) if (x & 0x8000) x -= 0x10000;
+// sign extend a 4-bit value
+#define SE_4BIT(x) if (x & 0x8) x -= 0x10;
+static t_adpcm_output_buf_manager g_mgr;
+static int block_align = 0;
+static int offset = 0;
+//extern unsigned char buffer[1024*64];
+static unsigned char *pwavebuf = NULL;
+static struct t_wave_buf wave_decoder_buffer[] = {{0, 0}, {0, 0}}; // 0 - stream, 1 - pcm
+
+#define CHECK_DATA_ENOUGH_SUB(Ctl,NeedBytes,UsedSetIfNo) { \
+ if ((Ctl)->ValidDataLen < (NeedBytes)) { \
+ PRINTF("[%s %d]NOTE--> no enough data\n",__FUNCTION__,__LINE__);\
+ (Ctl)->UsedDataLen-=(UsedSetIfNo); \
+ return -1; \
+ } \
+}
+
+#define CHECK_DATA_ENOUGH_SET(Ctl,NeedBytes,UsedSetIfNo) { \
+ if ((Ctl)->ValidDataLen < (NeedBytes)) { \
+ PRINTF("[%s %d]NOTE--> no enough data\n",__FUNCTION__,__LINE__);\
+ (Ctl)->UsedDataLen=(UsedSetIfNo); \
+ return -1; \
+ } \
+}
+
+static int refill(audio_decoder_operations_t *adec_ops, pcm_read_ctl_t *pcm_read_ctx, unsigned char* buf, int len)
+{
+ static unsigned refill_timestamp_len = 0;
+ unsigned char *pbuf = buf;
+ unsigned char tmp_a = 0;
+ unsigned char tmp_p = 0;
+ unsigned char tmp_t = 0;
+ unsigned char tmp_s = 0;
+ int len_bak = len;
+ int tmp = 0;
+ if (wave_timestamplen == 0) { // when no apts found
+ unsigned char timestamp[4] = {0};
+ unsigned char block_length[4] = {0};
+
+ CHECK_DATA_ENOUGH_SET(pcm_read_ctx, 4, 0)
+ pcm_read(pcm_read_ctx, &tmp_a, 1);
+ pcm_read(pcm_read_ctx, &tmp_p, 1);
+ pcm_read(pcm_read_ctx, &tmp_t, 1);
+ pcm_read(pcm_read_ctx, &tmp_s, 1);
+
+ if (tmp_a == 'A' && tmp_p == 'P' && tmp_t == 'T' && tmp_s == 'S') {
+ CHECK_DATA_ENOUGH_SET(pcm_read_ctx, 8, 0)
+ pcm_read(pcm_read_ctx, timestamp, 4);
+ wave_timestamp = (timestamp[0] << 24) | (timestamp[1] << 16) | (timestamp[2] << 8) | (timestamp[3]);
+ pcm_read(pcm_read_ctx, block_length, 4);
+ wave_timestamplen = (block_length[0] << 24) | (block_length[1] << 16) | (block_length[2] << 8) | (block_length[3]);
+ refill_timestamp_len = wave_timestamplen;
+
+ CHECK_DATA_ENOUGH_SET(pcm_read_ctx, refill_timestamp_len, 0)
+
+ } else if (tmp_a == 'R' && tmp_p == 'I' && tmp_t == 'F' && tmp_s == 'F') {
+ if ((adec_ops->nAudioDecoderType == CODEC_ID_ADPCM_IMA_WAV) || (adec_ops->nAudioDecoderType == CODEC_ID_ADPCM_MS)) {
+ tmp = len;
+ while (tmp) {
+ CHECK_DATA_ENOUGH_SET(pcm_read_ctx, 8, 0)
+ pcm_read(pcm_read_ctx, ×tamp[0], 1);
+ tmp --;
+ if (timestamp[0] == 'd') {
+ pcm_read(pcm_read_ctx, ×tamp[1], 3);
+ tmp -= 3;
+ if ((timestamp[0] == 'd') && (timestamp[1] == 'a') && (timestamp[2] == 't') && (timestamp[3] == 'a')) {
+ break;
+ }
+ }
+ }
+ pcm_read(pcm_read_ctx, timestamp, 4);
+ wave_timestamplen = 0;
+ wave_timestamp = 0xffffffff;
+
+ CHECK_DATA_ENOUGH_SUB(pcm_read_ctx, len, 0)
+ } else {
+ *pbuf++ = tmp_a;
+ *pbuf++ = tmp_p;
+ *pbuf++ = tmp_t;
+ *pbuf++ = tmp_s;
+ len -= 4;
+ wave_timestamplen = 0;
+ wave_timestamp = 0xffffffff;
+
+ CHECK_DATA_ENOUGH_SET(pcm_read_ctx, len, 0)
+ }
+ } else {
+ *pbuf++ = tmp_a;
+ *pbuf++ = tmp_p;
+ *pbuf++ = tmp_t;
+ *pbuf++ = tmp_s;
+ len -= 4;
+ CHECK_DATA_ENOUGH_SET(pcm_read_ctx, len, 0)
+ wave_timestamplen = 0;
+ wave_timestamp = 0xffffffff;
+ }
+ }
+
+ if (wave_timestamplen) {
+ pcm_read(pcm_read_ctx, pbuf, refill_timestamp_len);
+ return refill_timestamp_len;
+ } else {
+ pcm_read(pcm_read_ctx, pbuf, len);
+ return len_bak;
+ }
+
+}
+
+/*IMA ADPCM*/
+#define le2me_16(x) (x)
+#define MS_IMA_ADPCM_PREAMBLE_SIZE 4
+#define LE_16(x) (le2me_16(*(unsigned short *)(x)))
+
+static void decode_nibbles(unsigned short *output,
+ int output_size, int channels,
+ int predictor_l, int index_l,
+ int predictor_r, int index_r)
+{
+ int step[2];
+ int predictor[2];
+ int index[2];
+ int diff;
+ int i;
+ int sign;
+ int delta;
+ int channel_number = 0;
+
+ step[0] = adpcm_step[index_l];
+ step[1] = adpcm_step[index_r];
+ predictor[0] = predictor_l;
+ predictor[1] = predictor_r;
+ index[0] = index_l;
+ index[1] = index_r;
+
+ for (i = 0; i < output_size; i++) {
+ delta = output[i];
+
+ index[channel_number] += adpcm_index[delta];
+ CLAMP_0_TO_88(index[channel_number]);
+
+ sign = delta & 8;
+ delta = delta & 7;
+
+ diff = step[channel_number] >> 3;
+ if (delta & 4) {
+ diff += step[channel_number];
+ }
+ if (delta & 2) {
+ diff += step[channel_number] >> 1;
+ }
+ if (delta & 1) {
+ diff += step[channel_number] >> 2;
+ }
+
+ if (sign) {
+ predictor[channel_number] -= diff;
+ } else {
+ predictor[channel_number] += diff;
+ }
+
+ CLAMP_S16(predictor[channel_number]);
+ output[i] = predictor[channel_number];
+ step[channel_number] = adpcm_step[index[channel_number]];
+
+ // toggle channel
+ channel_number ^= channels - 1;
+
+ }
+}
+
+static int ima_adpcm_decode_block(unsigned short *output,
+ unsigned char *input, int channels, int block_size)
+{
+ int predictor_l = 0;
+ int predictor_r = 0;
+ int index_l = 0;
+ int index_r = 0;
+ int i;
+ int channel_counter;
+ int channel_index;
+ int channel_index_l;
+ int channel_index_r;
+
+ predictor_l = LE_16(&input[0]);
+ SE_16BIT(predictor_l);
+ index_l = input[2];
+ if (channels == 2) {
+ predictor_r = LE_16(&input[4]);
+ SE_16BIT(predictor_r);
+ index_r = input[6];
+ }
+
+ if (channels == 1)
+ for (i = 0; i < (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels); i++) {
+ output[i * 2 + 0] = input[MS_IMA_ADPCM_PREAMBLE_SIZE + i] & 0x0F;
+ output[i * 2 + 1] = input[MS_IMA_ADPCM_PREAMBLE_SIZE + i] >> 4;
+ }
+ else {
+ // encoded as 8 nibbles (4 bytes) per channel; switch channel every
+ // 4th byte
+ channel_counter = 0;
+ channel_index_l = 0;
+ channel_index_r = 1;
+ channel_index = channel_index_l;
+ for (i = 0;
+ i < (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels); i++) {
+ output[channel_index + 0] =
+ input[MS_IMA_ADPCM_PREAMBLE_SIZE * 2 + i] & 0x0F;
+ output[channel_index + 2] =
+ input[MS_IMA_ADPCM_PREAMBLE_SIZE * 2 + i] >> 4;
+ channel_index += 4;
+ channel_counter++;
+ if (channel_counter == 4) {
+ channel_index_l = channel_index;
+ channel_index = channel_index_r;
+ } else if (channel_counter == 8) {
+ channel_index_r = channel_index;
+ channel_index = channel_index_l;
+ channel_counter = 0;
+ }
+ }
+ }
+
+ decode_nibbles(output,
+ (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels) * 2,
+ channels,
+ predictor_l, index_l,
+ predictor_r, index_r);
+
+ return (block_size - MS_IMA_ADPCM_PREAMBLE_SIZE * channels) * 2;
+}
+#define MSADPCM_ADAPT_COEFF_COUNT 7
+static int AdaptationTable [] = {
+ 230, 230, 230, 230, 307, 409, 512, 614,
+ 768, 614, 512, 409, 307, 230, 230, 230
+} ;
+
+/* TODO : The first 7 coef's are are always hardcode and must
+appear in the actual WAVE file. They should be read in
+in case a sound program added extras to the list. */
+
+static int AdaptCoeff1 [MSADPCM_ADAPT_COEFF_COUNT] = {
+ 256, 512, 0, 192, 240, 460, 392
+} ;
+
+static int AdaptCoeff2 [MSADPCM_ADAPT_COEFF_COUNT] = {
+ 0, -256, 0, 64, 0, -208, -232
+} ;
+
+static int ms_adpcm_decode_block(short *pcm_buf, unsigned char *buf, int channel, int block)
+{
+ int sampleblk = 2036;
+ short bpred[2];
+ short idelta[2];
+ int blockindx = 0;
+ int sampleindx = 0;
+ short bytecode = 0;
+ int predict = 0;
+ int current = 0;
+ int delta = 0;
+ int i = 0;
+ int j = 0;
+ short s0 = 0;
+ short s1 = 0;
+ short s2 = 0;
+ short s3 = 0;
+ short s4 = 0;
+ short s5 = 0;
+
+ //sampleblk = sample_block;
+ j = 0;
+ if (channel == 1) {
+ bpred[0] = buf[0];
+ bpred[1] = 0;
+ if (bpred[0] >= 7) {
+ //printf("sync error\n");
+ //goto _exit;
+ }
+ idelta[0] = buf[1] | buf[2] << 8;
+ idelta[1] = 0;
+
+ s1 = buf[3] | buf[4] << 8;
+ s0 = buf[5] | buf[6] << 8;
+
+ blockindx = 7;
+ sampleindx = 2;
+ } else if (channel == 2) {
+ bpred[0] = buf[0];
+ bpred[1] = buf[1];
+ if (bpred[0] >= 7 || bpred[1] >= 7) {
+ //printf("sync error\n");
+ //goto _exit;
+ }
+ idelta[0] = buf[2] | buf[3] << 8;
+ idelta[1] = buf[4] | buf[5] << 8;
+
+ s2 = buf[6] | buf[7] << 8;
+ s3 = buf[8] | buf[9] << 8;
+ s0 = buf[10] | buf[11] << 8;
+ s1 = buf[12] | buf[13] << 8;
+ blockindx = 14;
+ sampleindx = 4;
+ }
+
+ /*--------------------------------------------------------
+ This was left over from a time when calculations were done
+ as ints rather than shorts. Keep this around as a reminder
+ in case I ever find a file which decodes incorrectly.
+
+ if (chan_idelta [0] & 0x8000)
+ chan_idelta [0] -= 0x10000 ;
+ if (chan_idelta [1] & 0x8000)
+ chan_idelta [1] -= 0x10000 ;
+ --------------------------------------------------------*/
+
+ /* Pull apart the packed 4 bit samples and store them in their
+ ** correct sample positions.
+ */
+
+ /* Decode the encoded 4 bit samples. */
+ int chan;
+
+ for (i = channel * 2;/*i<channel*sampleblk&&*/(blockindx < block); i++) {
+ if (sampleindx <= i) {
+ if (blockindx < block) {
+ bytecode = buf[blockindx++];
+
+
+ if (channel == 1) {
+ s2 = (bytecode >> 4) & 0x0f;
+ s3 = bytecode & 0x0f;
+ } else if (channel == 2) {
+ s4 = (bytecode >> 4) & 0x0f;
+ s5 = bytecode & 0x0f;
+ }
+ sampleindx++;
+ sampleindx++;
+
+ }
+ }
+ chan = (channel > 1) ? (i % 2) : 0;
+
+ if (channel == 1) {
+ bytecode = s2 & 0x0f;
+ } else if (channel == 2) {
+ bytecode = s4 & 0x0f;
+ }
+ /* Compute next Adaptive Scale Factor (ASF) */
+ delta = idelta[chan];
+
+ /* => / 256 => FIXED_POINT_ADAPTATION_BASE == 256 */
+ idelta[chan] = (AdaptationTable[bytecode] * delta) >> 8;
+
+ if (idelta[chan] < 16) {
+ idelta[chan] = 16;
+ }
+ if (bytecode & 0x8) {
+ bytecode -= 0x10;
+ }
+ /* => / 256 => FIXED_POINT_COEFF_BASE == 256 */
+
+ if (channel == 1) {
+ predict = s1 * AdaptCoeff1[bpred[chan]];
+ predict += s0 * AdaptCoeff2[bpred[chan]];
+ } else if (channel == 2) {
+ predict = s2 * AdaptCoeff1[bpred[chan]];
+ predict += s0 * AdaptCoeff2[bpred[chan]];
+ }
+
+ predict >>= 8;
+ current = bytecode * delta + predict;
+#if 1
+ if (current > 32767) {
+ current = 32767 ;
+ } else if (current < -32768) {
+ current = -32768 ;
+ }
+#else
+ current = _min(current, 32767);
+ current = _max(current, -32768);
+#endif
+ if (channel == 1) {
+ s2 = current;
+ } else if (channel == 2) {
+ s4 = current;
+ }
+
+ pcm_buf[j++] = s0;
+
+ if (channel == 1) {
+ s0 = s1;
+ s1 = s2;
+ s2 = s3;
+ } else if (channel == 2) {
+ s0 = s1;
+ s1 = s2;
+ s2 = s3;
+ s3 = s4;
+ s4 = s5;
+ }
+ }
+
+ if (channel == 1) {
+ pcm_buf[j++] = s0;
+ pcm_buf[j++] = s1;
+ } else if (channel == 2) {
+ pcm_buf[j++] = s0;
+ pcm_buf[j++] = s1;
+ pcm_buf[j++] = s2;
+ pcm_buf[j++] = s3;
+ }
+
+ return j;
+}
+
+static void dump_data(void *buffer, int size, char *file_name)
+{
+ int flen = 0;
+
+ if (property_get_bool("vendor.media.adec.adpcm", 0)) {
+ FILE *fp = fopen(file_name, "a+");
+ if (fp) {
+ flen = fwrite((char *)buffer, 1, size, fp);
+ ALOGV("%s[%d]: buffer=%p, need dump data size=%d, actual dump size=%d\n", __FUNCTION__, __LINE__, buffer, size, flen);
+ fclose(fp);
+ }
+ }
+}
+
+/*
+ * u-law, A-law and linear PCM conversions.
+ */
+
+#define SIGN_BIT (0x80) /* Sign bit for a A-law byte. */
+#define QUANT_MASK (0xf) /* Quantization field mask. */
+#define NSEGS (8) /* Number of A-law segments. */
+#define SEG_SHIFT (4) /* Left shift for segment number. */
+#define SEG_MASK (0x70) /* Segment field mask. */
+//static short seg_end[8] = {0xFF, 0x1FF, 0x3FF, 0x7FF, 0xFFF, 0x1FFF, 0x3FFF, 0x7FFF};
+#define BIAS (0x84) /* Bias for linear code. */
+
+/*
+ * alaw2linear() - Convert an A-law value to 16-bit linear PCM
+ *
+ */
+int alaw2linear(unsigned char a_val)
+{
+ int t;
+ int seg;
+ a_val ^= 0x55;
+ t = (a_val & QUANT_MASK) << 4;
+ seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;
+ switch (seg) {
+ case 0:
+ t += 8;
+ break;
+ case 1:
+ t += 0x108;
+ break;
+ default:
+ t += 0x108;
+ t <<= seg - 1;
+ }
+ return ((a_val & SIGN_BIT) ? t : -t);
+}
+/*
+ * ulaw2linear() - Convert a u-law value to 16-bit linear PCM
+ *
+ * First, a biased linear code is derived from the code word. An unbiased
+ * output can then be obtained by subtracting 33 from the biased code.
+ *
+ * Note that this function expects to be passed the complement of the
+ * original code word. This is in keeping with ISDN conventions.
+ */
+int ulaw2linear(unsigned char u_val)
+{
+ int t;
+ /* Complement to obtain normal u-law value. */
+ u_val = ~u_val;
+ /*
+ * Extract and bias the quantization bits. Then
+ * shift up by the segment number and subtract out the bias.
+ */
+ t = ((u_val & QUANT_MASK) << 3) + BIAS;
+ t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
+ return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));
+}
+
+int runalawdecoder(audio_decoder_operations_t *adec_ops, pcm_read_ctl_t *pcm_read_ctx, unsigned char *buf, int len)
+{
+ int i = 0;
+ int tmp = 0;
+ short *pcm_buf = (short*)wave_decoder_buffer[1].addr;
+
+ tmp = refill(adec_ops, pcm_read_ctx, pwavebuf, WAVE_BLOCK_SIZE);
+ if (tmp < 0) {
+ return -1;
+ }
+ for (i = 0; i < tmp; i++) {
+ pcm_buf[i] = alaw2linear(pwavebuf[i]);
+ }
+ memcpy(buf, (char*)pcm_buf, 2 * WAVE_BLOCK_SIZE);
+ return (WAVE_BLOCK_SIZE) * 2;
+}
+int runulawdecoder(audio_decoder_operations_t *adec_ops, pcm_read_ctl_t *pcm_read_ctx, unsigned char *buf, int len)
+{
+ int i = 0;
+ short *pcm_buf = (short*)wave_decoder_buffer[1].addr;
+ int tmp = 0;
+
+ tmp = refill(adec_ops, pcm_read_ctx, pwavebuf, WAVE_BLOCK_SIZE);
+ if (tmp < 0) {
+ return -1;
+ }
+ for (i = 0; i < tmp; i++) {
+ pcm_buf[i] = ulaw2linear(pwavebuf[i]);
+ }
+ memcpy(buf, (char*)pcm_buf, 2 * WAVE_BLOCK_SIZE);
+ return (WAVE_BLOCK_SIZE) * 2;
+
+}
+static short
+read_sample (const char * data)
+{
+ unsigned short val = data[0] | (data[1] << 8);
+ return *((short *) & val);
+}
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+short Clamp(int x, int min, int max)
+{
+ if (x > max)
+ return max;
+ if (x < min)
+ return min;
+ return x;
+}
+
+int adpcmdec_decode_ima_block (int channels, int n_samples, const char * data,
+ short * samples)
+{
+ short stepindex[2];
+ int channel;
+ int idx;
+ int i, j;
+ int sample;
+
+ if ((n_samples - channels) % 8 != 0) {
+ ALOGE("[%s:%d] Input not correct size", __func__, __LINE__);
+ return 0;
+ }
+
+ for (channel = 0; channel < channels; channel++) {
+ samples[channel] = read_sample (data + channel * 4);
+ stepindex[channel] = MIN (data[channel * 4 + 2], 88);
+
+ if (data[channel * 4 + 3] != 0) {
+ ALOGE("[%s:%d] Synchronisation error", __func__, __LINE__);
+ return 0;
+ }
+ }
+
+ i = channels;
+ idx = 4 * channels;
+
+ while (i < n_samples) {
+ for (channel = 0; channel < channels; channel++) {
+ sample = i + channel;
+ for (j = 0; j < 8; j++) {
+ int bytecode;
+ int step;
+ int diff;
+
+ if (j % 2 == 0) {
+ bytecode = data[idx] & 0x0F;
+ } else {
+ bytecode = (data[idx] >> 4) & 0x0F;
+ idx++;
+ }
+ step = adpcm_step[stepindex[channel]];
+ diff = (2 * (bytecode & 0x7) * step + step) / 8;
+ if (bytecode & 8)
+ diff = -diff;
+
+ samples[sample] =
+ Clamp(samples[sample - channels] + diff, -32768, 32767);
+ stepindex[channel] =
+ Clamp (stepindex[channel] + adpcm_index[bytecode], 0, 88);
+ sample += channels;
+ }
+ }
+ i += 8 * channels;
+ }
+ return 1;
+}
+
+int runimaadpcmdecoder(audio_decoder_operations_t *adec_ops, pcm_read_ctl_t *pcm_read_ctx, unsigned char *buf, int len)
+{
+ short *pcm_buf = (short*)wave_decoder_buffer[1].addr;
+ int Output_Size = 0, samples;
+ int tmp = 0;
+ char buffer[5];
+ unsigned block_size = 0;
+ int UsedDataLenSave = 0;
+ if (!block_align) {
+ CHECK_DATA_ENOUGH_SET(pcm_read_ctx, 4, 0)
+ pcm_read(pcm_read_ctx, buffer, 4);
+ while (1) {
+ if ((buffer[0] == 0x11) && (buffer[1] == 0x22) && (buffer[2] == 0x33) && (buffer[3] == 0x44)) { //sync word
+ break;
+ }
+ CHECK_DATA_ENOUGH_SUB(pcm_read_ctx, 1, 3)
+ pcm_read(pcm_read_ctx, &buffer[4], 1);
+ memmove(buffer, &buffer[1], 4);
+ }
+ CHECK_DATA_ENOUGH_SUB(pcm_read_ctx, 2, 4)
+ pcm_read(pcm_read_ctx, buffer, 2);
+
+ block_size = (buffer[0] << 8) | buffer[1];
+ CHECK_DATA_ENOUGH_SUB(pcm_read_ctx, block_size, 6)
+ } else {
+ block_size = block_align;
+ CHECK_DATA_ENOUGH_SET(pcm_read_ctx, block_size, 0)
+ }
+
+ if (block_size < 4) {
+ PRINTF("[%s %d]imaadpcm block align not valid: %d\n", __FUNCTION__, __LINE__, block_size);
+ return 0;
+ }
+
+ UsedDataLenSave = pcm_read_ctx->UsedDataLen;
+ tmp = refill(adec_ops, pcm_read_ctx, pwavebuf, block_size);
+ if (tmp < 0) {
+ pcm_read_ctx->UsedDataLen = UsedDataLenSave;
+ return -1;
+ }
+
+ if (tmp != block_size) {
+ PRINTF("[%s %d]imaadpcm: data missalign\n", __FUNCTION__, __LINE__);
+ }
+
+ //Output_Size = ima_adpcm_decode_block((unsigned short *)pcm_buf, pwavebuf, g_mgr.ch, block_size);
+ samples = (block_align - 4 * g_mgr.ch) * 2 + g_mgr.ch;
+ //dump_data(pwavebuf, block_size, "/data/adpcm_in.pcm");
+ adpcmdec_decode_ima_block(g_mgr.ch, samples, pwavebuf, pcm_buf);
+ memcpy(buf, (char*)pcm_buf, 2 * samples);
+ //return Output_Size * 2;
+ return samples * 2;
+}
+
+int runmsadpcmdecoder(audio_decoder_operations_t *adec_ops, pcm_read_ctl_t *pcm_read_ctx, unsigned char *buf, int len)
+{
+ short *pcm_buf = (short*)wave_decoder_buffer[1].addr;
+ int Output_Size = 0;
+ unsigned tmp = 0;
+ char buffer[5];
+ unsigned block_size = 0;
+ int UsedDataLenSave = 0;
+ if (!block_align) {
+ CHECK_DATA_ENOUGH_SET(pcm_read_ctx, 4, 0)
+ pcm_read(pcm_read_ctx, buffer, 4);
+ while (1) {
+ if ((buffer[0] == 0x11) && (buffer[1] == 0x22) && (buffer[2] == 0x33) && (buffer[3] == 0x44)) { //sync word
+ break;
+ }
+ CHECK_DATA_ENOUGH_SUB(pcm_read_ctx, 1, 3)
+ pcm_read(pcm_read_ctx, &buffer[4], 1);
+ memmove(buffer, &buffer[1], 4);
+ }
+
+ CHECK_DATA_ENOUGH_SUB(pcm_read_ctx, 2, 4)
+ pcm_read(pcm_read_ctx, buffer, 2);
+ block_size = (buffer[0] << 8) | buffer[1];
+ CHECK_DATA_ENOUGH_SUB(pcm_read_ctx, block_size, 6)
+ } else {
+ block_size = block_align;
+ CHECK_DATA_ENOUGH_SET(pcm_read_ctx, block_size, 0)
+ }
+
+ if (block_size < 4) {
+ PRINTF("[%s %d]msadpcm block align not valid: %d\n", __FUNCTION__, __LINE__, block_size);
+ return 0;
+ }
+
+ UsedDataLenSave = pcm_read_ctx->UsedDataLen;
+ tmp = refill(adec_ops, pcm_read_ctx, pwavebuf, block_size);
+ if (tmp < 0) {
+ pcm_read_ctx->UsedDataLen = UsedDataLenSave;
+ return -1;
+
+ }
+ if (tmp != block_size) {
+ PRINTF("[%s %d]msadpcm: data missalign\n", __FUNCTION__, __LINE__);
+ }
+
+ Output_Size = ms_adpcm_decode_block(pcm_buf, pwavebuf, g_mgr.ch, block_size);
+ Output_Size = Output_Size - Output_Size % g_mgr.ch;
+ memcpy(buf, (char*)pcm_buf, 2 * Output_Size);
+ return Output_Size * 2;
+
+}
+
+
+enum SampleFormat {
+ SAMPLE_FMT_NONE = -1,
+ SAMPLE_FMT_U8, ///< unsigned 8 bits
+ SAMPLE_FMT_S16, ///< signed 16 bits
+ SAMPLE_FMT_S32, ///< signed 32 bits
+ SAMPLE_FMT_FLT, ///< float
+ SAMPLE_FMT_DBL, ///< double
+ SAMPLE_FMT_NB ///< Number of sample formats. DO NOT USE if dynamically linking to libavcodec
+};
+
+int runpcmdecoder(audio_decoder_operations_t *adec_ops, pcm_read_ctl_t *pcm_read_ctx, unsigned char *buf, int len)
+{
+ int i/*, j*/;
+ short *pcm_buf = (short*)wave_decoder_buffer[1].addr;
+ int tmp = 0;
+ offset = 0;
+ if (g_mgr.bps == SAMPLE_FMT_U8) {
+ tmp = refill(adec_ops, pcm_read_ctx, pwavebuf, WAVE_BLOCK_SIZE);
+ if (tmp < 0) {
+ return -1;
+ }
+ for (i = 0; i < tmp;) {
+ pcm_buf[i] = (pwavebuf[i] - 0x80) << 8;
+ i++;
+ pcm_buf[i] = (pwavebuf[i] - 0x80) << 8;
+ i++;
+ pcm_buf[i] = (pwavebuf[i] - 0x80) << 8;
+ i++;
+ pcm_buf[i] = (pwavebuf[i] - 0x80) << 8;
+ i++;
+ }
+ return (WAVE_BLOCK_SIZE) * 2;
+ } else {
+ if (refill(adec_ops, pcm_read_ctx, pwavebuf, WAVE_BLOCK_SIZE) < 0) {
+ return -1;
+ };
+ return ((WAVE_BLOCK_SIZE >> 1) * 2);
+ }
+}
+
+static int adpcm_decode_frame(audio_decoder_operations_t *adec_ops, pcm_read_ctl_t *pcm_read_ctx, unsigned char *buf, int len)
+{
+ int buf_size = 0;
+ pwavebuf = (unsigned char*)wave_decoder_buffer[0].addr;
+
+ switch (adec_ops->nAudioDecoderType) {
+ case CODEC_ID_PCM_ALAW:
+ buf_size = runalawdecoder(adec_ops, pcm_read_ctx, buf, len);
+ break;
+
+ case CODEC_ID_PCM_MULAW:
+ buf_size = runulawdecoder(adec_ops, pcm_read_ctx, buf, len);
+ break;
+
+ case CODEC_ID_ADPCM_IMA_WAV:
+ buf_size = runimaadpcmdecoder(adec_ops, pcm_read_ctx, buf, len);
+ break;
+
+ case CODEC_ID_ADPCM_MS:
+ buf_size = runmsadpcmdecoder(adec_ops, pcm_read_ctx, buf, len);
+ break;
+ default:
+ buf_size = runpcmdecoder(adec_ops, pcm_read_ctx, buf, len);
+ break;
+ }
+ return buf_size;
+}
+
+
+
+int audio_dec_decode(audio_decoder_operations_t *adec_ops, char *outbuf, int *outlen, char *inbuf, int inlen)
+{
+ //ALOGV("[%s:%d] in %p, inlen %d", __func__, __LINE__, inbuf, inlen);
+ pcm_read_ctl_t pcm_read_ctl = {0};
+ pcm_read_init(&pcm_read_ctl, inbuf, inlen);
+
+ *outlen = adpcm_decode_frame(adec_ops, &pcm_read_ctl, outbuf, *outlen);
+ //dump_data(outbuf, *outlen, "/data/adpcm_out.pcm");
+ //ALOGV("[%s:%d] outlen %d. used %d", __func__, __LINE__, *outlen, pcm_read_ctl.UsedDataLen);
+
+ return pcm_read_ctl.UsedDataLen;
+
+}
+int audio_dec_init(audio_decoder_operations_t *adec_ops)
+{
+ ALOGD("\n\n[%s]BuildDate--%s BuildTime--%s", __FUNCTION__, __DATE__, __TIME__);
+ ALOGD("[%s] samplerate/%d channels/%d\n", __FUNCTION__, adec_ops->samplerate, adec_ops->channels);
+
+ wave_decoder_buffer[0].addr = malloc(WAVE_BLOCK_SIZE);
+ if (wave_decoder_buffer[0].addr == 0) {
+ PRINTF("[%s %d]Error: malloc adpcm buffer failed!\n", __FUNCTION__, __LINE__);
+ return -1;
+ }
+ wave_decoder_buffer[0].size = WAVE_BLOCK_SIZE;
+ wave_decoder_buffer[1].addr = malloc(WAVE_BLOCK_SIZE * 1 * 4);
+ if (wave_decoder_buffer[1].addr == 0) {
+ PRINTF("[%s %d]Error: malloc adpcm buffer failed!\n", __FUNCTION__, __LINE__);
+ return -1;
+ }
+ adec_ops->nInBufSize = WAVE_BLOCK_SIZE;
+ adec_ops->nOutBufSize = 0;
+ wave_decoder_buffer[1].size = WAVE_BLOCK_SIZE * 1 * 4; // 2byte, 2ch, compress ratio 4
+ g_mgr.start = 0;
+ g_mgr.size = 0;
+ g_mgr.bps = SAMPLE_FMT_S16;
+ g_mgr.ch = adec_ops->channels;
+ g_mgr.sr = adec_ops->samplerate;
+ g_mgr.wr = 0;
+ g_mgr.last_rd = 0;
+ g_mgr.totalSample = 0;
+ g_mgr.totalSamplePlayed = 0;
+ g_mgr.totalSampleDecoded = 0;
+ g_mgr.last_pts = 0;
+ g_mgr.blk = 0;
+
+ block_align = adec_ops->block_size;//512;
+ wave_timestamplen = 0;
+ ALOGD("[%s %d]block_align/%d codec_id/0x%x\n", __FUNCTION__, __LINE__, block_align, adec_ops->nAudioDecoderType);
+ return 0;
+}
+
+int audio_dec_release(audio_decoder_operations_t *adec_ops)
+{
+ if (wave_decoder_buffer[0].addr) {
+ free(wave_decoder_buffer[0].addr);
+ wave_decoder_buffer[0].addr = 0;
+ wave_decoder_buffer[0].size = 0;
+ }
+ if (wave_decoder_buffer[1].addr) {
+ free(wave_decoder_buffer[1].addr);
+ wave_decoder_buffer[1].addr = 0;
+ wave_decoder_buffer[1].size = 0;
+ }
+ return 0;
+}
+
+int audio_dec_getinfo(audio_decoder_operations_t *adec_ops, void *pAudioInfo)
+{
+ return 0;
+}
+
+