FFmpeg: libavcodec/qdmc.c Source File

FFmpeg

[フレーム]

libavcodec

qdmc.c

Go to the documentation of this file.

1 /*

2 * QDMC compatible decoder

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

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

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 #include <math.h>

23 #include <stddef.h>

25 #define BITSTREAM_READER_LE

27 #include "libavutil/channel_layout.h"

28 #include "libavutil/mem_internal.h"

29 #include "libavutil/thread.h"

30 #include "libavutil/tx.h"

32 #include "avcodec.h"

33 #include "bytestream.h"

34 #include "codec_internal.h"

35 #include "decode.h"

36 #include "get_bits.h"

38 typedef struct QDMCTone {

39 uint8_t mode;

40 uint8_t phase;

41 uint8_t offset;

42 int16_t freq;

43 int16_t amplitude;

44 } QDMCTone;

46 typedef struct QDMCContext {

47 AVCodecContext *avctx;

49 uint8_t frame_bits;

50 int band_index;

51 int frame_size;

52 int subframe_size;

53 int fft_offset;

54 int buffer_offset;

55 int nb_channels;

56 int checksum_size;

58 uint8_t noise[2][19][17];

59 QDMCTone tones[5][8192];

60 int nb_tones[5];

61 int cur_tone[5];

62 float alt_sin[5][31];

63 float fft_buffer[4][8192 * 2];

64 float noise2_buffer[4096 * 2];

65 float noise_buffer[4096 * 2];

66 float buffer[2 * 32768];

67 float *buffer_ptr;

68 int rndval;

70 DECLARE_ALIGNED(32, AVComplexFloat, cmplx_in)[2][512];

71 DECLARE_ALIGNED(32, AVComplexFloat, cmplx_out)[2][512];

72 AVTXContext *fft_ctx;

73 av_tx_fn itx_fn;

74 } QDMCContext;

76 static float sin_table[512];

77 static VLC vtable[6];

79 static const unsigned code_prefix[] = {

80 0x0, 0x1, 0x2, 0x3, 0x4, 0x6, 0x8, 0xA,

81 0xC, 0x10, 0x14, 0x18, 0x1C, 0x24, 0x2C, 0x34,

82 0x3C, 0x4C, 0x5C, 0x6C, 0x7C, 0x9C, 0xBC, 0xDC,

83 0xFC, 0x13C, 0x17C, 0x1BC, 0x1FC, 0x27C, 0x2FC, 0x37C,

84 0x3FC, 0x4FC, 0x5FC, 0x6FC, 0x7FC, 0x9FC, 0xBFC, 0xDFC,

85 0xFFC, 0x13FC, 0x17FC, 0x1BFC, 0x1FFC, 0x27FC, 0x2FFC, 0x37FC,

86 0x3FFC, 0x4FFC, 0x5FFC, 0x6FFC, 0x7FFC, 0x9FFC, 0xBFFC, 0xDFFC,

87 0xFFFC, 0x13FFC, 0x17FFC, 0x1BFFC, 0x1FFFC, 0x27FFC, 0x2FFFC, 0x37FFC,

88 0x3FFFC

89 };

91 static const float amplitude_tab[64] = {

92 1.18750000f, 1.68359380f, 2.37500000f, 3.36718750f, 4.75000000f,

93 6.73437500f, 9.50000000f, 13.4687500f, 19.0000000f, 26.9375000f,

94 38.0000000f, 53.8750000f, 76.0000000f, 107.750000f, 152.000000f,

95 215.500000f, 304.000000f, 431.000000f, 608.000000f, 862.000000f,

96 1216.00000f, 1724.00000f, 2432.00000f, 3448.00000f, 4864.00000f,

97 6896.00000f, 9728.00000f, 13792.0000f, 19456.0000f, 27584.0000f,

98 38912.0000f, 55168.0000f, 77824.0000f, 110336.000f, 155648.000f,

99 220672.000f, 311296.000f, 441344.000f, 622592.000f, 882688.000f,

100 1245184.00f, 1765376.00f, 2490368.00f, 3530752.00f, 4980736.00f,

101 7061504.00f, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

102 };

103

104 static const uint16_t qdmc_nodes[112] = {

105 0, 1, 2, 4, 6, 8, 12, 16, 24, 32, 48, 56, 64,

106 80, 96, 120, 144, 176, 208, 240, 256,

107 0, 2, 4, 8, 16, 24, 32, 48, 56, 64, 80, 104,

108 128, 160, 208, 256, 0, 0, 0, 0, 0,

109 0, 2, 4, 8, 16, 32, 48, 64, 80, 112, 160, 208,

110 256, 0, 0, 0, 0, 0, 0, 0, 0,

111 0, 4, 8, 16, 32, 48, 64, 96, 144, 208, 256,

112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

113 0, 4, 16, 32, 64, 256, 0, 0, 0, 0, 0, 0, 0, 0,

114 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0

115 };

116

117 static const uint8_t noise_bands_size[] = {

118 19, 14, 11, 9, 4, 2, 0

119 };

120

121 static const uint8_t noise_bands_selector[] = {

122 4, 3, 2, 1, 0, 0, 0,

123 };

124

125 static const uint8_t qdmc_hufftab[][2] = {

126 /* Noise value - 27 entries */

