FFmpeg: libavcodec/vorbisdec.c Source File

FFmpeg

[フレーム]

libavcodec

vorbisdec.c

Go to the documentation of this file.

1 /**

2 * @file

3 * Vorbis I decoder

4 * @author Denes Balatoni ( dbalatoni programozo hu )

5 *

6 * This file is part of FFmpeg.

7 *

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.

12 *

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.

17 *

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

21 */

23 /**

24 * @file

25 * Vorbis I decoder

26 * @author Denes Balatoni ( dbalatoni programozo hu )

27 */

29 #include <inttypes.h>

30 #include <math.h>

32 #define BITSTREAM_READER_LE

33 #include "libavutil/float_dsp.h"

34 #include "libavutil/avassert.h"

35 #include "avcodec.h"

36 #include "get_bits.h"

37 #include "fft.h"

38 #include "internal.h"

40 #include "vorbis.h"

41 #include "vorbisdsp.h"

42 #include "xiph.h"

44 #define V_NB_BITS 8

45 #define V_NB_BITS2 11

46 #define V_MAX_VLCS (1 << 16)

47 #define V_MAX_PARTITIONS (1 << 20)

49 typedef struct vorbis_codebook {

50 uint8_t dimensions;

51 uint8_t lookup_type;

52 uint8_t maxdepth;

53 VLC vlc;

54 float *codevectors;

55 unsigned int nb_bits;

56 } vorbis_codebook;

58 typedef union vorbis_floor_u vorbis_floor_data;

59 typedef struct vorbis_floor0_s vorbis_floor0;

60 typedef struct vorbis_floor1_s vorbis_floor1;

61 struct vorbis_context_s;

62 typedef

63 int (* vorbis_floor_decode_func)

64 (struct vorbis_context_s *, vorbis_floor_data *, float *);

65 typedef struct vorbis_floor {

66 uint8_t floor_type;

67 vorbis_floor_decode_func decode;

68 union vorbis_floor_u {

69 struct vorbis_floor0_s {

70 uint8_t order;

71 uint16_t rate;

72 uint16_t bark_map_size;

73 int32_t *map[2];

74 uint32_t map_size[2];

75 uint8_t amplitude_bits;

76 uint8_t amplitude_offset;

77 uint8_t num_books;

78 uint8_t *book_list;

79 float *lsp;

80 } t0;

81 struct vorbis_floor1_s {

82 uint8_t partitions;

83 uint8_t partition_class[32];

84 uint8_t class_dimensions[16];

85 uint8_t class_subclasses[16];

86 uint8_t class_masterbook[16];

87 int16_t subclass_books[16][8];

88 uint8_t multiplier;

89 uint16_t x_list_dim;

90 vorbis_floor1_entry *list;

91 } t1;

92 } data;

93 } vorbis_floor;

95 typedef struct vorbis_residue {

96 uint16_t type;

97 uint32_t begin;

98 uint32_t end;

99 unsigned partition_size;

100 uint8_t classifications;

101 uint8_t classbook;

102 int16_t books[64][8];

103 uint8_t maxpass;

104 uint16_t ptns_to_read;

105 uint8_t *classifs;

106 } vorbis_residue;

107

108 typedef struct vorbis_mapping {

109 uint8_t submaps;

110 uint16_t coupling_steps;

111 uint8_t *magnitude;

112 uint8_t *angle;

113 uint8_t *mux;

114 uint8_t submap_floor[16];

115 uint8_t submap_residue[16];

116 } vorbis_mapping;

117

118 typedef struct vorbis_mode {

119 uint8_t blockflag;

120 uint16_t windowtype;

121 uint16_t transformtype;

122 uint8_t mapping;

123 } vorbis_mode;

124

125 typedef struct vorbis_context_s {

126 AVCodecContext *avctx;

127 GetBitContext gb;

128 VorbisDSPContext dsp;

129 AVFloatDSPContext *fdsp;

130

131 FFTContext mdct[2];

132 uint8_t first_frame;

133 uint32_t version;

134 uint8_t audio_channels;

135 uint32_t audio_samplerate;

136 uint32_t bitrate_maximum;

137 uint32_t bitrate_nominal;

138 uint32_t bitrate_minimum;

139 uint32_t blocksize[2];

140 const float *win[2];

141 uint16_t codebook_count;

142 vorbis_codebook *codebooks;

143 uint8_t floor_count;

144 vorbis_floor *floors;

145 uint8_t residue_count;

146 vorbis_residue *residues;

147 uint8_t mapping_count;

148 vorbis_mapping *mappings;

149 uint8_t mode_count;

150 vorbis_mode *modes;

151 uint8_t mode_number; // mode number for the current packet

152 int8_t previous_window;

153 float *channel_residues;

154 float *saved;

155 } vorbis_context;

156

157 /* Helper functions */

158

159 #define BARK(x) \

160 (13.1f * atan(0.00074f * (x)) + 2.24f * atan(1.85e-8f * (x) * (x)) + 1e-4f * (x))

161

162 static const char idx_err_str[] = "Index value %d out of range (0 - %d) for %s at %s:%i\n";

163 #define VALIDATE_INDEX(idx, limit) \

