1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
|
/**
* Copyright (C) 2022 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "aptXbtenc.h"
#include "AptxEncoder.h"
#include "AptxParameters.h"
#include "AptxTables.h"
#include "CodewordPacker.h"
#include "SyncInserter.h"
#include "swversion.h"
typedef struct aptxbtenc_t {
/* m_endian should either be 0 (little endian) or 8 (big endian). */
int32_t m_endian;
/* m_sync_mode is an enumerated type and will be
0 (stereo sync),
1 (for dual mono sync), or
2 (for dual channel with no autosync).
*/
int32_t m_sync_mode;
/* Autosync inserter & Checker for use with the stereo aptX codec. */
/* The current phase of the sync word insertion (7 down to 0) */
uint32_t m_syncWordPhase;
/* Stereo channel aptX encoder (annotated to produce Kalimba test vectors
* for it's I/O. This will process valid PCM from a WAV file). */
/* Each Encoder_data structure requires 1592 bytes */
Encoder_data m_encoderData[2];
Qmf_storage m_qmf_l;
Qmf_storage m_qmf_r;
} aptxbtenc;
/* Log to linear lookup table used in inverse quantiser*/
/* Size of Table: 32*4 = 128 bytes */
static const int32_t IQuant_tableLogT[32] = {
16384 * 256, 16744 * 256, 17112 * 256, 17488 * 256, 17864 * 256,
18256 * 256, 18656 * 256, 19064 * 256, 19480 * 256, 19912 * 256,
20344 * 256, 20792 * 256, 21248 * 256, 21712 * 256, 22192 * 256,
22672 * 256, 23168 * 256, 23680 * 256, 24200 * 256, 24728 * 256,
25264 * 256, 25824 * 256, 26384 * 256, 26968 * 256, 27552 * 256,
28160 * 256, 28776 * 256, 29408 * 256, 30048 * 256, 30704 * 256,
31376 * 256, 32064 * 256};
static void clearmem(void* mem, int32_t sz) {
int8_t* m = (int8_t*)mem;
int32_t i = 0;
for (; i < sz; i++) {
*m = 0;
m++;
}
}
APTXBTENCEXPORT int SizeofAptxbtenc(void) { return (sizeof(aptxbtenc)); }
APTXBTENCEXPORT const char* aptxbtenc_version() { return (swversion); }
APTXBTENCEXPORT int aptxbtenc_init(void* _state, short endian) {
aptxbtenc* state = (aptxbtenc*)_state;
int32_t j = 0;
int32_t k;
int32_t t;
clearmem(_state, sizeof(aptxbtenc));
if (state == 0) {
return 1;
}
state->m_syncWordPhase = 7L;
if (endian == 0) {
state->m_endian = 0;
} else {
state->m_endian = 8;
}
/* default setting should be stereo autosync,
for backwards-compatibility with legacy applications that use this library */
state->m_sync_mode = stereo;
for (j = 0; j < 2; j++) {
Encoder_data* encode_dat = &state->m_encoderData[j];
uint32_t i;
/* Create a quantiser and subband processor for each subband */
for (i = LL; i <= HH; i++) {
encode_dat->m_codewordHistory = 0L;
encode_dat->m_qdata[i].thresholdTablePtr =
subbandParameters[i].threshTable;
encode_dat->m_qdata[i].thresholdTablePtr_sl1 =
subbandParameters[i].threshTable_sl1;
encode_dat->m_qdata[i].ditherTablePtr = subbandParameters[i].dithTable;
encode_dat->m_qdata[i].minusLambdaDTable =
subbandParameters[i].minusLambdaDTable;
encode_dat->m_qdata[i].codeBits = subbandParameters[i].numBits;
encode_dat->m_qdata[i].qCode = 0L;
encode_dat->m_qdata[i].altQcode = 0L;
encode_dat->m_qdata[i].distPenalty = 0L;
/* initialisation of inverseQuantiser data */
encode_dat->m_SubbandData[i].m_iqdata.thresholdTablePtr =
subbandParameters[i].threshTable;
encode_dat->m_SubbandData[i].m_iqdata.thresholdTablePtr_sl1 =
subbandParameters[i].threshTable_sl1;
encode_dat->m_SubbandData[i].m_iqdata.ditherTablePtr_sf1 =
subbandParameters[i].dithTable_sh1;
encode_dat->m_SubbandData[i].m_iqdata.incrTablePtr =
subbandParameters[i].incrTable;
encode_dat->m_SubbandData[i].m_iqdata.maxLogDelta =
subbandParameters[i].maxLogDelta;
encode_dat->m_SubbandData[i].m_iqdata.minLogDelta =
subbandParameters[i].minLogDelta;
encode_dat->m_SubbandData[i].m_iqdata.delta = 0;
encode_dat->m_SubbandData[i].m_iqdata.logDelta = 0;
encode_dat->m_SubbandData[i].m_iqdata.invQ = 0;
encode_dat->m_SubbandData[i].m_iqdata.iquantTableLogPtr =
&IQuant_tableLogT[0];
// Initializing data for predictor filter
encode_dat->m_SubbandData[i].m_predData.m_zeroDelayLine.modulo =
subbandParameters[i].numZeros;
for (t = 0; t < 48; t++) {
encode_dat->m_SubbandData[i].m_predData.m_zeroDelayLine.buffer[t] = 0;
}
encode_dat->m_SubbandData[i].m_predData.m_zeroDelayLine.pointer = 0;
/* Initialise the previous zero filter output and predictor output to zero
*/
encode_dat->m_SubbandData[i].m_predData.m_zeroVal = 0L;
encode_dat->m_SubbandData[i].m_predData.m_predVal = 0L;
encode_dat->m_SubbandData[i].m_predData.m_numZeros =
subbandParameters[i].numZeros;
/* Initialise the contents of the pole data delay line to zero */
encode_dat->m_SubbandData[i].m_predData.m_poleDelayLine[0] = 0L;
encode_dat->m_SubbandData[i].m_predData.m_poleDelayLine[1] = 0L;
for (k = 0; k < 24; k++) {
encode_dat->m_SubbandData[i].m_ZeroCoeffData.m_zeroCoeff[k] = 0;
}
// Initializing data for zerocoeff update function.
encode_dat->m_SubbandData[i].m_ZeroCoeffData.m_numZeros =
subbandParameters[i].numZeros;
/* Initializing data for PoleCoeff Update function.
* Fill the adaptation delay line with +1 initially */
encode_dat->m_SubbandData[i].m_PoleCoeffData.m_poleAdaptDelayLine.s32 =
0x00010001;
/* Zero the pole coefficients */
encode_dat->m_SubbandData[i].m_PoleCoeffData.m_poleCoeff[0] = 0L;
encode_dat->m_SubbandData[i].m_PoleCoeffData.m_poleCoeff[1] = 0L;
}
}
return 0;
}
APTXBTENCEXPORT int aptxbtenc_setsync_mode(void* _state, int32_t sync_mode) {
aptxbtenc* state = (aptxbtenc*)_state;
state->m_sync_mode = sync_mode;
return 0;
}
APTXBTENCEXPORT int aptxbtenc_encodestereo(void* _state, void* _pcmL,
void* _pcmR, void* _buffer) {
aptxbtenc* state = (aptxbtenc*)_state;
int32_t* pcmL = (int32_t*)_pcmL;
int32_t* pcmR = (int32_t*)_pcmR;
int16_t* buffer = (int16_t*)_buffer;
int16_t tmp_reg;
int16_t tmp_out;
// Feed the PCM to the dual aptX encoders
aptxEncode(pcmL, &state->m_qmf_l, &state->m_encoderData[0]);
aptxEncode(pcmR, &state->m_qmf_r, &state->m_encoderData[1]);
// only insert sync information if we are not in non-autosync mode.
// The Non-autosync mode changes only take effect in the packCodeword()
// function.
if (state->m_sync_mode != no_sync) {
if (state->m_sync_mode == stereo) {
// Insert the autosync information into the stereo quantised codes
xbtEncinsertSync(&state->m_encoderData[0], &state->m_encoderData[1],
&state->m_syncWordPhase);
} else {
// Insert the autosync information into the two individual mono quantised
// codes
xbtEncinsertSyncDualMono(&state->m_encoderData[0],
&state->m_encoderData[1],
&state->m_syncWordPhase);
}
}
aptxPostEncode(&state->m_encoderData[0]);
aptxPostEncode(&state->m_encoderData[1]);
// Pack the (possibly adjusted) codes into a 16-bit codeword per channel
tmp_reg = packCodeword(&state->m_encoderData[0], state->m_sync_mode);
// Swap bytes to output data in big-endian as expected by bc5 code...
tmp_out = tmp_reg >> state->m_endian;
tmp_out |= tmp_reg << state->m_endian;
buffer[0] = tmp_out;
tmp_reg = packCodeword(&state->m_encoderData[1], state->m_sync_mode);
// Swap bytes to output data in big-endian as expected by bc5 code...
tmp_out = tmp_reg >> state->m_endian;
tmp_out |= tmp_reg << state->m_endian;
buffer[1] = tmp_out;
return 0;
}
|