127 { 1, 2 }, { 10, 7 }, { 26, 9 }, { 22, 9 }, { 24, 9 }, { 14, 9 },

128 { 8, 6 }, { 6, 5 }, { 7, 5 }, { 9, 7 }, { 30, 9 }, { 32, 10 },

129 { 13, 10 }, { 20, 9 }, { 28, 9 }, { 12, 7 }, { 15, 11 }, { 36, 12 },

130 { 0, 12 }, { 34, 10 }, { 18, 9 }, { 11, 9 }, { 16, 9 }, { 5, 3 },

131 { 2, 3 }, { 4, 3 }, { 3, 2 },

132 /* Noise segment length - 12 entries */

133 { 1, 1 }, { 2, 2 }, { 3, 4 }, { 8, 9 }, { 9, 10 }, { 0, 10 },

134 { 13, 8 }, { 7, 7 }, { 6, 6 }, { 17, 5 }, { 4, 4 }, { 5, 4 },

135 /* Amplitude - 28 entries */

136 { 18, 3 }, { 16, 3 }, { 22, 7 }, { 8, 10 }, { 4, 10 }, { 3, 9 },

137 { 2, 8 }, { 23, 8 }, { 10, 8 }, { 11, 7 }, { 21, 5 }, { 20, 4 },

138 { 1, 7 }, { 7, 10 }, { 5, 10 }, { 9, 9 }, { 6, 10 }, { 25, 11 },

139 { 26, 12 }, { 27, 13 }, { 0, 13 }, { 24, 9 }, { 12, 6 }, { 13, 5 },

140 { 14, 4 }, { 19, 3 }, { 15, 3 }, { 17, 2 },

141 /* Frequency differences - 47 entries */

142 { 2, 4 }, { 14, 6 }, { 26, 7 }, { 31, 8 }, { 32, 9 }, { 35, 9 },

143 { 7, 5 }, { 10, 5 }, { 22, 7 }, { 27, 7 }, { 19, 7 }, { 20, 7 },

144 { 4, 5 }, { 13, 5 }, { 17, 6 }, { 15, 6 }, { 8, 5 }, { 5, 4 },

145 { 28, 7 }, { 33, 9 }, { 36, 11 }, { 38, 12 }, { 42, 14 }, { 45, 16 },

146 { 44, 18 }, { 0, 18 }, { 46, 17 }, { 43, 15 }, { 40, 13 }, { 37, 11 },

147 { 39, 12 }, { 41, 12 }, { 34, 8 }, { 16, 6 }, { 11, 5 }, { 9, 4 },

148 { 1, 2 }, { 3, 4 }, { 30, 7 }, { 29, 7 }, { 23, 6 }, { 24, 6 },

149 { 18, 6 }, { 6, 4 }, { 12, 5 }, { 21, 6 }, { 25, 6 },

150 /* Amplitude differences - 9 entries */

151 { 1, 2 }, { 3, 3 }, { 4, 4 }, { 5, 5 }, { 6, 6 }, { 7, 7 },

152 { 8, 8 }, { 0, 8 }, { 2, 1 },

153 /* Phase differences - 9 entries */

154 { 2, 2 }, { 1, 2 }, { 3, 4 }, { 7, 4 }, { 6, 5 }, { 5, 6 },

155 { 0, 6 }, { 4, 4 }, { 8, 2 },

156 };

157

158 static const uint8_t huff_sizes[] = {

159 27, 12, 28, 47, 9, 9

160 };

161

162 static const uint8_t huff_bits[] = {

163 12, 10, 12, 12, 8, 6

164 };

165

166 static av_cold void qdmc_init_static_data(void)

167 {

168 const uint8_t (*hufftab)[2] = qdmc_hufftab;

169 int i;

170

171 for (unsigned i = 0, offset = 0; i < FF_ARRAY_ELEMS(vtable); i++) {

172 static VLCElem vlc_buffer[13698];

173 vtable[i].table = &vlc_buffer[offset];

174 vtable[i].table_allocated = FF_ARRAY_ELEMS(vlc_buffer) - offset;

175 ff_vlc_init_from_lengths(&vtable[i], huff_bits[i], huff_sizes[i],

176 &hufftab[0][1], 2, &hufftab[0][0], 2, 1, -1,

177 VLC_INIT_LE | VLC_INIT_STATIC_OVERLONG, NULL);

178 hufftab += huff_sizes[i];

179 offset += vtable[i].table_size;

180 }

181

182 for (i = 0; i < 512; i++)

183 sin_table[i] = sin(2.0f * i * M_PI * 0.001953125f);

184 }

185

186 static void make_noises(QDMCContext *s)

187 {

188 int i, j, n0, n1, n2, diff;

189 float *nptr;

190

191 for (j = 0; j < noise_bands_size[s->band_index]; j++) {

192 n0 = qdmc_nodes[j + 21 * s->band_index ];

193 n1 = qdmc_nodes[j + 21 * s->band_index + 1];

194 n2 = qdmc_nodes[j + 21 * s->band_index + 2];

195 nptr = s->noise_buffer + 256 * j;

196

197 for (i = 0; i + n0 < n1; i++, nptr++)

198 nptr[0] = i / (float)(n1 - n0);

199

200 diff = n2 - n1;

201 nptr = s->noise_buffer + (j << 8) + n1 - n0;

202

203 for (i = n1; i < n2; i++, nptr++, diff--)

204 nptr[0] = diff / (float)(n2 - n1);

205 }

206 }