164 if (idx >= limit) {\

165 av_log(vc->avctx, AV_LOG_ERROR,\

166 idx_err_str,\

167 (int)(idx), (int)(limit - 1), #idx, __FILE__, __LINE__);\

168 return AVERROR_INVALIDDATA;\

169 }

170 #define GET_VALIDATED_INDEX(idx, bits, limit) \

171 {\

172 idx = get_bits(gb, bits);\

173 VALIDATE_INDEX(idx, limit)\

174 }

175

176 static float vorbisfloat2float(unsigned val)

177 {

178 double mant = val & 0x1fffff;

179 long exp = (val & 0x7fe00000L) >> 21;

180 if (val & 0x80000000)

181 mant = -mant;

182 return ldexp(mant, exp - 20 - 768);

183 }

184

185

186 // Free all allocated memory -----------------------------------------

187

188 static void vorbis_free(vorbis_context *vc)

189 {

190 int i;

191

192 av_freep(&vc->channel_residues);

193 av_freep(&vc->saved);

194 av_freep(&vc->fdsp);

195

196 if (vc->residues)

197 for (i = 0; i < vc->residue_count; i++)

198 av_freep(&vc->residues[i].classifs);

199 av_freep(&vc->residues);

200 av_freep(&vc->modes);

201

202 ff_mdct_end(&vc->mdct[0]);

203 ff_mdct_end(&vc->mdct[1]);

204

205 if (vc->codebooks)

206 for (i = 0; i < vc->codebook_count; ++i) {

207 av_freep(&vc->codebooks[i].codevectors);

208 ff_free_vlc(&vc->codebooks[i].vlc);

209 }

210 av_freep(&vc->codebooks);

211

212 if (vc->floors)

213 for (i = 0; i < vc->floor_count; ++i) {

214 if (vc->floors[i].floor_type == 0) {

215 av_freep(&vc->floors[i].data.t0.map[0]);

216 av_freep(&vc->floors[i].data.t0.map[1]);

217 av_freep(&vc->floors[i].data.t0.book_list);

218 av_freep(&vc->floors[i].data.t0.lsp);

219 } else {

220 av_freep(&vc->floors[i].data.t1.list);

221 }

222 }

223 av_freep(&vc->floors);

224

225 if (vc->mappings)

226 for (i = 0; i < vc->mapping_count; ++i) {

227 av_freep(&vc->mappings[i].magnitude);

228 av_freep(&vc->mappings[i].angle);

229 av_freep(&vc->mappings[i].mux);

230 }

231 av_freep(&vc->mappings);

232 }

233

234 // Parse setup header -------------------------------------------------

235

236 // Process codebooks part

237

238 static int vorbis_parse_setup_hdr_codebooks(vorbis_context *vc)

239 {

240 unsigned cb;

241 uint8_t *tmp_vlc_bits = NULL;

242 uint32_t *tmp_vlc_codes = NULL;

243 GetBitContext *gb = &vc->gb;

244 uint16_t *codebook_multiplicands = NULL;

245 int ret = 0;

246

247 vc->codebook_count = get_bits(gb, 8) + 1;

248

249 av_dlog(NULL, " Codebooks: %d \n", vc->codebook_count);

250

251 vc->codebooks = av_mallocz(vc->codebook_count * sizeof(*vc->codebooks));

252 tmp_vlc_bits = av_mallocz(V_MAX_VLCS * sizeof(*tmp_vlc_bits));

253 tmp_vlc_codes = av_mallocz(V_MAX_VLCS * sizeof(*tmp_vlc_codes));

254 codebook_multiplicands = av_malloc(V_MAX_VLCS * sizeof(*codebook_multiplicands));

255 if (!vc->codebooks ||

256 !tmp_vlc_bits || !tmp_vlc_codes || !codebook_multiplicands) {

257 ret = AVERROR(ENOMEM);

258 goto error;

259 }

260

261 for (cb = 0; cb < vc->codebook_count; ++cb) {

262 vorbis_codebook *codebook_setup = &vc->codebooks[cb];

263 unsigned ordered, t, entries, used_entries = 0;

264

265 av_dlog(NULL, " %u. Codebook\n", cb);

266

267 if (get_bits(gb, 24) != 0x564342) {

268 av_log(vc->avctx, AV_LOG_ERROR,

269 " %u. Codebook setup data corrupt.\n", cb);

270 ret = AVERROR_INVALIDDATA;

271 goto error;

272 }

273

274 codebook_setup->dimensions=get_bits(gb, 16);

275 if (codebook_setup->dimensions > 16 || codebook_setup->dimensions == 0) {

276 av_log(vc->avctx, AV_LOG_ERROR,

277 " %u. Codebook's dimension is invalid (%d).\n",

278 cb, codebook_setup->dimensions);

279 ret = AVERROR_INVALIDDATA;

280 goto error;

281 }

282 entries = get_bits(gb, 24);

283 if (entries > V_MAX_VLCS) {

284 av_log(vc->avctx, AV_LOG_ERROR,

285 " %u. Codebook has too many entries (%u).\n",

286 cb, entries);

287 ret = AVERROR_INVALIDDATA;

288 goto error;

289 }

290

291 ordered = get_bits1(gb);

292

293 av_dlog(NULL, " codebook_dimensions %d, codebook_entries %u\n",

294 codebook_setup->dimensions, entries);

295

296 if (!ordered) {

297 unsigned ce, flag;

298 unsigned sparse = get_bits1(gb);

299

300 av_dlog(NULL, " not ordered \n");

301

302 if (sparse) {

303 av_dlog(NULL, " sparse \n");

304

305 used_entries = 0;

306 for (ce = 0; ce < entries; ++ce) {

307 flag = get_bits1(gb);

308 if (flag) {

309 tmp_vlc_bits[ce] = get_bits(gb, 5) + 1;

310 ++used_entries;

311 } else

312 tmp_vlc_bits[ce] = 0;

313 }

314 } else {

315 av_dlog(NULL, " not sparse \n");

316

317 used_entries = entries;

318 for (ce = 0; ce < entries; ++ce)

319 tmp_vlc_bits[ce] = get_bits(gb, 5) + 1;

320 }

321 } else {

322 unsigned current_entry = 0;

323 unsigned current_length = get_bits(gb, 5) + 1;

324

325 av_dlog(NULL, " ordered, current length: %u\n", current_length); //FIXME

326

327 used_entries = entries;

328 for (; current_entry < used_entries && current_length <= 32; ++current_length) {

329 unsigned i, number;

330

331 av_dlog(NULL, " number bits: %u ", ilog(entries - current_entry));

332

333 number = get_bits(gb, ilog(entries - current_entry));

334

335 av_dlog(NULL, " number: %u\n", number);

336

337 for (i = current_entry; i < number+current_entry; ++i)

338 if (i < used_entries)

339 tmp_vlc_bits[i] = current_length;

340

341 current_entry+=number;

342 }

343 if (current_entry>used_entries) {

344 av_log(vc->avctx, AV_LOG_ERROR, " More codelengths than codes in codebook. \n");

345 ret = AVERROR_INVALIDDATA;

346 goto error;

347 }

348 }

349

350 codebook_setup->lookup_type = get_bits(gb, 4);

351

352 av_dlog(NULL, " lookup type: %d : %s \n", codebook_setup->lookup_type,

353 codebook_setup->lookup_type ? "vq" : "no lookup");

354

355 // If the codebook is used for (inverse) VQ, calculate codevectors.

356

357 if (codebook_setup->lookup_type == 1) {

358 unsigned i, j, k;

359 unsigned codebook_lookup_values = ff_vorbis_nth_root(entries, codebook_setup->dimensions);

360

361 float codebook_minimum_value = vorbisfloat2float(get_bits_long(gb, 32));

362 float codebook_delta_value = vorbisfloat2float(get_bits_long(gb, 32));

363 unsigned codebook_value_bits = get_bits(gb, 4) + 1;

364 unsigned codebook_sequence_p = get_bits1(gb);

365

366 av_dlog(NULL, " We expect %d numbers for building the codevectors. \n",

367 codebook_lookup_values);

368 av_dlog(NULL, " delta %f minmum %f \n",

369 codebook_delta_value, codebook_minimum_value);

370

371 for (i = 0; i < codebook_lookup_values; ++i) {

372 codebook_multiplicands[i] = get_bits(gb, codebook_value_bits);

373

374 av_dlog(NULL, " multiplicands*delta+minmum : %e \n",

375 (float)codebook_multiplicands[i] * codebook_delta_value + codebook_minimum_value);

376 av_dlog(NULL, " multiplicand %u\n", codebook_multiplicands[i]);

377 }

378

379 // Weed out unused vlcs and build codevector vector

380 if (used_entries) {

381 codebook_setup->codevectors =

382 av_mallocz_array(used_entries, codebook_setup->dimensions *

383 sizeof(*codebook_setup->codevectors));

384 if (!codebook_setup->codevectors) {

385 ret = AVERROR(ENOMEM);

386 goto error;

387 }

388 } else

389 codebook_setup->codevectors = NULL;

390

391 for (j = 0, i = 0; i < entries; ++i) {

392 unsigned dim = codebook_setup->dimensions;

393

394 if (tmp_vlc_bits[i]) {

395 float last = 0.0;

396 unsigned lookup_offset = i;

397

398 av_dlog(vc->avctx, "Lookup offset %u ,", i);

399

400 for (k = 0; k < dim; ++k) {

401 unsigned multiplicand_offset = lookup_offset % codebook_lookup_values;

402 codebook_setup->codevectors[j * dim + k] = codebook_multiplicands[multiplicand_offset] * codebook_delta_value + codebook_minimum_value + last;

403 if (codebook_sequence_p)

404 last = codebook_setup->codevectors[j * dim + k];

405 lookup_offset/=codebook_lookup_values;

406 }

407 tmp_vlc_bits[j] = tmp_vlc_bits[i];

408

409 av_dlog(vc->avctx, "real lookup offset %u, vector: ", j);

410 for (k = 0; k < dim; ++k)

411 av_dlog(vc->avctx, " %f ",

412 codebook_setup->codevectors[j * dim + k]);

413 av_dlog(vc->avctx, "\n");

414

415 ++j;

416 }

417 }

418 if (j != used_entries) {

419 av_log(vc->avctx, AV_LOG_ERROR, "Bug in codevector vector building code. \n");

420 ret = AVERROR_INVALIDDATA;

421 goto error;

422 }

423 entries = used_entries;

424 } else if (codebook_setup->lookup_type >= 2) {

425 av_log(vc->avctx, AV_LOG_ERROR, "Codebook lookup type not supported. \n");

426 ret = AVERROR_INVALIDDATA;

427 goto error;

428 }

429

430 // Initialize VLC table

431 if (ff_vorbis_len2vlc(tmp_vlc_bits, tmp_vlc_codes, entries)) {

432 av_log(vc->avctx, AV_LOG_ERROR, " Invalid code lengths while generating vlcs. \n");

433 ret = AVERROR_INVALIDDATA;

434 goto error;

435 }

436 codebook_setup->maxdepth = 0;

437 for (t = 0; t < entries; ++t)

438 if (tmp_vlc_bits[t] >= codebook_setup->maxdepth)

439 codebook_setup->maxdepth = tmp_vlc_bits[t];

440

441 if (codebook_setup->maxdepth > 3 * V_NB_BITS)

442 codebook_setup->nb_bits = V_NB_BITS2;

443 else

444 codebook_setup->nb_bits = V_NB_BITS;

445

446 codebook_setup->maxdepth = (codebook_setup->maxdepth+codebook_setup->nb_bits - 1) / codebook_setup->nb_bits;

447

448 if ((ret = init_vlc(&codebook_setup->vlc, codebook_setup->nb_bits,

449 entries, tmp_vlc_bits, sizeof(*tmp_vlc_bits),

450 sizeof(*tmp_vlc_bits), tmp_vlc_codes,

451 sizeof(*tmp_vlc_codes), sizeof(*tmp_vlc_codes),

452 INIT_VLC_LE))) {

453 av_log(vc->avctx, AV_LOG_ERROR, " Error generating vlc tables. \n");

454 goto error;

455 }

456 }

457

458 av_free(tmp_vlc_bits);

459 av_free(tmp_vlc_codes);

460 av_free(codebook_multiplicands);

461 return 0;

462

463 // Error:

464 error:

465 av_free(tmp_vlc_bits);

466 av_free(tmp_vlc_codes);

467 av_free(codebook_multiplicands);

468 return ret;

469 }

470

471 // Process time domain transforms part (unused in Vorbis I)

472

473 static int vorbis_parse_setup_hdr_tdtransforms(vorbis_context *vc)

474 {

475 GetBitContext *gb = &vc->gb;

476 unsigned i, vorbis_time_count = get_bits(gb, 6) + 1;

477

478 for (i = 0; i < vorbis_time_count; ++i) {

479 unsigned vorbis_tdtransform = get_bits(gb, 16);

480

481 av_dlog(NULL, " Vorbis time domain transform %u: %u\n",

482 vorbis_time_count, vorbis_tdtransform);

483

484 if (vorbis_tdtransform) {

485 av_log(vc->avctx, AV_LOG_ERROR, "Vorbis time domain transform data nonzero. \n");

486 return AVERROR_INVALIDDATA;

487 }

488 }

489 return 0;

490 }

491

492 // Process floors part

493

494 static int vorbis_floor0_decode(vorbis_context *vc,

495 vorbis_floor_data *vfu, float *vec);

496 static int create_map(vorbis_context *vc, unsigned floor_number);

497 static int vorbis_floor1_decode(vorbis_context *vc,

498 vorbis_floor_data *vfu, float *vec);

499 static int vorbis_parse_setup_hdr_floors(vorbis_context *vc)

500 {

501 GetBitContext *gb = &vc->gb;

502 int i, j, k, ret;

503

504 vc->floor_count = get_bits(gb, 6) + 1;

505

506 vc->floors = av_mallocz(vc->floor_count * sizeof(*vc->floors));

507 if (!vc->floors)

508 return AVERROR(ENOMEM);

509

510 for (i = 0; i < vc->floor_count; ++i) {

511 vorbis_floor *floor_setup = &vc->floors[i];

512

513 floor_setup->floor_type = get_bits(gb, 16);

514

515 av_dlog(NULL, " %d. floor type %d \n", i, floor_setup->floor_type);

516

517 if (floor_setup->floor_type == 1) {

518 int maximum_class = -1;

519 unsigned rangebits, rangemax, floor1_values = 2;

520

521 floor_setup->decode = vorbis_floor1_decode;

522

523 floor_setup->data.t1.partitions = get_bits(gb, 5);

524

525 av_dlog(NULL, " %d.floor: %d partitions \n",

526 i, floor_setup->data.t1.partitions);

527

528 for (j = 0; j < floor_setup->data.t1.partitions; ++j) {

529 floor_setup->data.t1.partition_class[j] = get_bits(gb, 4);

530 if (floor_setup->data.t1.partition_class[j] > maximum_class)

531 maximum_class = floor_setup->data.t1.partition_class[j];

532

533 av_dlog(NULL, " %d. floor %d partition class %d \n",

534 i, j, floor_setup->data.t1.partition_class[j]);

535

536 }

537

538 av_dlog(NULL, " maximum class %d \n", maximum_class);

539

540 for (j = 0; j <= maximum_class; ++j) {

541 floor_setup->data.t1.class_dimensions[j] = get_bits(gb, 3) + 1;

542 floor_setup->data.t1.class_subclasses[j] = get_bits(gb, 2);

543

544 av_dlog(NULL, " %d floor %d class dim: %d subclasses %d \n", i, j,

545 floor_setup->data.t1.class_dimensions[j],

546 floor_setup->data.t1.class_subclasses[j]);

547

548 if (floor_setup->data.t1.class_subclasses[j]) {

549 GET_VALIDATED_INDEX(floor_setup->data.t1.class_masterbook[j], 8, vc->codebook_count)

550

551 av_dlog(NULL, " masterbook: %d \n", floor_setup->data.t1.class_masterbook[j]);

552 }

553

554 for (k = 0; k < (1 << floor_setup->data.t1.class_subclasses[j]); ++k) {

555 int16_t bits = get_bits(gb, 8) - 1;

556 if (bits != -1)

557 VALIDATE_INDEX(bits, vc->codebook_count)

558 floor_setup->data.t1.subclass_books[j][k] = bits;

559

560 av_dlog(NULL, " book %d. : %d \n", k, floor_setup->data.t1.subclass_books[j][k]);

561 }

562 }

563

564 floor_setup->data.t1.multiplier = get_bits(gb, 2) + 1;

565 floor_setup->data.t1.x_list_dim = 2;

566

567 for (j = 0; j < floor_setup->data.t1.partitions; ++j)

568 floor_setup->data.t1.x_list_dim+=floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]];

569

570 floor_setup->data.t1.list = av_mallocz_array(floor_setup->data.t1.x_list_dim,

571 sizeof(*floor_setup->data.t1.list));

572 if (!floor_setup->data.t1.list)

573 return AVERROR(ENOMEM);

574

575 rangebits = get_bits(gb, 4);

576 rangemax = (1 << rangebits);

577 if (rangemax > vc->blocksize[1] / 2) {

578 av_log(vc->avctx, AV_LOG_ERROR,

579 "Floor value is too large for blocksize: %u (%"PRIu32")\n",

580 rangemax, vc->blocksize[1] / 2);

581 return AVERROR_INVALIDDATA;

582 }

583 floor_setup->data.t1.list[0].x = 0;

584 floor_setup->data.t1.list[1].x = rangemax;

585

586 for (j = 0; j < floor_setup->data.t1.partitions; ++j) {

587 for (k = 0; k < floor_setup->data.t1.class_dimensions[floor_setup->data.t1.partition_class[j]]; ++k, ++floor1_values) {

588 floor_setup->data.t1.list[floor1_values].x = get_bits(gb, rangebits);

589

590 av_dlog(NULL, " %u. floor1 Y coord. %d\n", floor1_values,

591 floor_setup->data.t1.list[floor1_values].x);

592 }

593 }

594

595 // Precalculate order of x coordinates - needed for decode

596 if (ff_vorbis_ready_floor1_list(vc->avctx,

597 floor_setup->data.t1.list,

598 floor_setup->data.t1.x_list_dim)) {

599 return AVERROR_INVALIDDATA;

600 }

601 } else if (floor_setup->floor_type == 0) {

602 unsigned max_codebook_dim = 0;

603

604 floor_setup->decode = vorbis_floor0_decode;

605

606 floor_setup->data.t0.order = get_bits(gb, 8);

607 if (!floor_setup->data.t0.order) {

608 av_log(vc->avctx, AV_LOG_ERROR, "Floor 0 order is 0.\n");

609 return AVERROR_INVALIDDATA;

610 }

611 floor_setup->data.t0.rate = get_bits(gb, 16);

612 if (!floor_setup->data.t0.rate) {

613 av_log(vc->avctx, AV_LOG_ERROR, "Floor 0 rate is 0.\n");

614 return AVERROR_INVALIDDATA;

615 }

616 floor_setup->data.t0.bark_map_size = get_bits(gb, 16);

617 if (!floor_setup->data.t0.bark_map_size) {

618 av_log(vc->avctx, AV_LOG_ERROR,

619 "Floor 0 bark map size is 0.\n");

620 return AVERROR_INVALIDDATA;

621 }

622 floor_setup->data.t0.amplitude_bits = get_bits(gb, 6);

623 floor_setup->data.t0.amplitude_offset = get_bits(gb, 8);

624 floor_setup->data.t0.num_books = get_bits(gb, 4) + 1;

625

626 /* allocate mem for booklist */

627 floor_setup->data.t0.book_list =

628 av_malloc(floor_setup->data.t0.num_books);

629 if (!floor_setup->data.t0.book_list)

630 return AVERROR(ENOMEM);

631 /* read book indexes */

632 {

633 int idx;

634 unsigned book_idx;

635 for (idx = 0; idx < floor_setup->data.t0.num_books; ++idx) {

636 GET_VALIDATED_INDEX(book_idx, 8, vc->codebook_count)

637 floor_setup->data.t0.book_list[idx] = book_idx;

638 if (vc->codebooks[book_idx].dimensions > max_codebook_dim)

639 max_codebook_dim = vc->codebooks[book_idx].dimensions;

640 }

641 }

642

643 if ((ret = create_map(vc, i)) < 0)

644 return ret;

645

646 /* codebook dim is for padding if codebook dim doesn't *

647 * divide order+1 then we need to read more data */

648 floor_setup->data.t0.lsp =

649 av_malloc_array((floor_setup->data.t0.order + 1 + max_codebook_dim),

650 sizeof(*floor_setup->data.t0.lsp));

651 if (!floor_setup->data.t0.lsp)

652 return AVERROR(ENOMEM);

653

654 /* debug output parsed headers */

655 av_dlog(NULL, "floor0 order: %u\n", floor_setup->data.t0.order);

656 av_dlog(NULL, "floor0 rate: %u\n", floor_setup->data.t0.rate);

657 av_dlog(NULL, "floor0 bark map size: %u\n",

658 floor_setup->data.t0.bark_map_size);

659 av_dlog(NULL, "floor0 amplitude bits: %u\n",

660 floor_setup->data.t0.amplitude_bits);

661 av_dlog(NULL, "floor0 amplitude offset: %u\n",

662 floor_setup->data.t0.amplitude_offset);

663 av_dlog(NULL, "floor0 number of books: %u\n",

664 floor_setup->data.t0.num_books);

665 av_dlog(NULL, "floor0 book list pointer: %p\n",

666 floor_setup->data.t0.book_list);

667 {

668 int idx;

669 for (idx = 0; idx < floor_setup->data.t0.num_books; ++idx) {

670 av_dlog(NULL, " Book %d: %u\n", idx + 1,

671 floor_setup->data.t0.book_list[idx]);

672 }

673 }

674 } else {

675 av_log(vc->avctx, AV_LOG_ERROR, "Invalid floor type!\n");

676 return AVERROR_INVALIDDATA;

677 }

678 }

