2 * Audio Processing Technology codec for Bluetooth (aptX)
4 * Copyright (C) 2017 Aurelien Jacobs <aurel@gnuage.org>
6 * This file is part of FFmpeg.
8 * FFmpeg is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * FFmpeg is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with FFmpeg; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 #include "libavutil/intreadwrite.h"
27 #include "audio_frame_queue.h"
37 LF, // Low Frequency (0-5.5 kHz)
38 MLF, // Medium-Low Frequency (5.5-11kHz)
39 MHF, // Medium-High Frequency (11-16.5kHz)
40 HF, // High Frequency (16.5-22kHz)
45 #define FILTER_TAPS 16
49 int32_t buffer[2*FILTER_TAPS];
53 FilterSignal outer_filter_signal[NB_FILTERS];
54 FilterSignal inner_filter_signal[NB_FILTERS][NB_FILTERS];
58 int32_t quantized_sample;
59 int32_t quantized_sample_parity_change;
64 int32_t quantization_factor;
65 int32_t factor_select;
66 int32_t reconstructed_difference;
74 int32_t reconstructed_differences[48];
75 int32_t previous_reconstructed_sample;
76 int32_t predicted_difference;
77 int32_t predicted_sample;
81 int32_t codeword_history;
82 int32_t dither_parity;
83 int32_t dither[NB_SUBBANDS];
86 Quantize quantize[NB_SUBBANDS];
87 InvertQuantize invert_quantize[NB_SUBBANDS];
88 Prediction prediction[NB_SUBBANDS];
95 Channel channels[NB_CHANNELS];
100 static const int32_t quantize_intervals_LF[65] = {
101 -9948, 9948, 29860, 49808, 69822, 89926, 110144, 130502,
102 151026, 171738, 192666, 213832, 235264, 256982, 279014, 301384,
103 324118, 347244, 370790, 394782, 419250, 444226, 469742, 495832,
104 522536, 549890, 577936, 606720, 636290, 666700, 698006, 730270,
105 763562, 797958, 833538, 870398, 908640, 948376, 989740, 1032874,
106 1077948, 1125150, 1174700, 1226850, 1281900, 1340196, 1402156, 1468282,
107 1539182, 1615610, 1698514, 1789098, 1888944, 2000168, 2125700, 2269750,
108 2438670, 2642660, 2899462, 3243240, 3746078, 4535138, 5664098, 7102424,
111 static const int32_t invert_quantize_dither_factors_LF[65] = {
112 9948, 9948, 9962, 9988, 10026, 10078, 10142, 10218,
113 10306, 10408, 10520, 10646, 10784, 10934, 11098, 11274,
114 11462, 11664, 11880, 12112, 12358, 12618, 12898, 13194,
115 13510, 13844, 14202, 14582, 14988, 15422, 15884, 16380,
116 16912, 17484, 18098, 18762, 19480, 20258, 21106, 22030,
117 23044, 24158, 25390, 26760, 28290, 30008, 31954, 34172,
118 36728, 39700, 43202, 47382, 52462, 58762, 66770, 77280,
119 91642, 112348, 144452, 199326, 303512, 485546, 643414, 794914,
122 static const int32_t quantize_dither_factors_LF[65] = {
123 0, 4, 7, 10, 13, 16, 19, 22,
124 26, 28, 32, 35, 38, 41, 44, 47,
125 51, 54, 58, 62, 65, 70, 74, 79,
126 84, 90, 95, 102, 109, 116, 124, 133,
127 143, 154, 166, 180, 195, 212, 231, 254,
128 279, 308, 343, 383, 430, 487, 555, 639,
129 743, 876, 1045, 1270, 1575, 2002, 2628, 3591,
130 5177, 8026, 13719, 26047, 45509, 39467, 37875, 51303,
133 static const int16_t quantize_factor_select_offset_LF[65] = {
134 0, -21, -19, -17, -15, -12, -10, -8,
135 -6, -4, -1, 1, 3, 6, 8, 10,
136 13, 15, 18, 20, 23, 26, 29, 31,
137 34, 37, 40, 43, 47, 50, 53, 57,
138 60, 64, 68, 72, 76, 80, 85, 89,
139 94, 99, 105, 110, 116, 123, 129, 136,
140 144, 152, 161, 171, 182, 194, 207, 223,
141 241, 263, 291, 328, 382, 467, 522, 522,
146 static const int32_t quantize_intervals_MLF[9] = {
147 -89806, 89806, 278502, 494338, 759442, 1113112, 1652322, 2720256, 5190186,
149 static const int32_t invert_quantize_dither_factors_MLF[9] = {
150 89806, 89806, 98890, 116946, 148158, 205512, 333698, 734236, 1735696,
152 static const int32_t quantize_dither_factors_MLF[9] = {
153 0, 2271, 4514, 7803, 14339, 32047, 100135, 250365, 0,
155 static const int16_t quantize_factor_select_offset_MLF[9] = {
156 0, -14, 6, 29, 58, 96, 154, 270, 521,
160 static const int32_t quantize_intervals_MHF[3] = {
161 -194080, 194080, 890562,
163 static const int32_t invert_quantize_dither_factors_MHF[3] = {
164 194080, 194080, 502402,
166 static const int32_t quantize_dither_factors_MHF[3] = {
169 static const int16_t quantize_factor_select_offset_MHF[3] = {
174 static const int32_t quantize_intervals_HF[5] = {
175 -163006, 163006, 542708, 1120554, 2669238,
177 static const int32_t invert_quantize_dither_factors_HF[5] = {
178 163006, 163006, 216698, 361148, 1187538,
180 static const int32_t quantize_dither_factors_HF[5] = {
181 0, 13423, 36113, 206598, 0,
183 static const int16_t quantize_factor_select_offset_HF[5] = {
188 static const int32_t hd_quantize_intervals_LF[257] = {
189 -2436, 2436, 7308, 12180, 17054, 21930, 26806, 31686,
190 36566, 41450, 46338, 51230, 56124, 61024, 65928, 70836,
191 75750, 80670, 85598, 90530, 95470, 100418, 105372, 110336,
192 115308, 120288, 125278, 130276, 135286, 140304, 145334, 150374,
193 155426, 160490, 165566, 170654, 175756, 180870, 185998, 191138,
194 196294, 201466, 206650, 211850, 217068, 222300, 227548, 232814,
195 238096, 243396, 248714, 254050, 259406, 264778, 270172, 275584,
196 281018, 286470, 291944, 297440, 302956, 308496, 314056, 319640,
197 325248, 330878, 336532, 342212, 347916, 353644, 359398, 365178,
198 370986, 376820, 382680, 388568, 394486, 400430, 406404, 412408,
199 418442, 424506, 430600, 436726, 442884, 449074, 455298, 461554,
200 467844, 474168, 480528, 486922, 493354, 499820, 506324, 512866,
201 519446, 526064, 532722, 539420, 546160, 552940, 559760, 566624,
202 573532, 580482, 587478, 594520, 601606, 608740, 615920, 623148,
203 630426, 637754, 645132, 652560, 660042, 667576, 675164, 682808,
204 690506, 698262, 706074, 713946, 721876, 729868, 737920, 746036,
205 754216, 762460, 770770, 779148, 787594, 796108, 804694, 813354,
206 822086, 830892, 839774, 848736, 857776, 866896, 876100, 885386,
207 894758, 904218, 913766, 923406, 933138, 942964, 952886, 962908,
208 973030, 983254, 993582, 1004020, 1014566, 1025224, 1035996, 1046886,
209 1057894, 1069026, 1080284, 1091670, 1103186, 1114838, 1126628, 1138558,
210 1150634, 1162858, 1175236, 1187768, 1200462, 1213320, 1226346, 1239548,
211 1252928, 1266490, 1280242, 1294188, 1308334, 1322688, 1337252, 1352034,
212 1367044, 1382284, 1397766, 1413494, 1429478, 1445728, 1462252, 1479058,
213 1496158, 1513562, 1531280, 1549326, 1567710, 1586446, 1605550, 1625034,
214 1644914, 1665208, 1685932, 1707108, 1728754, 1750890, 1773542, 1796732,
215 1820488, 1844840, 1869816, 1895452, 1921780, 1948842, 1976680, 2005338,
216 2034868, 2065322, 2096766, 2129260, 2162880, 2197708, 2233832, 2271352,
217 2310384, 2351050, 2393498, 2437886, 2484404, 2533262, 2584710, 2639036,
218 2696578, 2757738, 2822998, 2892940, 2968278, 3049896, 3138912, 3236760,
219 3345312, 3467068, 3605434, 3765154, 3952904, 4177962, 4452178, 4787134,
220 5187290, 5647128, 6159120, 6720518, 7332904, 8000032, 8726664, 9518152,
223 static const int32_t hd_invert_quantize_dither_factors_LF[257] = {
224 2436, 2436, 2436, 2436, 2438, 2438, 2438, 2440,
225 2442, 2442, 2444, 2446, 2448, 2450, 2454, 2456,
226 2458, 2462, 2464, 2468, 2472, 2476, 2480, 2484,
227 2488, 2492, 2498, 2502, 2506, 2512, 2518, 2524,
228 2528, 2534, 2540, 2548, 2554, 2560, 2568, 2574,
229 2582, 2588, 2596, 2604, 2612, 2620, 2628, 2636,
230 2646, 2654, 2664, 2672, 2682, 2692, 2702, 2712,
231 2722, 2732, 2742, 2752, 2764, 2774, 2786, 2798,
232 2810, 2822, 2834, 2846, 2858, 2870, 2884, 2896,
233 2910, 2924, 2938, 2952, 2966, 2980, 2994, 3010,
234 3024, 3040, 3056, 3070, 3086, 3104, 3120, 3136,
235 3154, 3170, 3188, 3206, 3224, 3242, 3262, 3280,
236 3300, 3320, 3338, 3360, 3380, 3400, 3422, 3442,
237 3464, 3486, 3508, 3532, 3554, 3578, 3602, 3626,
238 3652, 3676, 3702, 3728, 3754, 3780, 3808, 3836,
239 3864, 3892, 3920, 3950, 3980, 4010, 4042, 4074,
240 4106, 4138, 4172, 4206, 4240, 4276, 4312, 4348,
241 4384, 4422, 4460, 4500, 4540, 4580, 4622, 4664,
242 4708, 4752, 4796, 4842, 4890, 4938, 4986, 5036,
243 5086, 5138, 5192, 5246, 5300, 5358, 5416, 5474,
244 5534, 5596, 5660, 5726, 5792, 5860, 5930, 6002,
245 6074, 6150, 6226, 6306, 6388, 6470, 6556, 6644,
246 6736, 6828, 6924, 7022, 7124, 7228, 7336, 7448,
247 7562, 7680, 7802, 7928, 8058, 8192, 8332, 8476,
248 8624, 8780, 8940, 9106, 9278, 9458, 9644, 9840,
249 10042, 10252, 10472, 10702, 10942, 11194, 11458, 11734,
250 12024, 12328, 12648, 12986, 13342, 13720, 14118, 14540,
251 14990, 15466, 15976, 16520, 17102, 17726, 18398, 19124,
252 19908, 20760, 21688, 22702, 23816, 25044, 26404, 27922,
253 29622, 31540, 33720, 36222, 39116, 42502, 46514, 51334,
254 57218, 64536, 73830, 85890, 101860, 123198, 151020, 183936,
255 216220, 243618, 268374, 293022, 319362, 347768, 378864, 412626, 449596,
257 static const int32_t hd_quantize_dither_factors_LF[256] = {
258 0, 0, 0, 1, 0, 0, 1, 1,
259 0, 1, 1, 1, 1, 1, 1, 1,
260 1, 1, 1, 1, 1, 1, 1, 1,
261 1, 2, 1, 1, 2, 2, 2, 1,
262 2, 2, 2, 2, 2, 2, 2, 2,
263 2, 2, 2, 2, 2, 2, 2, 3,
264 2, 3, 2, 3, 3, 3, 3, 3,
265 3, 3, 3, 3, 3, 3, 3, 3,
266 3, 3, 3, 3, 3, 4, 3, 4,
267 4, 4, 4, 4, 4, 4, 4, 4,
268 4, 4, 4, 4, 5, 4, 4, 5,
269 4, 5, 5, 5, 5, 5, 5, 5,
270 5, 5, 6, 5, 5, 6, 5, 6,
271 6, 6, 6, 6, 6, 6, 6, 7,
272 6, 7, 7, 7, 7, 7, 7, 7,
273 7, 7, 8, 8, 8, 8, 8, 8,
274 8, 9, 9, 9, 9, 9, 9, 9,
275 10, 10, 10, 10, 10, 11, 11, 11,
276 11, 11, 12, 12, 12, 12, 13, 13,
277 13, 14, 14, 14, 15, 15, 15, 15,
278 16, 16, 17, 17, 17, 18, 18, 18,
279 19, 19, 20, 21, 21, 22, 22, 23,
280 23, 24, 25, 26, 26, 27, 28, 29,
281 30, 31, 32, 33, 34, 35, 36, 37,
282 39, 40, 42, 43, 45, 47, 49, 51,
283 53, 55, 58, 60, 63, 66, 69, 73,
284 76, 80, 85, 89, 95, 100, 106, 113,
285 119, 128, 136, 146, 156, 168, 182, 196,
286 213, 232, 254, 279, 307, 340, 380, 425,
287 480, 545, 626, 724, 847, 1003, 1205, 1471,
288 1830, 2324, 3015, 3993, 5335, 6956, 8229, 8071,
289 6850, 6189, 6162, 6585, 7102, 7774, 8441, 9243,
291 static const int16_t hd_quantize_factor_select_offset_LF[257] = {
292 0, -22, -21, -21, -20, -20, -19, -19,
293 -18, -18, -17, -17, -16, -16, -15, -14,
294 -14, -13, -13, -12, -12, -11, -11, -10,
295 -10, -9, -9, -8, -7, -7, -6, -6,
296 -5, -5, -4, -4, -3, -3, -2, -1,
297 -1, 0, 0, 1, 1, 2, 2, 3,
298 4, 4, 5, 5, 6, 6, 7, 8,
299 8, 9, 9, 10, 11, 11, 12, 12,
300 13, 14, 14, 15, 15, 16, 17, 17,
301 18, 19, 19, 20, 20, 21, 22, 22,
302 23, 24, 24, 25, 26, 26, 27, 28,
303 28, 29, 30, 30, 31, 32, 33, 33,
304 34, 35, 35, 36, 37, 38, 38, 39,
305 40, 41, 41, 42, 43, 44, 44, 45,
306 46, 47, 48, 48, 49, 50, 51, 52,
307 52, 53, 54, 55, 56, 57, 58, 58,
308 59, 60, 61, 62, 63, 64, 65, 66,
309 67, 68, 69, 69, 70, 71, 72, 73,
310 74, 75, 77, 78, 79, 80, 81, 82,
311 83, 84, 85, 86, 87, 89, 90, 91,
312 92, 93, 94, 96, 97, 98, 99, 101,
313 102, 103, 105, 106, 107, 109, 110, 112,
314 113, 115, 116, 118, 119, 121, 122, 124,
315 125, 127, 129, 130, 132, 134, 136, 137,
316 139, 141, 143, 145, 147, 149, 151, 153,
317 155, 158, 160, 162, 164, 167, 169, 172,
318 174, 177, 180, 182, 185, 188, 191, 194,
319 197, 201, 204, 208, 211, 215, 219, 223,
320 227, 232, 236, 241, 246, 251, 257, 263,
321 269, 275, 283, 290, 298, 307, 317, 327,
322 339, 352, 367, 384, 404, 429, 458, 494,
323 522, 522, 522, 522, 522, 522, 522, 522, 522,
327 static const int32_t hd_quantize_intervals_MLF[33] = {
328 -21236, 21236, 63830, 106798, 150386, 194832, 240376, 287258,
329 335726, 386034, 438460, 493308, 550924, 611696, 676082, 744626,
330 817986, 896968, 982580, 1076118, 1179278, 1294344, 1424504, 1574386,
331 1751090, 1966260, 2240868, 2617662, 3196432, 4176450, 5658260, 7671068,
334 static const int32_t hd_invert_quantize_dither_factors_MLF[33] = {
335 21236, 21236, 21360, 21608, 21978, 22468, 23076, 23806,
336 24660, 25648, 26778, 28070, 29544, 31228, 33158, 35386,
337 37974, 41008, 44606, 48934, 54226, 60840, 69320, 80564,
338 96140, 119032, 155576, 221218, 357552, 622468, 859344, 1153464, 1555840,
340 static const int32_t hd_quantize_dither_factors_MLF[32] = {
341 0, 31, 62, 93, 123, 152, 183, 214,
342 247, 283, 323, 369, 421, 483, 557, 647,
343 759, 900, 1082, 1323, 1654, 2120, 2811, 3894,
344 5723, 9136, 16411, 34084, 66229, 59219, 73530, 100594,
346 static const int16_t hd_quantize_factor_select_offset_MLF[33] = {
347 0, -21, -16, -12, -7, -2, 3, 8,
348 13, 19, 24, 30, 36, 43, 50, 57,
349 65, 74, 83, 93, 104, 117, 131, 147,
350 166, 189, 219, 259, 322, 427, 521, 521, 521,
354 static const int32_t hd_quantize_intervals_MHF[9] = {
355 -95044, 95044, 295844, 528780, 821332, 1226438, 1890540, 3344850, 6450664,
357 static const int32_t hd_invert_quantize_dither_factors_MHF[9] = {
358 95044, 95044, 105754, 127180, 165372, 39736, 424366, 1029946, 2075866,
360 static const int32_t hd_quantize_dither_factors_MHF[8] = {
361 0, 2678, 5357, 9548, -31409, 96158, 151395, 261480,
363 static const int16_t hd_quantize_factor_select_offset_MHF[9] = {
364 0, -17, 5, 30, 62, 105, 177, 334, 518,
368 static const int32_t hd_quantize_intervals_HF[17] = {
369 -45754, 45754, 138496, 234896, 337336, 448310, 570738, 708380,
370 866534, 1053262, 1281958, 1577438, 1993050, 2665984, 3900982, 5902844,
373 static const int32_t hd_invert_quantize_dither_factors_HF[17] = {
374 45754, 45754, 46988, 49412, 53026, 57950, 64478, 73164,
375 84988, 101740, 126958, 168522, 247092, 425842, 809154, 1192708, 1801910,
377 static const int32_t hd_quantize_dither_factors_HF[16] = {
378 0, 309, 606, 904, 1231, 1632, 2172, 2956,
379 4188, 6305, 10391, 19643, 44688, 95828, 95889, 152301,
381 static const int16_t hd_quantize_factor_select_offset_HF[17] = {
382 0, -18, -8, 2, 13, 25, 38, 53,
383 70, 90, 115, 147, 192, 264, 398, 521, 521,
386 typedef const struct {
387 const int32_t *quantize_intervals;
388 const int32_t *invert_quantize_dither_factors;
389 const int32_t *quantize_dither_factors;
390 const int16_t *quantize_factor_select_offset;
393 int32_t prediction_order;
396 static ConstTables tables[2][NB_SUBBANDS] = {
398 [LF] = { quantize_intervals_LF,
399 invert_quantize_dither_factors_LF,
400 quantize_dither_factors_LF,
401 quantize_factor_select_offset_LF,
402 FF_ARRAY_ELEMS(quantize_intervals_LF),
404 [MLF] = { quantize_intervals_MLF,
405 invert_quantize_dither_factors_MLF,
406 quantize_dither_factors_MLF,
407 quantize_factor_select_offset_MLF,
408 FF_ARRAY_ELEMS(quantize_intervals_MLF),
410 [MHF] = { quantize_intervals_MHF,
411 invert_quantize_dither_factors_MHF,
412 quantize_dither_factors_MHF,
413 quantize_factor_select_offset_MHF,
414 FF_ARRAY_ELEMS(quantize_intervals_MHF),
416 [HF] = { quantize_intervals_HF,
417 invert_quantize_dither_factors_HF,
418 quantize_dither_factors_HF,
419 quantize_factor_select_offset_HF,
420 FF_ARRAY_ELEMS(quantize_intervals_HF),
424 [LF] = { hd_quantize_intervals_LF,
425 hd_invert_quantize_dither_factors_LF,
426 hd_quantize_dither_factors_LF,
427 hd_quantize_factor_select_offset_LF,
428 FF_ARRAY_ELEMS(hd_quantize_intervals_LF),
430 [MLF] = { hd_quantize_intervals_MLF,
431 hd_invert_quantize_dither_factors_MLF,
432 hd_quantize_dither_factors_MLF,
433 hd_quantize_factor_select_offset_MLF,
434 FF_ARRAY_ELEMS(hd_quantize_intervals_MLF),
436 [MHF] = { hd_quantize_intervals_MHF,
437 hd_invert_quantize_dither_factors_MHF,
438 hd_quantize_dither_factors_MHF,
439 hd_quantize_factor_select_offset_MHF,
440 FF_ARRAY_ELEMS(hd_quantize_intervals_MHF),
442 [HF] = { hd_quantize_intervals_HF,
443 hd_invert_quantize_dither_factors_HF,
444 hd_quantize_dither_factors_HF,
445 hd_quantize_factor_select_offset_HF,
446 FF_ARRAY_ELEMS(hd_quantize_intervals_HF),
451 static const int16_t quantization_factors[32] = {
452 2048, 2093, 2139, 2186, 2233, 2282, 2332, 2383,
453 2435, 2489, 2543, 2599, 2656, 2714, 2774, 2834,
454 2896, 2960, 3025, 3091, 3158, 3228, 3298, 3371,
455 3444, 3520, 3597, 3676, 3756, 3838, 3922, 4008,
459 /* Rounded right shift with optionnal clipping */
460 #define RSHIFT_SIZE(size) \
462 static int##size##_t rshift##size(int##size##_t value, int shift) \
464 int##size##_t rounding = (int##size##_t)1 << (shift - 1); \
465 int##size##_t mask = ((int##size##_t)1 << (shift + 1)) - 1; \
466 return ((value + rounding) >> shift) - ((value & mask) == rounding); \
469 static int##size##_t rshift##size##_clip24(int##size##_t value, int shift) \
471 return av_clip_intp2(rshift##size(value, shift), 23); \
478 static void aptx_update_codeword_history(Channel *channel)
480 int32_t cw = ((channel->quantize[0].quantized_sample & 3) << 0) +
481 ((channel->quantize[1].quantized_sample & 2) << 1) +
482 ((channel->quantize[2].quantized_sample & 1) << 3);
483 channel->codeword_history = (cw << 8) + ((unsigned)channel->codeword_history << 4);
486 static void aptx_generate_dither(Channel *channel)
492 aptx_update_codeword_history(channel);
494 m = (int64_t)5184443 * (channel->codeword_history >> 7);
495 d = (m * 4) + (m >> 22);
496 for (subband = 0; subband < NB_SUBBANDS; subband++)
497 channel->dither[subband] = (unsigned)d << (23 - 5*subband);
498 channel->dither_parity = (d >> 25) & 1;
502 * Convolution filter coefficients for the outer QMF of the QMF tree.
503 * The 2 sets are a mirror of each other.
505 static const int32_t aptx_qmf_outer_coeffs[NB_FILTERS][FILTER_TAPS] = {
507 730, -413, -9611, 43626, -121026, 269973, -585547, 2801966,
508 697128, -160481, 27611, 8478, -10043, 3511, 688, -897,
511 -897, 688, 3511, -10043, 8478, 27611, -160481, 697128,
512 2801966, -585547, 269973, -121026, 43626, -9611, -413, 730,
517 * Convolution filter coefficients for the inner QMF of the QMF tree.
518 * The 2 sets are a mirror of each other.
520 static const int32_t aptx_qmf_inner_coeffs[NB_FILTERS][FILTER_TAPS] = {
522 1033, -584, -13592, 61697, -171156, 381799, -828088, 3962579,
523 985888, -226954, 39048, 11990, -14203, 4966, 973, -1268,
526 -1268, 973, 4966, -14203, 11990, 39048, -226954, 985888,
527 3962579, -828088, 381799, -171156, 61697, -13592, -584, 1033,
532 * Push one sample into a circular signal buffer.
535 static void aptx_qmf_filter_signal_push(FilterSignal *signal, int32_t sample)
537 signal->buffer[signal->pos ] = sample;
538 signal->buffer[signal->pos+FILTER_TAPS] = sample;
539 signal->pos = (signal->pos + 1) & (FILTER_TAPS - 1);
543 * Compute the convolution of the signal with the coefficients, and reduce
544 * to 24 bits by applying the specified right shifting.
547 static int32_t aptx_qmf_convolution(FilterSignal *signal,
548 const int32_t coeffs[FILTER_TAPS],
551 int32_t *sig = &signal->buffer[signal->pos];
555 for (i = 0; i < FILTER_TAPS; i++)
556 e += MUL64(sig[i], coeffs[i]);
558 return rshift64_clip24(e, shift);
562 * Half-band QMF analysis filter realized with a polyphase FIR filter.
563 * Split into 2 subbands and downsample by 2.
564 * So for each pair of samples that goes in, one sample goes out,
565 * split into 2 separate subbands.
568 static void aptx_qmf_polyphase_analysis(FilterSignal signal[NB_FILTERS],
569 const int32_t coeffs[NB_FILTERS][FILTER_TAPS],
571 int32_t samples[NB_FILTERS],
572 int32_t *low_subband_output,
573 int32_t *high_subband_output)
575 int32_t subbands[NB_FILTERS];
578 for (i = 0; i < NB_FILTERS; i++) {
579 aptx_qmf_filter_signal_push(&signal[i], samples[NB_FILTERS-1-i]);
580 subbands[i] = aptx_qmf_convolution(&signal[i], coeffs[i], shift);
583 *low_subband_output = av_clip_intp2(subbands[0] + subbands[1], 23);
584 *high_subband_output = av_clip_intp2(subbands[0] - subbands[1], 23);
588 * Two stage QMF analysis tree.
589 * Split 4 input samples into 4 subbands and downsample by 4.
590 * So for each group of 4 samples that goes in, one sample goes out,
591 * split into 4 separate subbands.
593 static void aptx_qmf_tree_analysis(QMFAnalysis *qmf,
595 int32_t subband_samples[4])
597 int32_t intermediate_samples[4];
600 /* Split 4 input samples into 2 intermediate subbands downsampled to 2 samples */
601 for (i = 0; i < 2; i++)
602 aptx_qmf_polyphase_analysis(qmf->outer_filter_signal,
603 aptx_qmf_outer_coeffs, 23,
605 &intermediate_samples[0+i],
606 &intermediate_samples[2+i]);
608 /* Split 2 intermediate subband samples into 4 final subbands downsampled to 1 sample */
609 for (i = 0; i < 2; i++)
610 aptx_qmf_polyphase_analysis(qmf->inner_filter_signal[i],
611 aptx_qmf_inner_coeffs, 23,
612 &intermediate_samples[2*i],
613 &subband_samples[2*i+0],
614 &subband_samples[2*i+1]);
618 * Half-band QMF synthesis filter realized with a polyphase FIR filter.
619 * Join 2 subbands and upsample by 2.
620 * So for each 2 subbands sample that goes in, a pair of samples goes out.
623 static void aptx_qmf_polyphase_synthesis(FilterSignal signal[NB_FILTERS],
624 const int32_t coeffs[NB_FILTERS][FILTER_TAPS],
626 int32_t low_subband_input,
627 int32_t high_subband_input,
628 int32_t samples[NB_FILTERS])
630 int32_t subbands[NB_FILTERS];
633 subbands[0] = low_subband_input + high_subband_input;
634 subbands[1] = low_subband_input - high_subband_input;
636 for (i = 0; i < NB_FILTERS; i++) {
637 aptx_qmf_filter_signal_push(&signal[i], subbands[1-i]);
638 samples[i] = aptx_qmf_convolution(&signal[i], coeffs[i], shift);
643 * Two stage QMF synthesis tree.
644 * Join 4 subbands and upsample by 4.
645 * So for each 4 subbands sample that goes in, a group of 4 samples goes out.
647 static void aptx_qmf_tree_synthesis(QMFAnalysis *qmf,
648 int32_t subband_samples[4],
651 int32_t intermediate_samples[4];
654 /* Join 4 subbands into 2 intermediate subbands upsampled to 2 samples. */
655 for (i = 0; i < 2; i++)
656 aptx_qmf_polyphase_synthesis(qmf->inner_filter_signal[i],
657 aptx_qmf_inner_coeffs, 22,
658 subband_samples[2*i+0],
659 subband_samples[2*i+1],
660 &intermediate_samples[2*i]);
662 /* Join 2 samples from intermediate subbands upsampled to 4 samples. */
663 for (i = 0; i < 2; i++)
664 aptx_qmf_polyphase_synthesis(qmf->outer_filter_signal,
665 aptx_qmf_outer_coeffs, 21,
666 intermediate_samples[0+i],
667 intermediate_samples[2+i],
673 static int32_t aptx_bin_search(int32_t value, int32_t factor,
674 const int32_t *intervals, int32_t nb_intervals)
679 for (i = nb_intervals >> 1; i > 0; i >>= 1)
680 if (MUL64(factor, intervals[idx + i]) <= ((int64_t)value << 24))
686 static void aptx_quantize_difference(Quantize *quantize,
687 int32_t sample_difference,
689 int32_t quantization_factor,
692 const int32_t *intervals = tables->quantize_intervals;
693 int32_t quantized_sample, dithered_sample, parity_change;
694 int32_t d, mean, interval, inv, sample_difference_abs;
697 sample_difference_abs = FFABS(sample_difference);
698 sample_difference_abs = FFMIN(sample_difference_abs, (1 << 23) - 1);
700 quantized_sample = aptx_bin_search(sample_difference_abs >> 4,
702 intervals, tables->tables_size);
704 d = rshift32_clip24(MULH(dither, dither), 7) - (1 << 23);
705 d = rshift64(MUL64(d, tables->quantize_dither_factors[quantized_sample]), 23);
707 intervals += quantized_sample;
708 mean = (intervals[1] + intervals[0]) / 2;
709 interval = (intervals[1] - intervals[0]) * (-(sample_difference < 0) | 1);
711 dithered_sample = rshift64_clip24(MUL64(dither, interval) + ((int64_t)av_clip_intp2(mean + d, 23) << 32), 32);
712 error = ((int64_t)sample_difference_abs << 20) - MUL64(dithered_sample, quantization_factor);
713 quantize->error = FFABS(rshift64(error, 23));
715 parity_change = quantized_sample;
721 inv = -(sample_difference < 0);
722 quantize->quantized_sample = quantized_sample ^ inv;
723 quantize->quantized_sample_parity_change = parity_change ^ inv;
726 static void aptx_encode_channel(Channel *channel, int32_t samples[4], int hd)
728 int32_t subband_samples[4];
730 aptx_qmf_tree_analysis(&channel->qmf, samples, subband_samples);
731 aptx_generate_dither(channel);
732 for (subband = 0; subband < NB_SUBBANDS; subband++) {
733 int32_t diff = av_clip_intp2(subband_samples[subband] - channel->prediction[subband].predicted_sample, 23);
734 aptx_quantize_difference(&channel->quantize[subband], diff,
735 channel->dither[subband],
736 channel->invert_quantize[subband].quantization_factor,
737 &tables[hd][subband]);
741 static void aptx_decode_channel(Channel *channel, int32_t samples[4])
743 int32_t subband_samples[4];
745 for (subband = 0; subband < NB_SUBBANDS; subband++)
746 subband_samples[subband] = channel->prediction[subband].previous_reconstructed_sample;
747 aptx_qmf_tree_synthesis(&channel->qmf, subband_samples, samples);
751 static void aptx_invert_quantization(InvertQuantize *invert_quantize,
752 int32_t quantized_sample, int32_t dither,
755 int32_t qr, idx, shift, factor_select;
757 idx = (quantized_sample ^ -(quantized_sample < 0)) + 1;
758 qr = tables->quantize_intervals[idx] / 2;
759 if (quantized_sample < 0)
762 qr = rshift64_clip24((qr * (1LL<<32)) + MUL64(dither, tables->invert_quantize_dither_factors[idx]), 32);
763 invert_quantize->reconstructed_difference = MUL64(invert_quantize->quantization_factor, qr) >> 19;
765 /* update factor_select */
766 factor_select = 32620 * invert_quantize->factor_select;
767 factor_select = rshift32(factor_select + (tables->quantize_factor_select_offset[idx] * (1 << 15)), 15);
768 invert_quantize->factor_select = av_clip(factor_select, 0, tables->factor_max);
770 /* update quantization factor */
771 idx = (invert_quantize->factor_select & 0xFF) >> 3;
772 shift = (tables->factor_max - invert_quantize->factor_select) >> 8;
773 invert_quantize->quantization_factor = (quantization_factors[idx] << 11) >> shift;
776 static int32_t *aptx_reconstructed_differences_update(Prediction *prediction,
777 int32_t reconstructed_difference,
780 int32_t *rd1 = prediction->reconstructed_differences, *rd2 = rd1 + order;
781 int p = prediction->pos;
784 prediction->pos = p = (p + 1) % order;
785 rd2[p] = reconstructed_difference;
789 static void aptx_prediction_filtering(Prediction *prediction,
790 int32_t reconstructed_difference,
793 int32_t reconstructed_sample, predictor, srd0;
794 int32_t *reconstructed_differences;
795 int64_t predicted_difference = 0;
798 reconstructed_sample = av_clip_intp2(reconstructed_difference + prediction->predicted_sample, 23);
799 predictor = av_clip_intp2((MUL64(prediction->s_weight[0], prediction->previous_reconstructed_sample)
800 + MUL64(prediction->s_weight[1], reconstructed_sample)) >> 22, 23);
801 prediction->previous_reconstructed_sample = reconstructed_sample;
803 reconstructed_differences = aptx_reconstructed_differences_update(prediction, reconstructed_difference, order);
804 srd0 = FFDIFFSIGN(reconstructed_difference, 0) * (1 << 23);
805 for (i = 0; i < order; i++) {
806 int32_t srd = FF_SIGNBIT(reconstructed_differences[-i-1]) | 1;
807 prediction->d_weight[i] -= rshift32(prediction->d_weight[i] - srd*srd0, 8);
808 predicted_difference += MUL64(reconstructed_differences[-i], prediction->d_weight[i]);
811 prediction->predicted_difference = av_clip_intp2(predicted_difference >> 22, 23);
812 prediction->predicted_sample = av_clip_intp2(predictor + prediction->predicted_difference, 23);
815 static void aptx_process_subband(InvertQuantize *invert_quantize,
816 Prediction *prediction,
817 int32_t quantized_sample, int32_t dither,
820 int32_t sign, same_sign[2], weight[2], sw1, range;
822 aptx_invert_quantization(invert_quantize, quantized_sample, dither, tables);
824 sign = FFDIFFSIGN(invert_quantize->reconstructed_difference,
825 -prediction->predicted_difference);
826 same_sign[0] = sign * prediction->prev_sign[0];
827 same_sign[1] = sign * prediction->prev_sign[1];
828 prediction->prev_sign[0] = prediction->prev_sign[1];
829 prediction->prev_sign[1] = sign | 1;
832 sw1 = rshift32(-same_sign[1] * prediction->s_weight[1], 1);
833 sw1 = (av_clip(sw1, -range, range) & ~0xF) * 16;
836 weight[0] = 254 * prediction->s_weight[0] + 0x800000*same_sign[0] + sw1;
837 prediction->s_weight[0] = av_clip(rshift32(weight[0], 8), -range, range);
839 range = 0x3C0000 - prediction->s_weight[0];
840 weight[1] = 255 * prediction->s_weight[1] + 0xC00000*same_sign[1];
841 prediction->s_weight[1] = av_clip(rshift32(weight[1], 8), -range, range);
843 aptx_prediction_filtering(prediction,
844 invert_quantize->reconstructed_difference,
845 tables->prediction_order);
848 static void aptx_invert_quantize_and_prediction(Channel *channel, int hd)
851 for (subband = 0; subband < NB_SUBBANDS; subband++)
852 aptx_process_subband(&channel->invert_quantize[subband],
853 &channel->prediction[subband],
854 channel->quantize[subband].quantized_sample,
855 channel->dither[subband],
856 &tables[hd][subband]);
859 static int32_t aptx_quantized_parity(Channel *channel)
861 int32_t parity = channel->dither_parity;
864 for (subband = 0; subband < NB_SUBBANDS; subband++)
865 parity ^= channel->quantize[subband].quantized_sample;
870 /* For each sample, ensure that the parity of all subbands of all channels
871 * is 0 except once every 8 samples where the parity is forced to 1. */
872 static int aptx_check_parity(Channel channels[NB_CHANNELS], int32_t *idx)
874 int32_t parity = aptx_quantized_parity(&channels[LEFT])
875 ^ aptx_quantized_parity(&channels[RIGHT]);
877 int eighth = *idx == 7;
878 *idx = (*idx + 1) & 7;
880 return parity ^ eighth;
883 static void aptx_insert_sync(Channel channels[NB_CHANNELS], int32_t *idx)
885 if (aptx_check_parity(channels, idx)) {
888 static const int map[] = { 1, 2, 0, 3 };
889 Quantize *min = &channels[NB_CHANNELS-1].quantize[map[0]];
890 for (c = &channels[NB_CHANNELS-1]; c >= channels; c--)
891 for (i = 0; i < NB_SUBBANDS; i++)
892 if (c->quantize[map[i]].error < min->error)
893 min = &c->quantize[map[i]];
895 /* Forcing the desired parity is done by offsetting by 1 the quantized
896 * sample from the subband featuring the smallest quantization error. */
897 min->quantized_sample = min->quantized_sample_parity_change;
901 static uint16_t aptx_pack_codeword(Channel *channel)
903 int32_t parity = aptx_quantized_parity(channel);
904 return (((channel->quantize[3].quantized_sample & 0x06) | parity) << 13)
905 | (((channel->quantize[2].quantized_sample & 0x03) ) << 11)
906 | (((channel->quantize[1].quantized_sample & 0x0F) ) << 7)
907 | (((channel->quantize[0].quantized_sample & 0x7F) ) << 0);
910 static uint32_t aptxhd_pack_codeword(Channel *channel)
912 int32_t parity = aptx_quantized_parity(channel);
913 return (((channel->quantize[3].quantized_sample & 0x01E) | parity) << 19)
914 | (((channel->quantize[2].quantized_sample & 0x00F) ) << 15)
915 | (((channel->quantize[1].quantized_sample & 0x03F) ) << 9)
916 | (((channel->quantize[0].quantized_sample & 0x1FF) ) << 0);
919 static void aptx_unpack_codeword(Channel *channel, uint16_t codeword)
921 channel->quantize[0].quantized_sample = sign_extend(codeword >> 0, 7);
922 channel->quantize[1].quantized_sample = sign_extend(codeword >> 7, 4);
923 channel->quantize[2].quantized_sample = sign_extend(codeword >> 11, 2);
924 channel->quantize[3].quantized_sample = sign_extend(codeword >> 13, 3);
925 channel->quantize[3].quantized_sample = (channel->quantize[3].quantized_sample & ~1)
926 | aptx_quantized_parity(channel);
929 static void aptxhd_unpack_codeword(Channel *channel, uint32_t codeword)
931 channel->quantize[0].quantized_sample = sign_extend(codeword >> 0, 9);
932 channel->quantize[1].quantized_sample = sign_extend(codeword >> 9, 6);
933 channel->quantize[2].quantized_sample = sign_extend(codeword >> 15, 4);
934 channel->quantize[3].quantized_sample = sign_extend(codeword >> 19, 5);
935 channel->quantize[3].quantized_sample = (channel->quantize[3].quantized_sample & ~1)
936 | aptx_quantized_parity(channel);
939 static void aptx_encode_samples(AptXContext *ctx,
940 int32_t samples[NB_CHANNELS][4],
944 for (channel = 0; channel < NB_CHANNELS; channel++)
945 aptx_encode_channel(&ctx->channels[channel], samples[channel], ctx->hd);
947 aptx_insert_sync(ctx->channels, &ctx->sync_idx);
949 for (channel = 0; channel < NB_CHANNELS; channel++) {
950 aptx_invert_quantize_and_prediction(&ctx->channels[channel], ctx->hd);
952 AV_WB24(output + 3*channel,
953 aptxhd_pack_codeword(&ctx->channels[channel]));
955 AV_WB16(output + 2*channel,
956 aptx_pack_codeword(&ctx->channels[channel]));
960 static int aptx_decode_samples(AptXContext *ctx,
961 const uint8_t *input,
962 int32_t samples[NB_CHANNELS][4])
966 for (channel = 0; channel < NB_CHANNELS; channel++) {
967 aptx_generate_dither(&ctx->channels[channel]);
970 aptxhd_unpack_codeword(&ctx->channels[channel],
971 AV_RB24(input + 3*channel));
973 aptx_unpack_codeword(&ctx->channels[channel],
974 AV_RB16(input + 2*channel));
975 aptx_invert_quantize_and_prediction(&ctx->channels[channel], ctx->hd);
978 ret = aptx_check_parity(ctx->channels, &ctx->sync_idx);
980 for (channel = 0; channel < NB_CHANNELS; channel++)
981 aptx_decode_channel(&ctx->channels[channel], samples[channel]);
987 static av_cold int aptx_init(AVCodecContext *avctx)
989 AptXContext *s = avctx->priv_data;
992 if (avctx->channels != 2)
993 return AVERROR_INVALIDDATA;
995 s->hd = avctx->codec->id == AV_CODEC_ID_APTX_HD;
996 s->block_size = s->hd ? 6 : 4;
998 if (avctx->frame_size == 0)
999 avctx->frame_size = 256 * s->block_size;
1001 if (avctx->frame_size % s->block_size) {
1002 av_log(avctx, AV_LOG_ERROR,
1003 "Frame size must be a multiple of %d samples\n", s->block_size);
1004 return AVERROR(EINVAL);
1007 for (chan = 0; chan < NB_CHANNELS; chan++) {
1008 Channel *channel = &s->channels[chan];
1009 for (subband = 0; subband < NB_SUBBANDS; subband++) {
1010 Prediction *prediction = &channel->prediction[subband];
1011 prediction->prev_sign[0] = 1;
1012 prediction->prev_sign[1] = 1;
1016 ff_af_queue_init(avctx, &s->afq);
1020 static int aptx_decode_frame(AVCodecContext *avctx, void *data,
1021 int *got_frame_ptr, AVPacket *avpkt)
1023 AptXContext *s = avctx->priv_data;
1024 AVFrame *frame = data;
1025 int pos, opos, channel, sample, ret;
1027 if (avpkt->size < s->block_size) {
1028 av_log(avctx, AV_LOG_ERROR, "Packet is too small\n");
1029 return AVERROR_INVALIDDATA;
1032 /* get output buffer */
1033 frame->channels = NB_CHANNELS;
1034 frame->format = AV_SAMPLE_FMT_S32P;
1035 frame->nb_samples = 4 * avpkt->size / s->block_size;
1036 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)
1039 for (pos = 0, opos = 0; opos < frame->nb_samples; pos += s->block_size, opos += 4) {
1040 int32_t samples[NB_CHANNELS][4];
1042 if (aptx_decode_samples(s, &avpkt->data[pos], samples)) {
1043 av_log(avctx, AV_LOG_ERROR, "Synchronization error\n");
1044 return AVERROR_INVALIDDATA;
1047 for (channel = 0; channel < NB_CHANNELS; channel++)
1048 for (sample = 0; sample < 4; sample++)
1049 AV_WN32A(&frame->data[channel][4*(opos+sample)],
1050 samples[channel][sample] * 256);
1054 return s->block_size * frame->nb_samples / 4;
1057 static int aptx_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
1058 const AVFrame *frame, int *got_packet_ptr)
1060 AptXContext *s = avctx->priv_data;
1061 int pos, ipos, channel, sample, output_size, ret;
1063 if ((ret = ff_af_queue_add(&s->afq, frame)) < 0)
1066 output_size = s->block_size * frame->nb_samples/4;
1067 if ((ret = ff_alloc_packet2(avctx, avpkt, output_size, 0)) < 0)
1070 for (pos = 0, ipos = 0; pos < output_size; pos += s->block_size, ipos += 4) {
1071 int32_t samples[NB_CHANNELS][4];
1073 for (channel = 0; channel < NB_CHANNELS; channel++)
1074 for (sample = 0; sample < 4; sample++)
1075 samples[channel][sample] = (int32_t)AV_RN32A(&frame->data[channel][4*(ipos+sample)]) >> 8;
1077 aptx_encode_samples(s, samples, avpkt->data + pos);
1080 ff_af_queue_remove(&s->afq, frame->nb_samples, &avpkt->pts, &avpkt->duration);
1081 *got_packet_ptr = 1;
1085 static av_cold int aptx_close(AVCodecContext *avctx)
1087 AptXContext *s = avctx->priv_data;
1088 ff_af_queue_close(&s->afq);
1093 #if CONFIG_APTX_DECODER
1094 AVCodec ff_aptx_decoder = {
1096 .long_name = NULL_IF_CONFIG_SMALL("aptX (Audio Processing Technology for Bluetooth)"),
1097 .type = AVMEDIA_TYPE_AUDIO,
1098 .id = AV_CODEC_ID_APTX,
1099 .priv_data_size = sizeof(AptXContext),
1101 .decode = aptx_decode_frame,
1102 .close = aptx_close,
1103 .capabilities = AV_CODEC_CAP_DR1,
1104 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1105 .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_STEREO, 0},
1106 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
1107 AV_SAMPLE_FMT_NONE },
1111 #if CONFIG_APTX_HD_DECODER
1112 AVCodec ff_aptx_hd_decoder = {
1114 .long_name = NULL_IF_CONFIG_SMALL("aptX HD (Audio Processing Technology for Bluetooth)"),
1115 .type = AVMEDIA_TYPE_AUDIO,
1116 .id = AV_CODEC_ID_APTX_HD,
1117 .priv_data_size = sizeof(AptXContext),
1119 .decode = aptx_decode_frame,
1120 .close = aptx_close,
1121 .capabilities = AV_CODEC_CAP_DR1,
1122 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1123 .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_STEREO, 0},
1124 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
1125 AV_SAMPLE_FMT_NONE },
1129 #if CONFIG_APTX_ENCODER
1130 AVCodec ff_aptx_encoder = {
1132 .long_name = NULL_IF_CONFIG_SMALL("aptX (Audio Processing Technology for Bluetooth)"),
1133 .type = AVMEDIA_TYPE_AUDIO,
1134 .id = AV_CODEC_ID_APTX,
1135 .priv_data_size = sizeof(AptXContext),
1137 .encode2 = aptx_encode_frame,
1138 .close = aptx_close,
1139 .capabilities = AV_CODEC_CAP_SMALL_LAST_FRAME,
1140 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1141 .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_STEREO, 0},
1142 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
1143 AV_SAMPLE_FMT_NONE },
1144 .supported_samplerates = (const int[]) {8000, 16000, 24000, 32000, 44100, 48000, 0},
1148 #if CONFIG_APTX_HD_ENCODER
1149 AVCodec ff_aptx_hd_encoder = {
1151 .long_name = NULL_IF_CONFIG_SMALL("aptX HD (Audio Processing Technology for Bluetooth)"),
1152 .type = AVMEDIA_TYPE_AUDIO,
1153 .id = AV_CODEC_ID_APTX_HD,
1154 .priv_data_size = sizeof(AptXContext),
1156 .encode2 = aptx_encode_frame,
1157 .close = aptx_close,
1158 .capabilities = AV_CODEC_CAP_SMALL_LAST_FRAME,
1159 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1160 .channel_layouts = (const uint64_t[]) { AV_CH_LAYOUT_STEREO, 0},
1161 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_S32P,
1162 AV_SAMPLE_FMT_NONE },
1163 .supported_samplerates = (const int[]) {8000, 16000, 24000, 32000, 44100, 48000, 0},