207

208 static av_cold int qdmc_decode_init(AVCodecContext *avctx)

209 {

210 static AVOnce init_static_once = AV_ONCE_INIT;

211 QDMCContext *s = avctx->priv_data;

212 int ret, fft_size, fft_order, size, g, j, x;

213 float scale = 1.f;

214 GetByteContext b;

215

216 ff_thread_once(&init_static_once, qdmc_init_static_data);

217

218 if (!avctx->extradata || (avctx->extradata_size < 48)) {

219 av_log(avctx, AV_LOG_ERROR, "extradata missing or truncated\n");

220 return AVERROR_INVALIDDATA;

221 }

222

223 bytestream2_init(&b, avctx->extradata, avctx->extradata_size);

224

225 while (bytestream2_get_bytes_left(&b) > 8) {

226 if (bytestream2_peek_be64(&b) == (((uint64_t)MKBETAG('f','r','m','a') << 32) |

227 (uint64_t)MKBETAG('Q','D','M','C')))

228 break;

229 bytestream2_skipu(&b, 1);

230 }

231 bytestream2_skipu(&b, 8);

232

233 if (bytestream2_get_bytes_left(&b) < 36) {

234 av_log(avctx, AV_LOG_ERROR, "not enough extradata (%i)\n",

235 bytestream2_get_bytes_left(&b));

236 return AVERROR_INVALIDDATA;

237 }

238

239 size = bytestream2_get_be32u(&b);

240 if (size > bytestream2_get_bytes_left(&b)) {

241 av_log(avctx, AV_LOG_ERROR, "extradata size too small, %i < %i\n",

242 bytestream2_get_bytes_left(&b), size);

243 return AVERROR_INVALIDDATA;

244 }

245

246 if (bytestream2_get_be32u(&b) != MKBETAG('Q','D','C','A')) {

247 av_log(avctx, AV_LOG_ERROR, "invalid extradata, expecting QDCA\n");

248 return AVERROR_INVALIDDATA;

249 }

250 bytestream2_skipu(&b, 4);

251

252 s->nb_channels = bytestream2_get_be32u(&b);

253 if (s->nb_channels <= 0 || s->nb_channels > 2) {

254 av_log(avctx, AV_LOG_ERROR, "invalid number of channels\n");

255 return AVERROR_INVALIDDATA;

256 }

257 av_channel_layout_uninit(&avctx->ch_layout);

258 avctx->ch_layout = s->nb_channels == 2 ? (AVChannelLayout)AV_CHANNEL_LAYOUT_STEREO :

259 (AVChannelLayout)AV_CHANNEL_LAYOUT_MONO;

260

261 avctx->sample_rate = bytestream2_get_be32u(&b);

262 avctx->bit_rate = bytestream2_get_be32u(&b);

263 bytestream2_skipu(&b, 4);

264 fft_size = bytestream2_get_be32u(&b);

265 fft_order = av_log2(fft_size) + 1;

266 s->checksum_size = bytestream2_get_be32u(&b);

267 if (s->checksum_size >= 1U << 28) {

268 av_log(avctx, AV_LOG_ERROR, "data block size too large (%u)\n", s->checksum_size);

269 return AVERROR_INVALIDDATA;

270 }

271

272 if (avctx->sample_rate >= 32000) {

273 x = 28000;

274 s->frame_bits = 13;

275 } else if (avctx->sample_rate >= 16000) {

276 x = 20000;

277 s->frame_bits = 12;

278 } else {

279 x = 16000;

280 s->frame_bits = 11;

281 }

282 s->frame_size = 1 << s->frame_bits;

283 s->subframe_size = s->frame_size >> 5;

284

285 if (avctx->ch_layout.nb_channels == 2)

286 x = 3 * x / 2;

287 s->band_index = noise_bands_selector[FFMIN(6, llrint(floor(avctx->bit_rate * 3.0 / (double)x + 0.5)))];

288

289 if ((fft_order < 7) || (fft_order > 9)) {

290 avpriv_request_sample(avctx, "Unknown FFT order %d", fft_order);

291 return AVERROR_PATCHWELCOME;

292 }

293

294 if (fft_size != (1 << (fft_order - 1))) {

295 av_log(avctx, AV_LOG_ERROR, "FFT size %d not power of 2.\n", fft_size);

296 return AVERROR_INVALIDDATA;

297 }

298

299 ret = av_tx_init(&s->fft_ctx, &s->itx_fn, AV_TX_FLOAT_FFT, 1, 1 << fft_order, &scale, 0);

300 if (ret < 0)

301 return ret;

302

303 avctx->sample_fmt = AV_SAMPLE_FMT_S16;

304

305 for (g = 5; g > 0; g--) {

306 for (j = 0; j < (1 << g) - 1; j++)

307 s->alt_sin[5-g][j] = sin_table[(((j+1) << (8 - g)) & 0x1FF)];

308 }

309

310 make_noises(s);

311

312 return 0;

313 }