679 return 0;

680 }

681

682 // Process residues part

683

684 static int vorbis_parse_setup_hdr_residues(vorbis_context *vc)

685 {

686 GetBitContext *gb = &vc->gb;

687 unsigned i, j, k;

688

689 vc->residue_count = get_bits(gb, 6)+1;

690 vc->residues = av_mallocz(vc->residue_count * sizeof(*vc->residues));

691 if (!vc->residues)

692 return AVERROR(ENOMEM);

693

694 av_dlog(NULL, " There are %d residues. \n", vc->residue_count);

695

696 for (i = 0; i < vc->residue_count; ++i) {

697 vorbis_residue *res_setup = &vc->residues[i];

698 uint8_t cascade[64];

699 unsigned high_bits, low_bits;

700

701 res_setup->type = get_bits(gb, 16);

702

703 av_dlog(NULL, " %u. residue type %d\n", i, res_setup->type);

704

705 res_setup->begin = get_bits(gb, 24);

706 res_setup->end = get_bits(gb, 24);

707 res_setup->partition_size = get_bits(gb, 24) + 1;

708 /* Validations to prevent a buffer overflow later. */

709 if (res_setup->begin>res_setup->end ||

710 (res_setup->end-res_setup->begin) / res_setup->partition_size > FFMIN(V_MAX_PARTITIONS, 65535)) {

711 av_log(vc->avctx, AV_LOG_ERROR,

712 "partition out of bounds: type, begin, end, size, blocksize: %"PRIu16", %"PRIu32", %"PRIu32", %u, %"PRIu32"\n",

713 res_setup->type, res_setup->begin, res_setup->end,

714 res_setup->partition_size, vc->blocksize[1] / 2);

715 return AVERROR_INVALIDDATA;

716 }

717

718 res_setup->classifications = get_bits(gb, 6) + 1;

719 GET_VALIDATED_INDEX(res_setup->classbook, 8, vc->codebook_count)

720

721 res_setup->ptns_to_read =

722 (res_setup->end - res_setup->begin) / res_setup->partition_size;

723 res_setup->classifs = av_malloc_array(res_setup->ptns_to_read,

724 vc->audio_channels *

725 sizeof(*res_setup->classifs));

726 if (!res_setup->classifs)

727 return AVERROR(ENOMEM);

728

729 av_dlog(NULL, " begin %d end %d part.size %d classif.s %d classbook %d \n",

730 res_setup->begin, res_setup->end, res_setup->partition_size,

731 res_setup->classifications, res_setup->classbook);

732

733 for (j = 0; j < res_setup->classifications; ++j) {

734 high_bits = 0;

735 low_bits = get_bits(gb, 3);

736 if (get_bits1(gb))

737 high_bits = get_bits(gb, 5);

738 cascade[j] = (high_bits << 3) + low_bits;

739

740 av_dlog(NULL, " %u class cascade depth: %d\n", j, ilog(cascade[j]));

741 }

742

743 res_setup->maxpass = 0;

744 for (j = 0; j < res_setup->classifications; ++j) {

745 for (k = 0; k < 8; ++k) {

746 if (cascade[j]&(1 << k)) {

747 GET_VALIDATED_INDEX(res_setup->books[j][k], 8, vc->codebook_count)

748

749 av_dlog(NULL, " %u class cascade depth %u book: %d\n",

750 j, k, res_setup->books[j][k]);

751

752 if (k>res_setup->maxpass)

753 res_setup->maxpass = k;

754 } else {

755 res_setup->books[j][k] = -1;

756 }

757 }

758 }

759 }

760 return 0;

761 }