314

315 static av_cold int qdmc_decode_close(AVCodecContext *avctx)

316 {

317 QDMCContext *s = avctx->priv_data;

318

319 av_tx_uninit(&s->fft_ctx);

320

321 return 0;

322 }

323

324 static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)

325 {

326 int v;

327

328 if (get_bits_left(gb) < 1)

329 return AVERROR_INVALIDDATA;

330 v = get_vlc2(gb, table->table, table->bits, 2);

331 if (v < 0)

332 v = get_bits(gb, get_bits(gb, 3) + 1);

333

334 if (flag) {

335 if (v >= FF_ARRAY_ELEMS(code_prefix))

336 return AVERROR_INVALIDDATA;

337

338 v = code_prefix[v] + get_bitsz(gb, v >> 2);

339 }

340

341 return v;

342 }

343

344 static int skip_label(QDMCContext *s, GetBitContext *gb)

345 {

346 uint32_t label = get_bits_long(gb, 32);

347 uint16_t sum = 226, checksum = get_bits(gb, 16);

348 const uint8_t *ptr = gb->buffer + 6;

349 int i;

350

351 if (label != MKTAG('Q', 'M', 'C', 1))

352 return AVERROR_INVALIDDATA;

353

354 for (i = 0; i < s->checksum_size - 6; i++)

355 sum += ptr[i];

356

357 return sum != checksum;

358 }

359

360 static int read_noise_data(QDMCContext *s, GetBitContext *gb)

361 {

362 int ch, j, k, v, idx, band, lastval, newval, len;

363

364 for (ch = 0; ch < s->nb_channels; ch++) {

365 for (band = 0; band < noise_bands_size[s->band_index]; band++) {

366 v = qdmc_get_vlc(gb, &vtable[0], 0);

367 if (v < 0)

368 return AVERROR_INVALIDDATA;

369

370 if (v & 1)

371 v = v + 1;

372 else

373 v = -v;

374

375 lastval = v / 2;

376 s->noise[ch][band][0] = lastval - 1;

377 for (j = 0; j < 15;) {

378 len = qdmc_get_vlc(gb, &vtable[1], 1);

379 if (len < 0)

380 return AVERROR_INVALIDDATA;

381 len += 1;

382

383 v = qdmc_get_vlc(gb, &vtable[0], 0);

384 if (v < 0)

385 return AVERROR_INVALIDDATA;

386

387 if (v & 1)

388 newval = lastval + (v + 1) / 2;

389 else

390 newval = lastval - v / 2;

391

392 idx = j + 1;

393 if (len + idx > 16)

394 return AVERROR_INVALIDDATA;

395

396 for (k = 1; idx <= j + len; k++, idx++)

397 s->noise[ch][band][idx] = lastval + k * (newval - lastval) / len - 1;

398

399 lastval = newval;

400 j += len;

401 }

402 }

403 }

404

405 return 0;

406 }

407

408 static void add_tone(QDMCContext *s, int group, int offset, int freq, int stereo_mode, int amplitude, int phase)

409 {

410 const int index = s->nb_tones[group];

411

412 if (index >= FF_ARRAY_ELEMS(s->tones[group])) {

413 av_log(s->avctx, AV_LOG_WARNING, "Too many tones already in buffer, ignoring tone!\n");

414 return;

415 }

416

417 s->tones[group][index].offset = offset;

418 s->tones[group][index].freq = freq;

419 s->tones[group][index].mode = stereo_mode;

420 s->tones[group][index].amplitude = amplitude;

421 s->tones[group][index].phase = phase;

422 s->nb_tones[group]++;

423 }

424

425 static int read_wave_data(QDMCContext *s, GetBitContext *gb)

426 {

427 int amp, phase, stereo_mode = 0, i, group, freq, group_size, group_bits;

428 int amp2, phase2, pos2, off;

429

430 for (group = 0; group < 5; group++) {

431 group_size = 1 << (s->frame_bits - group - 1);

432 group_bits = 4 - group;

433 pos2 = 0;

434 off = 0;

435

436 for (i = 1; ; i = freq + 1) {

437 int v;

438

439 v = qdmc_get_vlc(gb, &vtable[3], 1);

440 if (v < 0)

441 return AVERROR_INVALIDDATA;

442

443 freq = i + v;

444 while (freq >= group_size - 1) {

445 freq += 2 - group_size;

446 pos2 += group_size;

447 off += 1 << group_bits;

448 }

449

450 if (pos2 >= s->frame_size)

451 break;

452

453 if (s->nb_channels > 1)

454 stereo_mode = get_bits(gb, 2);

455

456 amp = qdmc_get_vlc(gb, &vtable[2], 0);

457 if (amp < 0)

458 return AVERROR_INVALIDDATA;

459 phase = get_bits(gb, 3);

460

461 if (stereo_mode > 1) {

462 amp2 = qdmc_get_vlc(gb, &vtable[4], 0);

463 if (amp2 < 0)

464 return AVERROR_INVALIDDATA;

465 amp2 = amp - amp2;

466

467 phase2 = qdmc_get_vlc(gb, &vtable[5], 0);

468 if (phase2 < 0)

469 return AVERROR_INVALIDDATA;

470 phase2 = phase - phase2;

471

472 if (phase2 < 0)

473 phase2 += 8;

474 }

475

476 if ((freq >> group_bits) + 1 < s->subframe_size) {

477 add_tone(s, group, off, freq, stereo_mode & 1, amp, phase);

478 if (stereo_mode > 1)

479 add_tone(s, group, off, freq, ~stereo_mode & 1, amp2, phase2);

480 }

481 }

482 }

483

484 return 0;

485 }