762

763 // Process mappings part

764

765 static int vorbis_parse_setup_hdr_mappings(vorbis_context *vc)

766 {

767 GetBitContext *gb = &vc->gb;

768 unsigned i, j;

769

770 vc->mapping_count = get_bits(gb, 6)+1;

771 vc->mappings = av_mallocz(vc->mapping_count * sizeof(*vc->mappings));

772 if (!vc->mappings)

773 return AVERROR(ENOMEM);

774

775 av_dlog(NULL, " There are %d mappings. \n", vc->mapping_count);

776

777 for (i = 0; i < vc->mapping_count; ++i) {

778 vorbis_mapping *mapping_setup = &vc->mappings[i];

779

780 if (get_bits(gb, 16)) {

781 av_log(vc->avctx, AV_LOG_ERROR, "Other mappings than type 0 are not compliant with the Vorbis I specification. \n");

782 return AVERROR_INVALIDDATA;

783 }

784 if (get_bits1(gb)) {

785 mapping_setup->submaps = get_bits(gb, 4) + 1;

786 } else {

787 mapping_setup->submaps = 1;

788 }

789

790 if (get_bits1(gb)) {

791 mapping_setup->coupling_steps = get_bits(gb, 8) + 1;

792 mapping_setup->magnitude = av_mallocz(mapping_setup->coupling_steps *

793 sizeof(*mapping_setup->magnitude));

794 mapping_setup->angle = av_mallocz(mapping_setup->coupling_steps *

795 sizeof(*mapping_setup->angle));

796 if (!mapping_setup->angle || !mapping_setup->magnitude)

797 return AVERROR(ENOMEM);

798

799 for (j = 0; j < mapping_setup->coupling_steps; ++j) {

800 GET_VALIDATED_INDEX(mapping_setup->magnitude[j], ilog(vc->audio_channels - 1), vc->audio_channels)

801 GET_VALIDATED_INDEX(mapping_setup->angle[j], ilog(vc->audio_channels - 1), vc->audio_channels)

802 }

803 } else {

804 mapping_setup->coupling_steps = 0;

805 }

806

807 av_dlog(NULL, " %u mapping coupling steps: %d\n",

808 i, mapping_setup->coupling_steps);

809

810 if (get_bits(gb, 2)) {

811 av_log(vc->avctx, AV_LOG_ERROR, "%u. mapping setup data invalid.\n", i);

812 return AVERROR_INVALIDDATA; // following spec.

813 }

814

815 if (mapping_setup->submaps>1) {

816 mapping_setup->mux = av_mallocz_array(vc->audio_channels,

817 sizeof(*mapping_setup->mux));

818 if (!mapping_setup->mux)

819 return AVERROR(ENOMEM);

820

821 for (j = 0; j < vc->audio_channels; ++j)

822 mapping_setup->mux[j] = get_bits(gb, 4);

823 }

824

825 for (j = 0; j < mapping_setup->submaps; ++j) {

826 skip_bits(gb, 8); // FIXME check?

827 GET_VALIDATED_INDEX(mapping_setup->submap_floor[j], 8, vc->floor_count)

828 GET_VALIDATED_INDEX(mapping_setup->submap_residue[j], 8, vc->residue_count)

829

830 av_dlog(NULL, " %u mapping %u submap : floor %d, residue %d\n", i, j,

831 mapping_setup->submap_floor[j],

832 mapping_setup->submap_residue[j]);

833 }

834 }

835 return 0;

836 }

837

838 // Process modes part

839

840 static int create_map(vorbis_context *vc, unsigned floor_number)

841 {

842 vorbis_floor *floors = vc->floors;

843 vorbis_floor0 *vf;

844 int idx;

845 int blockflag, n;

846 int32_t *map;

847

848 for (blockflag = 0; blockflag < 2; ++blockflag) {

849 n = vc->blocksize[blockflag] / 2;

850 floors[floor_number].data.t0.map[blockflag] =

851 av_malloc_array(n + 1, sizeof(int32_t)); // n + sentinel

852 if (!floors[floor_number].data.t0.map[blockflag])

853 return AVERROR(ENOMEM);

854

855 map = floors[floor_number].data.t0.map[blockflag];

856 vf = &floors[floor_number].data.t0;

857

858 for (idx = 0; idx < n; ++idx) {

859 map[idx] = floor(BARK((vf->rate * idx) / (2.0f * n)) *

860 (vf->bark_map_size / BARK(vf->rate / 2.0f)));

861 if (vf->bark_map_size-1 < map[idx])

862 map[idx] = vf->bark_map_size - 1;

863 }

864 map[n] = -1;

865 vf->map_size[blockflag] = n;

866 }

867

868 for (idx = 0; idx <= n; ++idx) {

869 av_dlog(NULL, "floor0 map: map at pos %d is %d\n", idx, map[idx]);

870 }

871

872 return 0;

873 }

874

875 static int vorbis_parse_setup_hdr_modes(vorbis_context *vc)

876 {

877 GetBitContext *gb = &vc->gb;

878 unsigned i;

879

880 vc->mode_count = get_bits(gb, 6) + 1;

881 vc->modes = av_mallocz(vc->mode_count * sizeof(*vc->modes));

882 if (!vc->modes)

883 return AVERROR(ENOMEM);

884

885 av_dlog(NULL, " There are %d modes.\n", vc->mode_count);

886

887 for (i = 0; i < vc->mode_count; ++i) {

888 vorbis_mode *mode_setup = &vc->modes[i];

889

890 mode_setup->blockflag = get_bits1(gb);

891 mode_setup->windowtype = get_bits(gb, 16); //FIXME check

892 mode_setup->transformtype = get_bits(gb, 16); //FIXME check

893 GET_VALIDATED_INDEX(mode_setup->mapping, 8, vc->mapping_count);

894

895 av_dlog(NULL, " %u mode: blockflag %d, windowtype %d, transformtype %d, mapping %d\n",

896 i, mode_setup->blockflag, mode_setup->windowtype,

897 mode_setup->transformtype, mode_setup->mapping);

898 }

899 return 0;

900 }

901

902 // Process the whole setup header using the functions above

903

904 static int vorbis_parse_setup_hdr(vorbis_context *vc)

905 {

906 GetBitContext *gb = &vc->gb;

907 int ret;

908

909 if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') ||

910 (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') ||

911 (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) {

912 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (no vorbis signature). \n");

913 return AVERROR_INVALIDDATA;

914 }

915

916 if ((ret = vorbis_parse_setup_hdr_codebooks(vc))) {

917 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (codebooks). \n");

918 return ret;

919 }

920 if ((ret = vorbis_parse_setup_hdr_tdtransforms(vc))) {

921 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (time domain transforms). \n");

922 return ret;

923 }

924 if ((ret = vorbis_parse_setup_hdr_floors(vc))) {

925 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (floors). \n");

926 return ret;

927 }

928 if ((ret = vorbis_parse_setup_hdr_residues(vc))) {

929 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (residues). \n");

930 return ret;

931 }

932 if ((ret = vorbis_parse_setup_hdr_mappings(vc))) {

933 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (mappings). \n");

934 return ret;

935 }

936 if ((ret = vorbis_parse_setup_hdr_modes(vc))) {

937 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (modes). \n");

938 return ret;

939 }

940 if (!get_bits1(gb)) {

941 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis setup header packet corrupt (framing flag). \n");

942 return AVERROR_INVALIDDATA; // framing flag bit unset error

943 }

944

945 return 0;

946 }

947

948 // Process the identification header

949

950 static int vorbis_parse_id_hdr(vorbis_context *vc)

951 {

952 GetBitContext *gb = &vc->gb;

953 unsigned bl0, bl1;

954

955 if ((get_bits(gb, 8) != 'v') || (get_bits(gb, 8) != 'o') ||

956 (get_bits(gb, 8) != 'r') || (get_bits(gb, 8) != 'b') ||

957 (get_bits(gb, 8) != 'i') || (get_bits(gb, 8) != 's')) {

958 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (no vorbis signature). \n");

959 return AVERROR_INVALIDDATA;

960 }

961

962 vc->version = get_bits_long(gb, 32); //FIXME check 0

963 vc->audio_channels = get_bits(gb, 8);

964 if (vc->audio_channels <= 0) {

965 av_log(vc->avctx, AV_LOG_ERROR, "Invalid number of channels\n");

966 return AVERROR_INVALIDDATA;

967 }

968 vc->audio_samplerate = get_bits_long(gb, 32);

969 if (vc->audio_samplerate <= 0) {

970 av_log(vc->avctx, AV_LOG_ERROR, "Invalid samplerate\n");

971 return AVERROR_INVALIDDATA;

972 }

973 vc->bitrate_maximum = get_bits_long(gb, 32);

974 vc->bitrate_nominal = get_bits_long(gb, 32);

975 vc->bitrate_minimum = get_bits_long(gb, 32);

976 bl0 = get_bits(gb, 4);

977 bl1 = get_bits(gb, 4);

978 if (bl0 > 13 || bl0 < 6 || bl1 > 13 || bl1 < 6 || bl1 < bl0) {

979 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (illegal blocksize). \n");

980 return AVERROR_INVALIDDATA;

981 }

982 vc->blocksize[0] = (1 << bl0);

983 vc->blocksize[1] = (1 << bl1);

984 vc->win[0] = ff_vorbis_vwin[bl0 - 6];

985 vc->win[1] = ff_vorbis_vwin[bl1 - 6];

986

987 if ((get_bits1(gb)) == 0) {

988 av_log(vc->avctx, AV_LOG_ERROR, " Vorbis id header packet corrupt (framing flag not set). \n");

989 return AVERROR_INVALIDDATA;

990 }

991

992 vc->channel_residues = av_malloc_array(vc->blocksize[1] / 2, vc->audio_channels * sizeof(*vc->channel_residues));

993 vc->saved = av_mallocz_array(vc->blocksize[1] / 4, vc->audio_channels * sizeof(*vc->saved));

994 if (!vc->channel_residues || !vc->saved)

995 return AVERROR(ENOMEM);

996

997 vc->previous_window = -1;

998

999 ff_mdct_init(&vc->mdct[0], bl0, 1, -1.0);

1000 ff_mdct_init(&vc->mdct[1], bl1, 1, -1.0);

1001 vc->fdsp = avpriv_float_dsp_alloc(vc->avctx->flags & CODEC_FLAG_BITEXACT);

1002 if (!vc->fdsp)

1003 return AVERROR(ENOMEM);

1004

1005 av_dlog(NULL, " vorbis version %d \n audio_channels %d \n audio_samplerate %d \n bitrate_max %d \n bitrate_nom %d \n bitrate_min %d \n blk_0 %d blk_1 %d \n ",

1006 vc->version, vc->audio_channels, vc->audio_samplerate, vc->bitrate_maximum, vc->bitrate_nominal, vc->bitrate_minimum, vc->blocksize[0], vc->blocksize[1]);

1007

1008 /*

1009 BLK = vc->blocksize[0];

1010 for (i = 0; i < BLK / 2; ++i) {

1011 vc->win[0][i] = sin(0.5*3.14159265358*(sin(((float)i + 0.5) / (float)BLK*3.14159265358))*(sin(((float)i + 0.5) / (float)BLK*3.14159265358)));

1012 }

1013 */

1014

1015 return 0;

1016 }

1017

1018 // Process the extradata using the functions above (identification header, setup header)

1019

1020 static av_cold int vorbis_decode_init(AVCodecContext *avctx)

1021 {

1022 vorbis_context *vc = avctx->priv_data;

1023 uint8_t *headers = avctx->extradata;

1024 int headers_len = avctx->extradata_size;

1025 const uint8_t *header_start[3];

1026 int header_len[3];

1027 GetBitContext *gb = &vc->gb;

1028 int hdr_type, ret;

1029

1030 vc->avctx = avctx;

1031 ff_vorbisdsp_init(&vc->dsp);

1032

1033 avctx->sample_fmt = AV_SAMPLE_FMT_FLTP;

1034

1035 if (!headers_len) {

1036 av_log(avctx, AV_LOG_ERROR, "Extradata missing.\n");

1037 return AVERROR_INVALIDDATA;

1038 }

1039

1040 if ((ret = avpriv_split_xiph_headers(headers, headers_len, 30, header_start, header_len)) < 0) {

1041 av_log(avctx, AV_LOG_ERROR, "Extradata corrupt.\n");

1042 return ret;

1043 }

1044

1045 init_get_bits(gb, header_start[0], header_len[0]*8);

1046 hdr_type = get_bits(gb, 8);

1047 if (hdr_type != 1) {

1048 av_log(avctx, AV_LOG_ERROR, "First header is not the id header.\n");

1049 return AVERROR_INVALIDDATA;

1050 }

1051 if ((ret = vorbis_parse_id_hdr(vc))) {

1052 av_log(avctx, AV_LOG_ERROR, "Id header corrupt.\n");

1053 vorbis_free(vc);

1054 return ret;

1055 }

1056

1057 init_get_bits(gb, header_start[2], header_len[2]*8);

1058 hdr_type = get_bits(gb, 8);

1059 if (hdr_type != 5) {

1060 av_log(avctx, AV_LOG_ERROR, "Third header is not the setup header.\n");

1061 vorbis_free(vc);

1062 return AVERROR_INVALIDDATA;

1063 }

1064 if ((ret = vorbis_parse_setup_hdr(vc))) {

1065 av_log(avctx, AV_LOG_ERROR, "Setup header corrupt.\n");

1066 vorbis_free(vc);

1067 return ret;

1068 }

1069

1070 if (vc->audio_channels > 8)

1071 avctx->channel_layout = 0;

1072 else

1073 avctx->channel_layout = ff_vorbis_channel_layouts[vc->audio_channels - 1];

1074

1075 avctx->channels = vc->audio_channels;

1076 avctx->sample_rate = vc->audio_samplerate;

1077

1078 return 0;

1079 }

1080

1081 // Decode audiopackets -------------------------------------------------

1082

1083 // Read and decode floor

1084

1085 static int vorbis_floor0_decode(vorbis_context *vc,

1086 vorbis_floor_data *vfu, float *vec)

1087 {

1088 vorbis_floor0 *vf = &vfu->t0;

1089 float *lsp = vf->lsp;

1090 unsigned amplitude, book_idx;

1091 unsigned blockflag = vc->modes[vc->mode_number].blockflag;

1092

1093 if (!vf->amplitude_bits)

1094 return 1;

1095

1096 amplitude = get_bits(&vc->gb, vf->amplitude_bits);

1097 if (amplitude > 0) {

1098 float last = 0;

1099 unsigned idx, lsp_len = 0;

1100 vorbis_codebook codebook;

1101

1102 book_idx = get_bits(&vc->gb, ilog(vf->num_books));

1103 if (book_idx >= vf->num_books) {

1104 av_log(vc->avctx, AV_LOG_ERROR, "floor0 dec: booknumber too high!\n");

1105 book_idx = 0;

1106 }

1107 av_dlog(NULL, "floor0 dec: booknumber: %u\n", book_idx);

1108 codebook = vc->codebooks[vf->book_list[book_idx]];

1109 /* Invalid codebook! */

1110 if (!codebook.codevectors)

1111 return AVERROR_INVALIDDATA;

1112

1113 while (lsp_len<vf->order) {

1114 int vec_off;

1115

1116 av_dlog(NULL, "floor0 dec: book dimension: %d\n", codebook.dimensions);

1117 av_dlog(NULL, "floor0 dec: maximum depth: %d\n", codebook.maxdepth);

1118 /* read temp vector */

1119 vec_off = get_vlc2(&vc->gb, codebook.vlc.table,

1120 codebook.nb_bits, codebook.maxdepth)

1121 * codebook.dimensions;

1122 av_dlog(NULL, "floor0 dec: vector offset: %d\n", vec_off);

1123 /* copy each vector component and add last to it */

1124 for (idx = 0; idx < codebook.dimensions; ++idx)

1125 lsp[lsp_len+idx] = codebook.codevectors[vec_off+idx] + last;

1126 last = lsp[lsp_len+idx-1]; /* set last to last vector component */

1127

1128 lsp_len += codebook.dimensions;

1129 }

1130 /* DEBUG: output lsp coeffs */

1131 {

1132 int idx;

1133 for (idx = 0; idx < lsp_len; ++idx)

1134 av_dlog(NULL, "floor0 dec: coeff at %d is %f\n", idx, lsp[idx]);

1135 }

1136

1137 /* synthesize floor output vector */

1138 {

1139 int i;

1140 int order = vf->order;

1141 float wstep = M_PI / vf->bark_map_size;

1142

1143 for (i = 0; i < order; i++)

1144 lsp[i] = 2.0f * cos(lsp[i]);

1145

1146 av_dlog(NULL, "floor0 synth: map_size = %"PRIu32"; m = %d; wstep = %f\n",

1147 vf->map_size[blockflag], order, wstep);

1148

1149 i = 0;

1150 while (i < vf->map_size[blockflag]) {

1151 int j, iter_cond = vf->map[blockflag][i];

1152 float p = 0.5f;

1153 float q = 0.5f;

1154 float two_cos_w = 2.0f * cos(wstep * iter_cond); // needed all times

1155

1156 /* similar part for the q and p products */

1157 for (j = 0; j + 1 < order; j += 2) {

1158 q *= lsp[j] - two_cos_w;

1159 p *= lsp[j + 1] - two_cos_w;

1160 }

1161 if (j == order) { // even order

1162 p *= p * (2.0f - two_cos_w);

1163 q *= q * (2.0f + two_cos_w);

1164 } else { // odd order

1165 q *= two_cos_w-lsp[j]; // one more time for q

1166

1167 /* final step and square */

1168 p *= p * (4.f - two_cos_w * two_cos_w);

1169 q *= q;

1170 }

1171

1172 /* calculate linear floor value */

1173 q = exp((((amplitude*vf->amplitude_offset) /

1174 (((1 << vf->amplitude_bits) - 1) * sqrt(p + q)))

1175 - vf->amplitude_offset) * .11512925f);

1176

1177 /* fill vector */

1178 do {

1179 vec[i] = q; ++i;

1180 } while (vf->map[blockflag][i] == iter_cond);

1181 }

1182 }

1183 } else {

1184 /* this channel is unused */

1185 return 1;

1186 }

1187

1188 av_dlog(NULL, " Floor0 decoded\n");

1189

1190 return 0;

1191 }

1192

1193 static int vorbis_floor1_decode(vorbis_context *vc,

1194 vorbis_floor_data *vfu, float *vec)

1195 {

1196 vorbis_floor1 *vf = &vfu->t1;

1197 GetBitContext *gb = &vc->gb;

1198 uint16_t range_v[4] = { 256, 128, 86, 64 };

1199 unsigned range = range_v[vf->multiplier - 1];

1200 uint16_t floor1_Y[258];

1201 uint16_t floor1_Y_final[258];

1202 int floor1_flag[258];

1203 unsigned partition_class, cdim, cbits, csub, cval, offset, i, j;

1204 int book, adx, ady, dy, off, predicted, err;

1205

1206

1207 if (!get_bits1(gb)) // silence

1208 return 1;

1209

1210 // Read values (or differences) for the floor's points

1211

1212 floor1_Y[0] = get_bits(gb, ilog(range - 1));

1213 floor1_Y[1] = get_bits(gb, ilog(range - 1));

1214

1215 av_dlog(NULL, "floor 0 Y %d floor 1 Y %d \n", floor1_Y[0], floor1_Y[1]);

1216

1217 offset = 2;

1218 for (i = 0; i < vf->partitions; ++i) {

1219 partition_class = vf->partition_class[i];

1220 cdim = vf->class_dimensions[partition_class];

1221 cbits = vf->class_subclasses[partition_class];

1222 csub = (1 << cbits) - 1;

1223 cval = 0;

1224

1225 av_dlog(NULL, "Cbits %u\n", cbits);

1226

1227 if (cbits) // this reads all subclasses for this partition's class

1228 cval = get_vlc2(gb, vc->codebooks[vf->class_masterbook[partition_class]].vlc.table,

1229 vc->codebooks[vf->class_masterbook[partition_class]].nb_bits, 3);

1230

1231 for (j = 0; j < cdim; ++j) {

1232 book = vf->subclass_books[partition_class][cval & csub];

1233

1234 av_dlog(NULL, "book %d Cbits %u cval %u bits:%d\n",

1235 book, cbits, cval, get_bits_count(gb));

1236

1237 cval = cval >> cbits;

1238 if (book > -1) {

1239 int v = get_vlc2(gb, vc->codebooks[book].vlc.table,

1240 vc->codebooks[book].nb_bits, 3);

1241 if (v < 0)

1242 return AVERROR_INVALIDDATA;

1243 floor1_Y[offset+j] = v;

1244 } else {

1245 floor1_Y[offset+j] = 0;

1246 }

1247

1248 av_dlog(NULL, " floor(%d) = %d \n",

1249 vf->list[offset+j].x, floor1_Y[offset+j]);

1250 }

1251 offset+=cdim;

1252 }

1253

1254 // Amplitude calculation from the differences

1255

1256 floor1_flag[0] = 1;

1257 floor1_flag[1] = 1;

1258 floor1_Y_final[0] = floor1_Y[0];

1259 floor1_Y_final[1] = floor1_Y[1];

1260

1261 for (i = 2; i < vf->x_list_dim; ++i) {

1262 unsigned val, highroom, lowroom, room, high_neigh_offs, low_neigh_offs;

1263

1264 low_neigh_offs = vf->list[i].low;

1265 high_neigh_offs = vf->list[i].high;

1266 dy = floor1_Y_final[high_neigh_offs] - floor1_Y_final[low_neigh_offs]; // render_point begin

1267 adx = vf->list[high_neigh_offs].x - vf->list[low_neigh_offs].x;

1268 ady = FFABS(dy);

1269 err = ady * (vf->list[i].x - vf->list[low_neigh_offs].x);

1270 off = err / adx;

1271 if (dy < 0) {

1272 predicted = floor1_Y_final[low_neigh_offs] - off;

1273 } else {

1274 predicted = floor1_Y_final[low_neigh_offs] + off;

1275 } // render_point end

1276

1277 val = floor1_Y[i];

1278 highroom = range-predicted;

1279 lowroom = predicted;

1280 if (highroom < lowroom) {

1281 room = highroom * 2;

1282 } else {

1283 room = lowroom * 2; // SPEC misspelling

1284 }

1285 if (val) {

1286 floor1_flag[low_neigh_offs] = 1;

1287 floor1_flag[high_neigh_offs] = 1;

1288 floor1_flag[i] = 1;

1289 if (val >= room) {

1290 if (highroom > lowroom) {

1291 floor1_Y_final[i] = av_clip_uint16(val - lowroom + predicted);

1292 } else {

1293 floor1_Y_final[i] = av_clip_uint16(predicted - val + highroom - 1);

1294 }

1295 } else {

1296 if (val & 1) {

1297 floor1_Y_final[i] = av_clip_uint16(predicted - (val + 1) / 2);

1298 } else {

1299 floor1_Y_final[i] = av_clip_uint16(predicted + val / 2);

1300 }

1301 }

1302 } else {

1303 floor1_flag[i] = 0;

1304 floor1_Y_final[i] = av_clip_uint16(predicted);

1305 }

1306

1307 av_dlog(NULL, " Decoded floor(%d) = %u / val %u\n",

1308 vf->list[i].x, floor1_Y_final[i], val);

1309 }

1310

1311 // Curve synth - connect the calculated dots and convert from dB scale FIXME optimize ?

1312

1313 ff_vorbis_floor1_render_list(vf->list, vf->x_list_dim, floor1_Y_final, floor1_flag, vf->multiplier, vec, vf->list[1].x);

1314

1315 av_dlog(NULL, " Floor decoded\n");

1316

1317 return 0;

1318 }

1319

1320 static av_always_inline int setup_classifs(vorbis_context *vc,

1321 vorbis_residue *vr,

1322 uint8_t *do_not_decode,

1323 unsigned ch_used,

1324 int partition_count,

1325 int ptns_to_read

1326 )

1327 {

1328 int p, j, i;

1329 unsigned c_p_c = vc->codebooks[vr->classbook].dimensions;

1330 unsigned inverse_class = ff_inverse[vr->classifications];

1331 unsigned temp, temp2;

1332 for (p = 0, j = 0; j < ch_used; ++j) {

1333 if (!do_not_decode[j]) {

1334 temp = get_vlc2(&vc->gb, vc->codebooks[vr->classbook].vlc.table,

1335 vc->codebooks[vr->classbook].nb_bits, 3);

1336

1337 av_dlog(NULL, "Classword: %u\n", temp);

1338

1339 if ((int)temp < 0)

1340 return temp;

1341

1342 av_assert0(vr->classifications > 1); //needed for inverse[]

1343

1344 if (temp <= 65536) {

1345 for (i = partition_count + c_p_c - 1; i >= partition_count; i--) {

1346 temp2 = (((uint64_t)temp) * inverse_class) >> 32;

1347

1348 if (i < ptns_to_read)

1349 vr->classifs[p + i] = temp - temp2 * vr->classifications;

1350 temp = temp2;

1351 }

1352 } else {

1353 for (i = partition_count + c_p_c - 1; i >= partition_count; i--) {

1354 temp2 = temp / vr->classifications;

1355

1356 if (i < ptns_to_read)

1357 vr->classifs[p + i] = temp - temp2 * vr->classifications;

1358 temp = temp2;

1359 }

1360 }

1361 }

1362 p += ptns_to_read;

1363 }

1364 return 0;

1365 }

1366 // Read and decode residue

1367

1368 static av_always_inline int vorbis_residue_decode_internal(vorbis_context *vc,

1369 vorbis_residue *vr,

1370 unsigned ch,

1371 uint8_t *do_not_decode,

1372 float *vec,

1373 unsigned vlen,

1374 unsigned ch_left,

1375 int vr_type)

1376 {

1377 GetBitContext *gb = &vc->gb;

1378 unsigned c_p_c = vc->codebooks[vr->classbook].dimensions;

1379 uint8_t *classifs = vr->classifs;

1380 unsigned pass, ch_used, i, j, k, l;

1381 unsigned max_output = (ch - 1) * vlen;

1382 int ptns_to_read = vr->ptns_to_read;

1383 int libvorbis_bug = 0;

1384

1385 if (vr_type == 2) {

1386 for (j = 1; j < ch; ++j)

1387 do_not_decode[0] &= do_not_decode[j]; // FIXME - clobbering input

1388 if (do_not_decode[0])

1389 return 0;

1390 ch_used = 1;

1391 max_output += vr->end / ch;

1392 } else {

1393 ch_used = ch;

1394 max_output += vr->end;

1395 }

1396

1397 if (max_output > ch_left * vlen) {

1398 if (max_output <= ch_left * vlen + vr->partition_size*ch_used/ch) {

1399 ptns_to_read--;

1400 libvorbis_bug = 1;

1401 } else {

1402 av_log(vc->avctx, AV_LOG_ERROR, "Insufficient output buffer\n");

1403 return AVERROR_INVALIDDATA;

1404 }

1405 }

1406

1407 av_dlog(NULL, " residue type 0/1/2 decode begin, ch: %d cpc %d \n", ch, c_p_c);

1408

1409 for (pass = 0; pass <= vr->maxpass; ++pass) { // FIXME OPTIMIZE?

1410 int voffset, partition_count, j_times_ptns_to_read;

1411

1412 voffset = vr->begin;

1413 for (partition_count = 0; partition_count < ptns_to_read;) { // SPEC error

1414 if (!pass) {

1415 int ret;

1416 if ((ret = setup_classifs(vc, vr, do_not_decode, ch_used, partition_count, ptns_to_read)) < 0)

1417 return ret;

1418 }

1419 for (i = 0; (i < c_p_c) && (partition_count < ptns_to_read); ++i) {

1420 for (j_times_ptns_to_read = 0, j = 0; j < ch_used; ++j) {

1421 unsigned voffs;

1422

1423 if (!do_not_decode[j]) {

1424 unsigned vqclass = classifs[j_times_ptns_to_read + partition_count];

1425 int vqbook = vr->books[vqclass][pass];

1426

1427 if (vqbook >= 0 && vc->codebooks[vqbook].codevectors) {

1428 unsigned coffs;

1429 unsigned dim = vc->codebooks[vqbook].dimensions;

1430 unsigned step = FASTDIV(vr->partition_size << 1, dim << 1);

1431 vorbis_codebook codebook = vc->codebooks[vqbook];

1432

1433 if (vr_type == 0) {

1434

1435 voffs = voffset+j*vlen;

1436 for (k = 0; k < step; ++k) {

1437 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;

1438 for (l = 0; l < dim; ++l)

1439 vec[voffs + k + l * step] += codebook.codevectors[coffs + l];

1440 }

1441 } else if (vr_type == 1) {

1442 voffs = voffset + j * vlen;

1443 for (k = 0; k < step; ++k) {

1444 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;

1445 for (l = 0; l < dim; ++l, ++voffs) {

1446 vec[voffs]+=codebook.codevectors[coffs+l];

1447

1448 av_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d \n",

1449 pass, voffs, vec[voffs], codebook.codevectors[coffs+l], coffs);

1450 }

1451 }

1452 } else if (vr_type == 2 && ch == 2 && (voffset & 1) == 0 && (dim & 1) == 0) { // most frequent case optimized

1453 voffs = voffset >> 1;

1454

1455 if (dim == 2) {

1456 for (k = 0; k < step; ++k) {

1457 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * 2;

1458 vec[voffs + k ] += codebook.codevectors[coffs ];

1459 vec[voffs + k + vlen] += codebook.codevectors[coffs + 1];

1460 }

1461 } else if (dim == 4) {

1462 for (k = 0; k < step; ++k, voffs += 2) {

1463 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * 4;

1464 vec[voffs ] += codebook.codevectors[coffs ];

1465 vec[voffs + 1 ] += codebook.codevectors[coffs + 2];

1466 vec[voffs + vlen ] += codebook.codevectors[coffs + 1];

1467 vec[voffs + vlen + 1] += codebook.codevectors[coffs + 3];

1468 }

1469 } else

1470 for (k = 0; k < step; ++k) {

1471 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;

1472 for (l = 0; l < dim; l += 2, voffs++) {

1473 vec[voffs ] += codebook.codevectors[coffs + l ];

1474 vec[voffs + vlen] += codebook.codevectors[coffs + l + 1];

1475

1476 av_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",

1477 pass, voffset / ch + (voffs % ch) * vlen,

1478 vec[voffset / ch + (voffs % ch) * vlen],

1479 codebook.codevectors[coffs + l], coffs, l);

1480 }

1481 }

1482

1483 } else if (vr_type == 2) {

1484 unsigned voffs_div = FASTDIV(voffset << 1, ch <<1);

1485 unsigned voffs_mod = voffset - voffs_div * ch;

1486

1487 for (k = 0; k < step; ++k) {

1488 coffs = get_vlc2(gb, codebook.vlc.table, codebook.nb_bits, 3) * dim;

1489 for (l = 0; l < dim; ++l) {

1490 vec[voffs_div + voffs_mod * vlen] +=

1491 codebook.codevectors[coffs + l];

1492

1493 av_dlog(NULL, " pass %d offs: %d curr: %f change: %f cv offs.: %d+%d \n",

1494 pass, voffs_div + voffs_mod * vlen,

1495 vec[voffs_div + voffs_mod * vlen],

1496 codebook.codevectors[coffs + l], coffs, l);

1497

1498 if (++voffs_mod == ch) {

1499 voffs_div++;

1500 voffs_mod = 0;

1501 }

1502 }

1503 }

1504 }

1505 }

1506 }

1507 j_times_ptns_to_read += ptns_to_read;

1508 }

1509 ++partition_count;

1510 voffset += vr->partition_size;

1511 }

1512 }

1513 if (libvorbis_bug && !pass) {

1514 for (j = 0; j < ch_used; ++j) {

1515 if (!do_not_decode[j]) {

1516 get_vlc2(&vc->gb, vc->codebooks[vr->classbook].vlc.table,

1517 vc->codebooks[vr->classbook].nb_bits, 3);

1518 }

1519 }

1520 }

1521 }