486

487 static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)

488 {

489 int subframe_size, i, j, k, length;

490 float scale, *noise_ptr;

491

492 scale = 0.5 * amplitude;

493 subframe_size = s->subframe_size;

494 if (subframe_size >= node2)

495 subframe_size = node2;

496 length = (subframe_size - node1) & 0xFFFC;

497 j = node1;

498 noise_ptr = &s->noise_buffer[256 * index];

499

500 for (i = 0; i < length; i += 4, j+= 4, noise_ptr += 4) {

501 s->noise2_buffer[j ] += scale * noise_ptr[0];

502 s->noise2_buffer[j + 1] += scale * noise_ptr[1];

503 s->noise2_buffer[j + 2] += scale * noise_ptr[2];

504 s->noise2_buffer[j + 3] += scale * noise_ptr[3];

505 }

506

507 k = length + node1;

508 noise_ptr = s->noise_buffer + length + (index << 8);

509 for (i = length; i < subframe_size - node1; i++, k++, noise_ptr++)

510 s->noise2_buffer[k] += scale * noise_ptr[0];

511 }

512

513 static void add_noise(QDMCContext *s, int ch, int current_subframe)

514 {

515 int i, j, aindex;

516 float amplitude;

517 float *im = &s->fft_buffer[0 + ch][s->fft_offset + s->subframe_size * current_subframe];

518 float *re = &s->fft_buffer[2 + ch][s->fft_offset + s->subframe_size * current_subframe];

519

520 memset(s->noise2_buffer, 0, 4 * s->subframe_size);

521

522 for (i = 0; i < noise_bands_size[s->band_index]; i++) {

523 if (qdmc_nodes[i + 21 * s->band_index] > s->subframe_size - 1)

524 break;

525

526 aindex = s->noise[ch][i][current_subframe / 2];

527 amplitude = aindex > 0 ? amplitude_tab[aindex & 0x3F] : 0.0f;

528

529 lin_calc(s, amplitude, qdmc_nodes[21 * s->band_index + i],

530 qdmc_nodes[21 * s->band_index + i + 2], i);

531 }

532

533 for (j = 2; j < s->subframe_size - 1; j++) {

534 float rnd_re, rnd_im;

535

536 s->rndval = 214013U * s->rndval + 2531011;

537 rnd_im = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];

538 s->rndval = 214013U * s->rndval + 2531011;

539 rnd_re = ((s->rndval & 0x7FFF) - 16384.0f) * 0.000030517578f * s->noise2_buffer[j];

540 im[j ] += rnd_im;

541 re[j ] += rnd_re;

542 im[j+1] -= rnd_im;

543 re[j+1] -= rnd_re;

544 }

545 }

546

547 static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)

548 {

549 int j, group_bits, pos, pindex;

550 float im, re, amplitude, level, *imptr, *reptr;

551

552 if (s->nb_channels == 1)

553 stereo_mode = 0;

554

555 group_bits = 4 - group;

556 pos = freqs >> (4 - group);

557 amplitude = amplitude_tab[amp & 0x3F];

558 imptr = &s->fft_buffer[ stereo_mode][s->fft_offset + s->subframe_size * offset + pos];

559 reptr = &s->fft_buffer[2 + stereo_mode][s->fft_offset + s->subframe_size * offset + pos];

560 pindex = (phase << 6) - ((2 * (freqs >> (4 - group)) + 1) << 7);

561 for (j = 0; j < (1 << (group_bits + 1)) - 1; j++) {

562 pindex += (2 * freqs + 1) << (7 - group_bits);

563 level = amplitude * s->alt_sin[group][j];

564 im = level * sin_table[ pindex & 0x1FF];

565 re = level * sin_table[(pindex + 128) & 0x1FF];

566 imptr[0] += im;

567 imptr[1] -= im;

568 reptr[0] += re;

569 reptr[1] -= re;

570 imptr += s->subframe_size;

571 reptr += s->subframe_size;

572 if (imptr >= &s->fft_buffer[stereo_mode][2 * s->frame_size]) {

573 imptr = &s->fft_buffer[0 + stereo_mode][pos];

574 reptr = &s->fft_buffer[2 + stereo_mode][pos];

575 }

576 }

577 }

578

579 static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)

580 {

581 float level, im, re;

582 int pos;

583

584 if (s->nb_channels == 1)

585 stereo_mode = 0;

586

587 level = amplitude_tab[amp & 0x3F];

588 im = level * sin_table[ (phase << 6) & 0x1FF];

589 re = level * sin_table[((phase << 6) + 128) & 0x1FF];

590 pos = s->fft_offset + freqs + s->subframe_size * offset;

591 s->fft_buffer[ stereo_mode][pos ] += im;

592 s->fft_buffer[2 + stereo_mode][pos ] += re;

593 s->fft_buffer[ stereo_mode][pos + 1] -= im;

594 s->fft_buffer[2 + stereo_mode][pos + 1] -= re;

595 }