1522 return 0;

1523 }

1524

1525 static inline int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr,

1526 unsigned ch,

1527 uint8_t *do_not_decode,

1528 float *vec, unsigned vlen,

1529 unsigned ch_left)

1530 {

1531 if (vr->type == 2)

1532 return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 2);

1533 else if (vr->type == 1)

1534 return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 1);

1535 else if (vr->type == 0)

1536 return vorbis_residue_decode_internal(vc, vr, ch, do_not_decode, vec, vlen, ch_left, 0);

1537 else {

1538 av_log(vc->avctx, AV_LOG_ERROR, " Invalid residue type while residue decode?! \n");

1539 return AVERROR_INVALIDDATA;

1540 }

1541 }

1542

1543 void ff_vorbis_inverse_coupling(float *mag, float *ang, intptr_t blocksize)

1544 {

1545 int i;

1546 for (i = 0; i < blocksize; i++) {

1547 if (mag[i] > 0.0) {

1548 if (ang[i] > 0.0) {

1549 ang[i] = mag[i] - ang[i];

1550 } else {

1551 float temp = ang[i];

1552 ang[i] = mag[i];

1553 mag[i] += temp;

1554 }

1555 } else {

1556 if (ang[i] > 0.0) {

1557 ang[i] += mag[i];

1558 } else {

1559 float temp = ang[i];

1560 ang[i] = mag[i];

1561 mag[i] -= temp;

1562 }

1563 }

1564 }

1565 }