596

597 static void add_waves(QDMCContext *s, int current_subframe)

598 {

599 int w, g;

600

601 for (g = 0; g < 4; g++) {

602 for (w = s->cur_tone[g]; w < s->nb_tones[g]; w++) {

603 QDMCTone *t = &s->tones[g][w];

604

605 if (current_subframe < t->offset)

606 break;

607 add_wave(s, t->offset, t->freq, g, t->mode, t->amplitude, t->phase);

608 }

609 s->cur_tone[g] = w;

610 }

611 for (w = s->cur_tone[4]; w < s->nb_tones[4]; w++) {

612 QDMCTone *t = &s->tones[4][w];

613

614 if (current_subframe < t->offset)

615 break;

616 add_wave0(s, t->offset, t->freq, t->mode, t->amplitude, t->phase);

617 }

618 s->cur_tone[4] = w;

619 }

620

621 static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)

622 {

623 int ret, ch, i, n;

624

625 if (skip_label(s, gb))

626 return AVERROR_INVALIDDATA;

627

628 s->fft_offset = s->frame_size - s->fft_offset;

629 s->buffer_ptr = &s->buffer[s->nb_channels * s->buffer_offset];

630

631 ret = read_noise_data(s, gb);

632 if (ret < 0)

633 return ret;

634

635 ret = read_wave_data(s, gb);

636 if (ret < 0)

637 return ret;

638

639 for (n = 0; n < 32; n++) {

640 float *r;

641

642 for (ch = 0; ch < s->nb_channels; ch++)

643 add_noise(s, ch, n);

644

645 add_waves(s, n);

646

647 for (ch = 0; ch < s->nb_channels; ch++) {

648 for (i = 0; i < s->subframe_size; i++) {

649 s->cmplx_in[ch][i].re = s->fft_buffer[ch + 2][s->fft_offset + n * s->subframe_size + i];

650 s->cmplx_in[ch][i].im = s->fft_buffer[ch + 0][s->fft_offset + n * s->subframe_size + i];

651 s->cmplx_in[ch][s->subframe_size + i].re = 0;

652 s->cmplx_in[ch][s->subframe_size + i].im = 0;

653 }

654 }

655

656 for (ch = 0; ch < s->nb_channels; ch++) {

657 s->itx_fn(s->fft_ctx, s->cmplx_out[ch], s->cmplx_in[ch], sizeof(float));

658 }

659

660 r = &s->buffer_ptr[s->nb_channels * n * s->subframe_size];

661 for (i = 0; i < 2 * s->subframe_size; i++) {

662 for (ch = 0; ch < s->nb_channels; ch++) {

663 *r++ += s->cmplx_out[ch][i].re;

664 }

665 }

666

667 r = &s->buffer_ptr[n * s->subframe_size * s->nb_channels];

668 for (i = 0; i < s->nb_channels * s->subframe_size; i++) {

669 out[i] = av_clipf(r[i], INT16_MIN, INT16_MAX);

670 }

671 out += s->subframe_size * s->nb_channels;

672

673 for (ch = 0; ch < s->nb_channels; ch++) {

674 memset(s->fft_buffer[ch+0] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);

675 memset(s->fft_buffer[ch+2] + s->fft_offset + n * s->subframe_size, 0, 4 * s->subframe_size);

676 }

677 memset(s->buffer + s->nb_channels * (n * s->subframe_size + s->frame_size + s->buffer_offset), 0, 4 * s->subframe_size * s->nb_channels);

678 }

679

680 s->buffer_offset += s->frame_size;

681 if (s->buffer_offset >= 32768 - s->frame_size) {

682 memcpy(s->buffer, &s->buffer[s->nb_channels * s->buffer_offset], 4 * s->frame_size * s->nb_channels);

683 s->buffer_offset = 0;

684 }

685

686 return 0;

687 }

688

689 static av_cold void qdmc_flush(AVCodecContext *avctx)

690 {

691 QDMCContext *s = avctx->priv_data;

692

693 memset(s->buffer, 0, sizeof(s->buffer));

694 memset(s->fft_buffer, 0, sizeof(s->fft_buffer));

695 s->fft_offset = 0;

696 s->buffer_offset = 0;

697 }

698

699 static int qdmc_decode_frame(AVCodecContext *avctx, AVFrame *frame,

700 int *got_frame_ptr, AVPacket *avpkt)

701 {

702 QDMCContext *s = avctx->priv_data;

703 GetBitContext gb;

704 int ret;

705

706 if (!avpkt->data)

707 return 0;

708 if (avpkt->size < s->checksum_size)

709 return AVERROR_INVALIDDATA;

710

711 s->avctx = avctx;

712 frame->nb_samples = s->frame_size;

713 if ((ret = ff_get_buffer(avctx, frame, 0)) < 0)

714 return ret;

715

716 if ((ret = init_get_bits8(&gb, avpkt->data, s->checksum_size)) < 0)

717 return ret;

718

719 memset(s->nb_tones, 0, sizeof(s->nb_tones));

720 memset(s->cur_tone, 0, sizeof(s->cur_tone));

721

722 ret = decode_frame(s, &gb, (int16_t *)frame->data[0]);

723 if (ret >= 0) {

724 *got_frame_ptr = 1;

725 return s->checksum_size;

726 }

727 qdmc_flush(avctx);

728 return ret;

729 }