1566

1567 // Decode the audio packet using the functions above

1568

1569 static int vorbis_parse_audio_packet(vorbis_context *vc, float **floor_ptr)

1570 {

1571 GetBitContext *gb = &vc->gb;

1572 FFTContext *mdct;

1573 int previous_window = vc->previous_window;

1574 unsigned mode_number, blockflag, blocksize;

1575 int i, j;

1576 uint8_t no_residue[255];

1577 uint8_t do_not_decode[255];

1578 vorbis_mapping *mapping;

1579 float *ch_res_ptr = vc->channel_residues;

1580 uint8_t res_chan[255];

1581 unsigned res_num = 0;

1582 int retlen = 0;

1583 unsigned ch_left = vc->audio_channels;

1584 unsigned vlen;

1585

1586 if (get_bits1(gb)) {

1587 av_log(vc->avctx, AV_LOG_ERROR, "Not a Vorbis I audio packet.\n");

1588 return AVERROR_INVALIDDATA; // packet type not audio

1589 }

1590

1591 if (vc->mode_count == 1) {

1592 mode_number = 0;

1593 } else {

1594 GET_VALIDATED_INDEX(mode_number, ilog(vc->mode_count-1), vc->mode_count)

1595 }

1596 vc->mode_number = mode_number;

1597 mapping = &vc->mappings[vc->modes[mode_number].mapping];

1598

1599 av_dlog(NULL, " Mode number: %u , mapping: %d , blocktype %d\n", mode_number,

1600 vc->modes[mode_number].mapping, vc->modes[mode_number].blockflag);

1601

1602 blockflag = vc->modes[mode_number].blockflag;

1603 blocksize = vc->blocksize[blockflag];

1604 vlen = blocksize / 2;

1605 if (blockflag) {

1606 int code = get_bits(gb, 2);

1607 if (previous_window < 0)

1608 previous_window = code>>1;

1609 } else if (previous_window < 0)

1610 previous_window = 0;

1611

1612 memset(ch_res_ptr, 0, sizeof(float) * vc->audio_channels * vlen); //FIXME can this be removed ?

1613 for (i = 0; i < vc->audio_channels; ++i)

1614 memset(floor_ptr[i], 0, vlen * sizeof(floor_ptr[0][0])); //FIXME can this be removed ?

1615

1616 // Decode floor

1617

1618 for (i = 0; i < vc->audio_channels; ++i) {

1619 vorbis_floor *floor;

1620 int ret;

1621 if (mapping->submaps > 1) {

1622 floor = &vc->floors[mapping->submap_floor[mapping->mux[i]]];

1623 } else {

1624 floor = &vc->floors[mapping->submap_floor[0]];

1625 }

1626

1627 ret = floor->decode(vc, &floor->data, floor_ptr[i]);

1628

1629 if (ret < 0) {

1630 av_log(vc->avctx, AV_LOG_ERROR, "Invalid codebook in vorbis_floor_decode.\n");

1631 return AVERROR_INVALIDDATA;

1632 }

1633 no_residue[i] = ret;

1634 }

1635

1636 // Nonzero vector propagate

1637

1638 for (i = mapping->coupling_steps - 1; i >= 0; --i) {

1639 if (!(no_residue[mapping->magnitude[i]] & no_residue[mapping->angle[i]])) {

1640 no_residue[mapping->magnitude[i]] = 0;

1641 no_residue[mapping->angle[i]] = 0;

1642 }

1643 }

1644

1645 // Decode residue

1646

1647 for (i = 0; i < mapping->submaps; ++i) {

1648 vorbis_residue *residue;

1649 unsigned ch = 0;

1650 int ret;

1651

1652 for (j = 0; j < vc->audio_channels; ++j) {

1653 if ((mapping->submaps == 1) || (i == mapping->mux[j])) {

1654 res_chan[j] = res_num;

1655 if (no_residue[j]) {

1656 do_not_decode[ch] = 1;

1657 } else {

1658 do_not_decode[ch] = 0;

1659 }

1660 ++ch;

1661 ++res_num;

1662 }

1663 }

1664 residue = &vc->residues[mapping->submap_residue[i]];

1665 if (ch_left < ch) {

1666 av_log(vc->avctx, AV_LOG_ERROR, "Too many channels in vorbis_floor_decode.\n");

1667 return AVERROR_INVALIDDATA;

1668 }

1669 if (ch) {

1670 ret = vorbis_residue_decode(vc, residue, ch, do_not_decode, ch_res_ptr, vlen, ch_left);

1671 if (ret < 0)

1672 return ret;

1673 }

1674

1675 ch_res_ptr += ch * vlen;

1676 ch_left -= ch;

1677 }

1678

1679 if (ch_left > 0)

1680 return AVERROR_INVALIDDATA;

1681

1682 // Inverse coupling

1683

1684 for (i = mapping->coupling_steps - 1; i >= 0; --i) { //warning: i has to be signed

1685 float *mag, *ang;

1686

1687 mag = vc->channel_residues+res_chan[mapping->magnitude[i]] * blocksize / 2;

1688 ang = vc->channel_residues+res_chan[mapping->angle[i]] * blocksize / 2;

1689 vc->dsp.vorbis_inverse_coupling(mag, ang, blocksize / 2);

1690 }

1691

1692 // Dotproduct, MDCT

1693

1694 mdct = &vc->mdct[blockflag];

1695

1696 for (j = vc->audio_channels-1;j >= 0; j--) {

1697 ch_res_ptr = vc->channel_residues + res_chan[j] * blocksize / 2;

1698 vc->fdsp->vector_fmul(floor_ptr[j], floor_ptr[j], ch_res_ptr, blocksize / 2);

1699 mdct->imdct_half(mdct, ch_res_ptr, floor_ptr[j]);

1700 }

1701

1702 // Overlap/add, save data for next overlapping

1703

1704 retlen = (blocksize + vc->blocksize[previous_window]) / 4;

1705 for (j = 0; j < vc->audio_channels; j++) {

1706 unsigned bs0 = vc->blocksize[0];

1707 unsigned bs1 = vc->blocksize[1];

1708 float *residue = vc->channel_residues + res_chan[j] * blocksize / 2;

1709 float *saved = vc->saved + j * bs1 / 4;

1710 float *ret = floor_ptr[j];

1711 float *buf = residue;

1712 const float *win = vc->win[blockflag & previous_window];

1713

1714 if (blockflag == previous_window) {

1715 vc->fdsp->vector_fmul_window(ret, saved, buf, win, blocksize / 4);

1716 } else if (blockflag > previous_window) {

1717 vc->fdsp->vector_fmul_window(ret, saved, buf, win, bs0 / 4);

1718 memcpy(ret+bs0/2, buf+bs0/4, ((bs1-bs0)/4) * sizeof(float));

1719 } else {

1720 memcpy(ret, saved, ((bs1 - bs0) / 4) * sizeof(float));

1721 vc->fdsp->vector_fmul_window(ret + (bs1 - bs0) / 4, saved + (bs1 - bs0) / 4, buf, win, bs0 / 4);

1722 }

1723 memcpy(saved, buf + blocksize / 4, blocksize / 4 * sizeof(float));

1724 }

1725

1726 vc->previous_window = blockflag;

1727 return retlen;

1728 }