730

731 const FFCodec ff_qdmc_decoder = {

732 .p.name = "qdmc",

733 CODEC_LONG_NAME("QDesign Music Codec 1"),

734 .p.type = AVMEDIA_TYPE_AUDIO,

735 .p.id = AV_CODEC_ID_QDMC,

736 .priv_data_size = sizeof(QDMCContext),

737 .init = qdmc_decode_init,

738 .close = qdmc_decode_close,

739 FF_CODEC_DECODE_CB(qdmc_decode_frame),

740 .flush = qdmc_flush,

741 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_CHANNEL_CONF,

742 };

add_waves

static void add_waves(QDMCContext *s, int current_subframe)

Definition: qdmc.c:597

make_noises

static void make_noises(QDMCContext *s)

Definition: qdmc.c:186

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:186

ff_vlc_init_from_lengths

int ff_vlc_init_from_lengths(VLC *vlc, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)

Build VLC decoding tables suitable for use with get_vlc2()

Definition: vlc.c:306

level

uint8_t level

Definition: svq3.c:205

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:695

const char * r

Definition: vf_curves.c:127

mem_internal.h

QDMCContext::fft_buffer

float fft_buffer[4][8192 *2]

Definition: qdmc.c:63

out

FILE * out

Definition: movenc.c:55

AV_CHANNEL_LAYOUT_STEREO

#define AV_CHANNEL_LAYOUT_STEREO

Definition: channel_layout.h:387

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1056

GetByteContext

Definition: bytestream.h:33

QDMCContext::cmplx_out

AVComplexFloat cmplx_out[2][512]

Definition: qdmc.c:71

QDMCContext::nb_channels

int nb_channels

Definition: qdmc.c:55

thread.h

skip_label

static int skip_label(QDMCContext *s, GetBitContext *gb)

Definition: qdmc.c:344

AVTXContext

Definition: tx_priv.h:235

get_bits_long

static unsigned int get_bits_long(GetBitContext *s, int n)

Read 0-32 bits.

Definition: get_bits.h:421

noise_bands_selector

static const uint8_t noise_bands_selector[]

Definition: qdmc.c:121

QDMCContext::noise_buffer

float noise_buffer[4096 *2]

Definition: qdmc.c:65

bytestream2_skipu

static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)

Definition: bytestream.h:174

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:389

lin_calc

static void lin_calc(QDMCContext *s, float amplitude, int node1, int node2, int index)

Definition: qdmc.c:487

uint8_t w

Definition: llviddspenc.c:38

QDMCContext::buffer

float buffer[2 *32768]

Definition: qdmc.c:66

AVPacket::data

uint8_t * data

Definition: packet.h:539

QDMCContext::noise2_buffer

float noise2_buffer[4096 *2]

Definition: qdmc.c:64

#define b

Definition: input.c:41

table

static const uint16_t table[]

Definition: prosumer.c:203

FFCodec

Definition: codec_internal.h:127

AVComplexFloat

Definition: tx.h:27

read_wave_data

static int read_wave_data(QDMCContext *s, GetBitContext *gb)

Definition: qdmc.c:425

QDMCContext::fft_ctx

AVTXContext * fft_ctx

Definition: qdmc.c:72

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:321

av_tx_init

av_cold int av_tx_init(AVTXContext **ctx, av_tx_fn *tx, enum AVTXType type, int inv, int len, const void *scale, uint64_t flags)

Initialize a transform context with the given configuration (i)MDCTs with an odd length are currently...

Definition: tx.c:903

ff_qdmc_decoder

const FFCodec ff_qdmc_decoder

Definition: qdmc.c:731

QDMCTone::freq

int16_t freq

Definition: qdmc.c:42

QDMCTone

Definition: qdmc.c:38

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:335

QDMCContext::alt_sin

float alt_sin[5][31]

Definition: qdmc.c:62

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1071

qdmc_get_vlc

static int qdmc_get_vlc(GetBitContext *gb, VLC *table, int flag)

Definition: qdmc.c:324

GetBitContext

Definition: get_bits.h:108

amplitude_tab

static const float amplitude_tab[64]

Definition: qdmc.c:91

qdmc_decode_close

static av_cold int qdmc_decode_close(AVCodecContext *avctx)

Definition: qdmc.c:315

QDMCContext::frame_size

int frame_size

Definition: qdmc.c:51

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:205

sin_table

static float sin_table[512]

Definition: qdmc.c:76

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:90

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:545

av_tx_fn

void(* av_tx_fn)(AVTXContext *s, void *out, void *in, ptrdiff_t stride)

Function pointer to a function to perform the transform.

Definition: tx.h:151

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:530

QDMCContext::subframe_size

int subframe_size

Definition: qdmc.c:52

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:311

#define s(width, name)

Definition: cbs_vp9.c:198

VLC_INIT_LE

#define VLC_INIT_LE

Definition: vlc.h:189

floor

static __device__ float floor(float a)

Definition: cuda_runtime.h:173

const char * g

Definition: vf_curves.c:128

QDMCContext::cur_tone

int cur_tone[5]

Definition: qdmc.c:61

AVMEDIA_TYPE_AUDIO

@ AVMEDIA_TYPE_AUDIO

Definition: avutil.h:202

qdmc_decode_init

static av_cold int qdmc_decode_init(AVCodecContext *avctx)

Definition: qdmc.c:208

QDMCContext::buffer_ptr

float * buffer_ptr

Definition: qdmc.c:67

QDMCContext

Definition: qdmc.c:46

AV_TX_FLOAT_FFT

@ AV_TX_FLOAT_FFT

Standard complex to complex FFT with sample data type of AVComplexFloat, AVComplexDouble or AVComplex...

Definition: tx.h:47

qdmc_hufftab

static const uint8_t qdmc_hufftab[][2]

Definition: qdmc.c:125

decode.h

get_bits.h

QDMCContext::band_index

int band_index

Definition: qdmc.c:50

decode_frame

static int decode_frame(QDMCContext *s, GetBitContext *gb, int16_t *out)

Definition: qdmc.c:621

QDMCTone::amplitude

int16_t amplitude

Definition: qdmc.c:43

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:296

GetBitContext::buffer

const uint8_t * buffer

Definition: get_bits.h:109

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

add_wave0

static void add_wave0(QDMCContext *s, int offset, int freqs, int stereo_mode, int amp, int phase)

Definition: qdmc.c:579

NULL

#define NULL

Definition: coverity.c:32

add_noise

static void add_noise(QDMCContext *s, int ch, int current_subframe)

Definition: qdmc.c:513

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

QDMCContext::rndval

int rndval

Definition: qdmc.c:68

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:501

QDMCContext::noise

uint8_t noise[2][19][17]

Definition: qdmc.c:58

QDMCTone::offset

uint8_t offset

Definition: qdmc.c:41

av_clipf

Definition: af_crystalizer.c:122

vtable

static VLC vtable[6]

Definition: qdmc.c:77

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:652

AVOnce

#define AVOnce

Definition: thread.h:202

index

int index

Definition: gxfenc.c:90

bytestream2_get_bytes_left

static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)

Definition: bytestream.h:158

AV_CODEC_CAP_CHANNEL_CONF

#define AV_CODEC_CAP_CHANNEL_CONF

Codec should fill in channel configuration and samplerate instead of container.

Definition: codec.h:106

QDMCContext::fft_offset

int fft_offset

Definition: qdmc.c:53

VLC::table_allocated

int table_allocated

Definition: vlc.h:39

Definition: af_crystalizer.c:122

ff_get_buffer

int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Get a buffer for a frame.

Definition: decode.c:1719

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

AVPacket::size

int size

Definition: packet.h:540

AVChannelLayout

An AVChannelLayout holds information about the channel layout of audio data.

Definition: channel_layout.h:311

codec_internal.h

DECLARE_ALIGNED

#define DECLARE_ALIGNED(n, t, v)

Definition: mem_internal.h:109

add_wave

static void add_wave(QDMCContext *s, int offset, int freqs, int group, int stereo_mode, int amp, int phase)

Definition: qdmc.c:547

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1063

size

int size

Definition: twinvq_data.h:10344

VLCElem

Definition: vlc.h:32

MKBETAG

#define MKBETAG(a, b, c, d)

Definition: macros.h:56

AV_CODEC_ID_QDMC

@ AV_CODEC_ID_QDMC

Definition: codec_id.h:490

qdmc_decode_frame

static int qdmc_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)

Definition: qdmc.c:699

QDMCTone::mode

uint8_t mode

Definition: qdmc.c:39

QDMCContext::itx_fn

av_tx_fn itx_fn

Definition: qdmc.c:73

QDMCContext::buffer_offset

int buffer_offset

Definition: qdmc.c:54

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:164

QDMCContext::checksum_size

int checksum_size

Definition: qdmc.c:56

code_prefix

static const unsigned code_prefix[]

Definition: qdmc.c:79

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

huff_sizes

static const uint8_t huff_sizes[]

Definition: qdmc.c:158

M_PI

#define M_PI

Definition: mathematics.h:67

av_tx_uninit

av_cold void av_tx_uninit(AVTXContext **ctx)

Frees a context and sets *ctx to NULL, does nothing when *ctx == NULL.

Definition: tx.c:295

QDMCContext::cmplx_in

AVComplexFloat cmplx_in[2][512]

Definition: qdmc.c:70

flag

#define flag(name)

Definition: cbs_av1.c:474

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:529

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

QDMCContext::avctx

AVCodecContext * avctx

Definition: qdmc.c:47

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:58

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:194

len

int len

Definition: vorbis_enc_data.h:426

avcodec.h

ret

Definition: filter_design.txt:187

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

QDMCContext::tones

QDMCTone tones[5][8192]

Definition: qdmc.c:59

huff_bits

static const uint8_t huff_bits[]

Definition: qdmc.c:162

pos

unsigned int pos

Definition: spdifenc.c:414

qdmc_flush

static av_cold void qdmc_flush(AVCodecContext *avctx)