1729

1730 // Return the decoded audio packet through the standard api

1731

1732 static int vorbis_decode_frame(AVCodecContext *avctx, void *data,

1733 int *got_frame_ptr, AVPacket *avpkt)

1734 {

1735 const uint8_t *buf = avpkt->data;

1736 int buf_size = avpkt->size;

1737 vorbis_context *vc = avctx->priv_data;

1738 AVFrame *frame = data;

1739 GetBitContext *gb = &vc->gb;

1740 float *channel_ptrs[255];

1741 int i, len, ret;

1742

1743 av_dlog(NULL, "packet length %d \n", buf_size);

1744

1745 if (*buf == 1 && buf_size > 7) {

1746 init_get_bits(gb, buf+1, buf_size*8 - 8);

1747 vorbis_free(vc);

1748 if ((ret = vorbis_parse_id_hdr(vc))) {

1749 av_log(avctx, AV_LOG_ERROR, "Id header corrupt.\n");

1750 vorbis_free(vc);

1751 return ret;

1752 }

1753

1754 if (vc->audio_channels > 8)

1755 avctx->channel_layout = 0;

1756 else

1757 avctx->channel_layout = ff_vorbis_channel_layouts[vc->audio_channels - 1];

1758

1759 avctx->channels = vc->audio_channels;

1760 avctx->sample_rate = vc->audio_samplerate;

1761 return buf_size;

1762 }

1763

1764 if (*buf == 3 && buf_size > 7) {

1765 av_log(avctx, AV_LOG_DEBUG, "Ignoring comment header\n");

1766 return buf_size;

1767 }

1768

1769 if (*buf == 5 && buf_size > 7 && vc->channel_residues && !vc->modes) {

1770 init_get_bits(gb, buf+1, buf_size*8 - 8);

1771 if ((ret = vorbis_parse_setup_hdr(vc))) {

1772 av_log(avctx, AV_LOG_ERROR, "Setup header corrupt.\n");

1773 vorbis_free(vc);

1774 return ret;

1775 }

1776 return buf_size;

1777 }

1778

1779 if (!vc->channel_residues || !vc->modes) {

1780 av_log(avctx, AV_LOG_ERROR, "Data packet before valid headers\n");

1781 return AVERROR_INVALIDDATA;

1782 }

1783

1784 /* get output buffer */

1785 frame->nb_samples = vc->blocksize[1] / 2;

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

1787 return ret;

1788

1789 if (vc->audio_channels > 8) {

1790 for (i = 0; i < vc->audio_channels; i++)

1791 channel_ptrs[i] = (float *)frame->extended_data[i];

1792 } else {

1793 for (i = 0; i < vc->audio_channels; i++) {

1794 int ch = ff_vorbis_channel_layout_offsets[vc->audio_channels - 1][i];

1795 channel_ptrs[ch] = (float *)frame->extended_data[i];

1796 }

1797 }

1798

1799 init_get_bits(gb, buf, buf_size*8);

1800

1801 if ((len = vorbis_parse_audio_packet(vc, channel_ptrs)) <= 0)

1802 return len;

1803

1804 if (!vc->first_frame) {

1805 vc->first_frame = 1;

1806 *got_frame_ptr = 0;

1807 av_frame_unref(frame);

1808 return buf_size;

1809 }

1810

1811 av_dlog(NULL, "parsed %d bytes %d bits, returned %d samples (*ch*bits) \n",

1812 get_bits_count(gb) / 8, get_bits_count(gb) % 8, len);

1813

1814 frame->nb_samples = len;

1815 *got_frame_ptr = 1;

1816

1817 return buf_size;

1818 }

1819

1820 // Close decoder

1821

1822 static av_cold int vorbis_decode_close(AVCodecContext *avctx)

1823 {

1824 vorbis_context *vc = avctx->priv_data;

1825

1826 vorbis_free(vc);

1827

1828 return 0;

1829 }

1830

1831 static av_cold void vorbis_decode_flush(AVCodecContext *avctx)

1832 {

1833 vorbis_context *vc = avctx->priv_data;

1834

1835 if (vc->saved) {

1836 memset(vc->saved, 0, (vc->blocksize[1] / 4) * vc->audio_channels *

1837 sizeof(*vc->saved));

1838 }

1839 vc->previous_window = -1;

1840 vc->first_frame = 0;

1841 }

1842

1843 AVCodec ff_vorbis_decoder = {

1844 .name = "vorbis",

1845 .long_name = NULL_IF_CONFIG_SMALL("Vorbis"),

1846 .type = AVMEDIA_TYPE_AUDIO,

1847 .id = AV_CODEC_ID_VORBIS,

1848 .priv_data_size = sizeof(vorbis_context),

1849 .init = vorbis_decode_init,

1850 .close = vorbis_decode_close,

1851 .decode = vorbis_decode_frame,

1852 .flush = vorbis_decode_flush,

1853 .capabilities = CODEC_CAP_DR1,

1854 .channel_layouts = ff_vorbis_channel_layouts,

1855 .sample_fmts = (const enum AVSampleFormat[]) { AV_SAMPLE_FMT_FLTP,

1856 AV_SAMPLE_FMT_NONE },

1857 };

Generated on Sun Mar 8 2015 02:35:02 for FFmpeg by doxygen 1.8.2