FFmpeg: libavcodec/adpcm.c Source File

FFmpeg

[フレーム]

libavcodec

adpcm.c

Go to the documentation of this file.

1 /*

3 *

4 * first version by Francois Revol (revol@free.fr)

5 * fringe ADPCM codecs (e.g., DK3, DK4, Westwood)

6 * by Mike Melanson (melanson@pcisys.net)

7 * CD-ROM XA ADPCM codec by BERO

8 * EA ADPCM decoder by Robin Kay (komadori@myrealbox.com)

9 * EA ADPCM R1/R2/R3 decoder by Peter Ross (pross@xvid.org)

10 * EA IMA EACS decoder by Peter Ross (pross@xvid.org)

11 * EA IMA SEAD decoder by Peter Ross (pross@xvid.org)

12 * EA ADPCM XAS decoder by Peter Ross (pross@xvid.org)

13 * MAXIS EA ADPCM decoder by Robert Marston (rmarston@gmail.com)

14 * THP ADPCM decoder by Marco Gerards (mgerards@xs4all.nl)

15 *

16 * This file is part of FFmpeg.

17 *

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

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

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

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

22 *

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

24 * but WITHOUT ANY WARRANTY; without even the implied warranty of

25 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

26 * Lesser General Public License for more details.

27 *

28 * You should have received a copy of the GNU Lesser General Public

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

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

31 */

32 #include "avcodec.h"

33 #include "get_bits.h"

34 #include "bytestream.h"

35 #include "adpcm.h"

36 #include "adpcm_data.h"

37 #include "internal.h"

39 /**

40 * @file

41 * ADPCM decoders

42 * Features and limitations:

43 *

44 * Reference documents:

45 * http://wiki.multimedia.cx/index.php?title=Category:ADPCM_Audio_Codecs

46 * http://www.pcisys.net/~melanson/codecs/simpleaudio.html [dead]

47 * http://www.geocities.com/SiliconValley/8682/aud3.txt [dead]

48 * http://openquicktime.sourceforge.net/

49 * XAnim sources (xa_codec.c) http://xanim.polter.net/

50 * http://www.cs.ucla.edu/~leec/mediabench/applications.html [dead]

51 * SoX source code http://sox.sourceforge.net/

52 *

53 * CD-ROM XA:

54 * http://ku-www.ss.titech.ac.jp/~yatsushi/xaadpcm.html [dead]

55 * vagpack & depack http://homepages.compuserve.de/bITmASTER32/psx-index.html [dead]

56 * readstr http://www.geocities.co.jp/Playtown/2004/

57 */

59 /* These are for CD-ROM XA ADPCM */

60 static const int xa_adpcm_table[5][2] = {

61 { 0, 0 },

62 { 60, 0 },

63 { 115, -52 },

64 { 98, -55 },

65 { 122, -60 }

66 };

68 static const int ea_adpcm_table[] = {

69 0, 240, 460, 392,

70 0, 0, -208, -220,

71 0, 1, 3, 4,

72 7, 8, 10, 11,

73 0, -1, -3, -4

74 };

76 // padded to zero where table size is less then 16

77 static const int swf_index_tables[4][16] = {

78 /*2*/ { -1, 2 },

79 /*3*/ { -1, -1, 2, 4 },

80 /*4*/ { -1, -1, -1, -1, 2, 4, 6, 8 },

81 /*5*/ { -1, -1, -1, -1, -1, -1, -1, -1, 1, 2, 4, 6, 8, 10, 13, 16 }

82 };

84 /* end of tables */

86 typedef struct ADPCMDecodeContext {

87 ADPCMChannelStatus status[6];

88 int vqa_version; /**< VQA version. Used for ADPCM_IMA_WS */

89 } ADPCMDecodeContext;

91 static av_cold int adpcm_decode_init(AVCodecContext * avctx)

92 {

93 ADPCMDecodeContext *c = avctx->priv_data;

94 unsigned int min_channels = 1;

95 unsigned int max_channels = 2;

97 switch(avctx->codec->id) {

98 case AV_CODEC_ID_ADPCM_DTK:

99 case AV_CODEC_ID_ADPCM_EA:

100 min_channels = 2;

101 break;

102 case AV_CODEC_ID_ADPCM_AFC:

103 case AV_CODEC_ID_ADPCM_EA_R1:

104 case AV_CODEC_ID_ADPCM_EA_R2:

105 case AV_CODEC_ID_ADPCM_EA_R3:

106 case AV_CODEC_ID_ADPCM_EA_XAS:

107 case AV_CODEC_ID_ADPCM_THP:

108 max_channels = 6;

109 break;

110 }

111 if (avctx->channels < min_channels || avctx->channels > max_channels) {

112 av_log(avctx, AV_LOG_ERROR, "Invalid number of channels\n");

113 return AVERROR(EINVAL);

114 }

115

116 switch(avctx->codec->id) {

117 case AV_CODEC_ID_ADPCM_CT:

118 c->status[0].step = c->status[1].step = 511;

119 break;

120 case AV_CODEC_ID_ADPCM_IMA_WAV:

121 if (avctx->bits_per_coded_sample < 2 || avctx->bits_per_coded_sample > 5)

122 return AVERROR_INVALIDDATA;

123 break;

124 case AV_CODEC_ID_ADPCM_IMA_APC:

125 if (avctx->extradata && avctx->extradata_size >= 8) {

126 c->status[0].predictor = AV_RL32(avctx->extradata);

127 c->status[1].predictor = AV_RL32(avctx->extradata + 4);

128 }

129 break;

130 case AV_CODEC_ID_ADPCM_IMA_WS:

131 if (avctx->extradata && avctx->extradata_size >= 2)

132 c->vqa_version = AV_RL16(avctx->extradata);

133 break;

134 default:

135 break;

136 }

137

138 switch(avctx->codec->id) {

139 case AV_CODEC_ID_ADPCM_IMA_QT:

140 case AV_CODEC_ID_ADPCM_IMA_WAV:

141 case AV_CODEC_ID_ADPCM_4XM:

142 case AV_CODEC_ID_ADPCM_XA:

143 case AV_CODEC_ID_ADPCM_EA_R1:

144 case AV_CODEC_ID_ADPCM_EA_R2:

145 case AV_CODEC_ID_ADPCM_EA_R3:

146 case AV_CODEC_ID_ADPCM_EA_XAS:

147 case AV_CODEC_ID_ADPCM_THP:

148 case AV_CODEC_ID_ADPCM_AFC:

149 case AV_CODEC_ID_ADPCM_DTK:

150 avctx->sample_fmt = AV_SAMPLE_FMT_S16P;

151 break;

152 case AV_CODEC_ID_ADPCM_IMA_WS:

153 avctx->sample_fmt = c->vqa_version == 3 ? AV_SAMPLE_FMT_S16P :

154 AV_SAMPLE_FMT_S16;

155 break;

156 default:

157 avctx->sample_fmt = AV_SAMPLE_FMT_S16;

158 }

159

160 return 0;

161 }

162

163 static inline short adpcm_ima_expand_nibble(ADPCMChannelStatus *c, char nibble, int shift)

164 {

165 int step_index;

166 int predictor;

167 int sign, delta, diff, step;

168

169 step = ff_adpcm_step_table[c->step_index];

170 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];

171 step_index = av_clip(step_index, 0, 88);

172

173 sign = nibble & 8;

174 delta = nibble & 7;

175 /* perform direct multiplication instead of series of jumps proposed by

176 * the reference ADPCM implementation since modern CPUs can do the mults

177 * quickly enough */

178 diff = ((2 * delta + 1) * step) >> shift;

179 predictor = c->predictor;

180 if (sign) predictor -= diff;

181 else predictor += diff;

182

183 c->predictor = av_clip_int16(predictor);

184 c->step_index = step_index;

185

186 return (short)c->predictor;

187 }

188

189 static inline int16_t adpcm_ima_wav_expand_nibble(ADPCMChannelStatus *c, GetBitContext *gb, int bps)

190 {

191 int nibble, step_index, predictor, sign, delta, diff, step, shift;

192

193 shift = bps - 1;

194 nibble = get_bits_le(gb, bps),

195 step = ff_adpcm_step_table[c->step_index];

196 step_index = c->step_index + ff_adpcm_index_tables[bps - 2][nibble];

197 step_index = av_clip(step_index, 0, 88);

198

199 sign = nibble & (1 << shift);

200 delta = nibble & ((1 << shift) - 1);

201 diff = ((2 * delta + 1) * step) >> shift;

202 predictor = c->predictor;

203 if (sign) predictor -= diff;

204 else predictor += diff;

205

206 c->predictor = av_clip_int16(predictor);

207 c->step_index = step_index;

208

209 return (int16_t)c->predictor;

210 }

211

212 static inline int adpcm_ima_qt_expand_nibble(ADPCMChannelStatus *c, int nibble, int shift)

213 {

214 int step_index;

215 int predictor;

216 int diff, step;

217

218 step = ff_adpcm_step_table[c->step_index];

219 step_index = c->step_index + ff_adpcm_index_table[nibble];

220 step_index = av_clip(step_index, 0, 88);

221

222 diff = step >> 3;

223 if (nibble & 4) diff += step;

224 if (nibble & 2) diff += step >> 1;

225 if (nibble & 1) diff += step >> 2;

226

227 if (nibble & 8)

228 predictor = c->predictor - diff;

229 else

230 predictor = c->predictor + diff;

231

232 c->predictor = av_clip_int16(predictor);

233 c->step_index = step_index;

234

235 return c->predictor;

236 }

237

238 static inline short adpcm_ms_expand_nibble(ADPCMChannelStatus *c, int nibble)

239 {

240 int predictor;

241

242 predictor = (((c->sample1) * (c->coeff1)) + ((c->sample2) * (c->coeff2))) / 64;

243 predictor += ((nibble & 0x08)?(nibble - 0x10):(nibble)) * c->idelta;

244

245 c->sample2 = c->sample1;

246 c->sample1 = av_clip_int16(predictor);

247 c->idelta = (ff_adpcm_AdaptationTable[(int)nibble] * c->idelta) >> 8;

248 if (c->idelta < 16) c->idelta = 16;

249 if (c->idelta > INT_MAX/768) {

250 av_log(NULL, AV_LOG_WARNING, "idelta overflow\n");

251 c->idelta = INT_MAX/768;

252 }

253

254 return c->sample1;

255 }

256

257 static inline short adpcm_ima_oki_expand_nibble(ADPCMChannelStatus *c, int nibble)

258 {

259 int step_index, predictor, sign, delta, diff, step;

260

261 step = ff_adpcm_oki_step_table[c->step_index];

262 step_index = c->step_index + ff_adpcm_index_table[(unsigned)nibble];

263 step_index = av_clip(step_index, 0, 48);

264

265 sign = nibble & 8;

266 delta = nibble & 7;

267 diff = ((2 * delta + 1) * step) >> 3;

268 predictor = c->predictor;

269 if (sign) predictor -= diff;

270 else predictor += diff;

271

272 c->predictor = av_clip_intp2(predictor, 11);

273 c->step_index = step_index;

274

275 return c->predictor << 4;

276 }

277

278 static inline short adpcm_ct_expand_nibble(ADPCMChannelStatus *c, char nibble)

279 {

280 int sign, delta, diff;

281 int new_step;

282

283 sign = nibble & 8;

284 delta = nibble & 7;

285 /* perform direct multiplication instead of series of jumps proposed by

286 * the reference ADPCM implementation since modern CPUs can do the mults

287 * quickly enough */

288 diff = ((2 * delta + 1) * c->step) >> 3;

289 /* predictor update is not so trivial: predictor is multiplied on 254/256 before updating */

290 c->predictor = ((c->predictor * 254) >> 8) + (sign ? -diff : diff);

291 c->predictor = av_clip_int16(c->predictor);

292 /* calculate new step and clamp it to range 511..32767 */

293 new_step = (ff_adpcm_AdaptationTable[nibble & 7] * c->step) >> 8;

294 c->step = av_clip(new_step, 511, 32767);

295

296 return (short)c->predictor;

297 }

298

299 static inline short adpcm_sbpro_expand_nibble(ADPCMChannelStatus *c, char nibble, int size, int shift)

300 {

301 int sign, delta, diff;

302

303 sign = nibble & (1<<(size-1));

304 delta = nibble & ((1<<(size-1))-1);

305 diff = delta << (7 + c->step + shift);

306

307 /* clamp result */

308 c->predictor = av_clip(c->predictor + (sign ? -diff : diff), -16384,16256);

309

310 /* calculate new step */

311 if (delta >= (2*size - 3) && c->step < 3)

312 c->step++;

313 else if (delta == 0 && c->step > 0)

314 c->step--;

315

316 return (short) c->predictor;

317 }

318

319 static inline short adpcm_yamaha_expand_nibble(ADPCMChannelStatus *c, unsigned char nibble)

320 {

321 if(!c->step) {

322 c->predictor = 0;

323 c->step = 127;

324 }

325

326 c->predictor += (c->step * ff_adpcm_yamaha_difflookup[nibble]) / 8;

327 c->predictor = av_clip_int16(c->predictor);

328 c->step = (c->step * ff_adpcm_yamaha_indexscale[nibble]) >> 8;

329 c->step = av_clip(c->step, 127, 24567);

330 return c->predictor;

331 }

332

333 static int xa_decode(AVCodecContext *avctx, int16_t *out0, int16_t *out1,

334 const uint8_t *in, ADPCMChannelStatus *left,

335 ADPCMChannelStatus *right, int channels, int sample_offset)

336 {

337 int i, j;

338 int shift,filter,f0,f1;

339 int s_1,s_2;

340 int d,s,t;

341

342 out0 += sample_offset;

343 if (channels == 1)

344 out1 = out0 + 28;

345 else

346 out1 += sample_offset;

347

348 for(i=0;i<4;i++) {

349 shift = 12 - (in[4+i*2] & 15);

350 filter = in[4+i*2] >> 4;

351 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {

352 avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);

353 filter=0;

354 }

355 f0 = xa_adpcm_table[filter][0];

356 f1 = xa_adpcm_table[filter][1];

357

358 s_1 = left->sample1;

359 s_2 = left->sample2;

360

361 for(j=0;j<28;j++) {

362 d = in[16+i+j*4];

363

364 t = sign_extend(d, 4);

365 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);

366 s_2 = s_1;

367 s_1 = av_clip_int16(s);

368 out0[j] = s_1;

369 }

370

371 if (channels == 2) {

372 left->sample1 = s_1;

373 left->sample2 = s_2;

374 s_1 = right->sample1;

375 s_2 = right->sample2;

376 }

377

378 shift = 12 - (in[5+i*2] & 15);

379 filter = in[5+i*2] >> 4;

380 if (filter >= FF_ARRAY_ELEMS(xa_adpcm_table)) {

381 avpriv_request_sample(avctx, "unknown XA-ADPCM filter %d", filter);

382 filter=0;

383 }

384

385 f0 = xa_adpcm_table[filter][0];

386 f1 = xa_adpcm_table[filter][1];

387

388 for(j=0;j<28;j++) {

389 d = in[16+i+j*4];

390

391 t = sign_extend(d >> 4, 4);

392 s = ( t<<shift ) + ((s_1*f0 + s_2*f1+32)>>6);

393 s_2 = s_1;

394 s_1 = av_clip_int16(s);

395 out1[j] = s_1;

396 }

397

398 if (channels == 2) {

399 right->sample1 = s_1;

400 right->sample2 = s_2;

401 } else {

402 left->sample1 = s_1;

403 left->sample2 = s_2;

404 }

405

406 out0 += 28 * (3 - channels);

407 out1 += 28 * (3 - channels);

408 }

409

410 return 0;

411 }

412

413 static void adpcm_swf_decode(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int16_t *samples)

414 {

415 ADPCMDecodeContext *c = avctx->priv_data;

416 GetBitContext gb;

417 const int *table;

418 int k0, signmask, nb_bits, count;

419 int size = buf_size*8;

420 int i;

421

422 init_get_bits(&gb, buf, size);

423

424 //read bits & initial values

425 nb_bits = get_bits(&gb, 2)+2;

426 table = swf_index_tables[nb_bits-2];

427 k0 = 1 << (nb_bits-2);

428 signmask = 1 << (nb_bits-1);

429

430 while (get_bits_count(&gb) <= size - 22*avctx->channels) {

431 for (i = 0; i < avctx->channels; i++) {

432 *samples++ = c->status[i].predictor = get_sbits(&gb, 16);

433 c->status[i].step_index = get_bits(&gb, 6);

434 }

435

436 for (count = 0; get_bits_count(&gb) <= size - nb_bits*avctx->channels && count < 4095; count++) {

437 int i;

438

439 for (i = 0; i < avctx->channels; i++) {

440 // similar to IMA adpcm

441 int delta = get_bits(&gb, nb_bits);

442 int step = ff_adpcm_step_table[c->status[i].step_index];

443 long vpdiff = 0; // vpdiff = (delta+0.5)*step/4

444 int k = k0;

445

446 do {

447 if (delta & k)

448 vpdiff += step;

449 step >>= 1;

450 k >>= 1;

451 } while(k);

452 vpdiff += step;

453

454 if (delta & signmask)

455 c->status[i].predictor -= vpdiff;

456 else

457 c->status[i].predictor += vpdiff;

458

459 c->status[i].step_index += table[delta & (~signmask)];

460

461 c->status[i].step_index = av_clip(c->status[i].step_index, 0, 88);

462 c->status[i].predictor = av_clip_int16(c->status[i].predictor);

463

464 *samples++ = c->status[i].predictor;

465 }

466 }

467 }

468 }

469

470 /**

471 * Get the number of samples that will be decoded from the packet.

472 * In one case, this is actually the maximum number of samples possible to

473 * decode with the given buf_size.

474 *

475 * @param[out] coded_samples set to the number of samples as coded in the

476 * packet, or 0 if the codec does not encode the

477 * number of samples in each frame.

478 * @param[out] approx_nb_samples set to non-zero if the number of samples

479 * returned is an approximation.

480 */

481 static int get_nb_samples(AVCodecContext *avctx, GetByteContext *gb,

482 int buf_size, int *coded_samples, int *approx_nb_samples)

483 {

484 ADPCMDecodeContext *s = avctx->priv_data;

485 int nb_samples = 0;

486 int ch = avctx->channels;

487 int has_coded_samples = 0;

488 int header_size;

489

490 *coded_samples = 0;

491 *approx_nb_samples = 0;

492

493 if(ch <= 0)

494 return 0;

495

496 switch (avctx->codec->id) {

497 /* constant, only check buf_size */

498 case AV_CODEC_ID_ADPCM_EA_XAS:

499 if (buf_size < 76 * ch)

500 return 0;

501 nb_samples = 128;

502 break;

503 case AV_CODEC_ID_ADPCM_IMA_QT:

504 if (buf_size < 34 * ch)

505 return 0;

506 nb_samples = 64;

507 break;

508 /* simple 4-bit adpcm */

509 case AV_CODEC_ID_ADPCM_CT:

510 case AV_CODEC_ID_ADPCM_IMA_APC:

511 case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:

512 case AV_CODEC_ID_ADPCM_IMA_OKI:

513 case AV_CODEC_ID_ADPCM_IMA_WS:

514 case AV_CODEC_ID_ADPCM_YAMAHA:

515 nb_samples = buf_size * 2 / ch;

516 break;

517 }

518 if (nb_samples)

519 return nb_samples;

520

521 /* simple 4-bit adpcm, with header */

522 header_size = 0;

523 switch (avctx->codec->id) {

524 case AV_CODEC_ID_ADPCM_4XM:

525 case AV_CODEC_ID_ADPCM_IMA_ISS: header_size = 4 * ch; break;

526 case AV_CODEC_ID_ADPCM_IMA_AMV: header_size = 8; break;

527 case AV_CODEC_ID_ADPCM_IMA_SMJPEG: header_size = 4 * ch; break;

528 }

529 if (header_size > 0)

530 return (buf_size - header_size) * 2 / ch;

531

532 /* more complex formats */

533 switch (avctx->codec->id) {

534 case AV_CODEC_ID_ADPCM_EA:

535 has_coded_samples = 1;

536 *coded_samples = bytestream2_get_le32(gb);

537 *coded_samples -= *coded_samples % 28;

538 nb_samples = (buf_size - 12) / 30 * 28;

539 break;

540 case AV_CODEC_ID_ADPCM_IMA_EA_EACS:

541 has_coded_samples = 1;

542 *coded_samples = bytestream2_get_le32(gb);

543 nb_samples = (buf_size - (4 + 8 * ch)) * 2 / ch;

544 break;

545 case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:

546 nb_samples = (buf_size - ch) / ch * 2;

547 break;

548 case AV_CODEC_ID_ADPCM_EA_R1:

549 case AV_CODEC_ID_ADPCM_EA_R2:

550 case AV_CODEC_ID_ADPCM_EA_R3:

551 /* maximum number of samples */

552 /* has internal offsets and a per-frame switch to signal raw 16-bit */

553 has_coded_samples = 1;

554 switch (avctx->codec->id) {

555 case AV_CODEC_ID_ADPCM_EA_R1:

556 header_size = 4 + 9 * ch;

557 *coded_samples = bytestream2_get_le32(gb);

558 break;

559 case AV_CODEC_ID_ADPCM_EA_R2:

560 header_size = 4 + 5 * ch;

561 *coded_samples = bytestream2_get_le32(gb);

562 break;

563 case AV_CODEC_ID_ADPCM_EA_R3:

564 header_size = 4 + 5 * ch;

565 *coded_samples = bytestream2_get_be32(gb);

566 break;

567 }

568 *coded_samples -= *coded_samples % 28;

569 nb_samples = (buf_size - header_size) * 2 / ch;

570 nb_samples -= nb_samples % 28;

571 *approx_nb_samples = 1;

572 break;

573 case AV_CODEC_ID_ADPCM_IMA_DK3:

574 if (avctx->block_align > 0)

575 buf_size = FFMIN(buf_size, avctx->block_align);

576 nb_samples = ((buf_size - 16) * 2 / 3 * 4) / ch;

577 break;

578 case AV_CODEC_ID_ADPCM_IMA_DK4:

579 if (avctx->block_align > 0)

580 buf_size = FFMIN(buf_size, avctx->block_align);

581 nb_samples = 1 + (buf_size - 4 * ch) * 2 / ch;

582 break;

583 case AV_CODEC_ID_ADPCM_IMA_RAD:

584 if (avctx->block_align > 0)

585 buf_size = FFMIN(buf_size, avctx->block_align);

586 nb_samples = (buf_size - 4 * ch) * 2 / ch;

587 break;

588 case AV_CODEC_ID_ADPCM_IMA_WAV:

589 {

590 int bsize = ff_adpcm_ima_block_sizes[avctx->bits_per_coded_sample - 2];

591 int bsamples = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];

592 if (avctx->block_align > 0)

593 buf_size = FFMIN(buf_size, avctx->block_align);

594 nb_samples = 1 + (buf_size - 4 * ch) / (bsize * ch) * bsamples;

595 break;

596 }

597 case AV_CODEC_ID_ADPCM_MS:

598 if (avctx->block_align > 0)

599 buf_size = FFMIN(buf_size, avctx->block_align);

600 nb_samples = 2 + (buf_size - 7 * ch) * 2 / ch;

601 break;

602 case AV_CODEC_ID_ADPCM_SBPRO_2:

603 case AV_CODEC_ID_ADPCM_SBPRO_3:

604 case AV_CODEC_ID_ADPCM_SBPRO_4:

605 {

606 int samples_per_byte;

607 switch (avctx->codec->id) {

608 case AV_CODEC_ID_ADPCM_SBPRO_2: samples_per_byte = 4; break;

609 case AV_CODEC_ID_ADPCM_SBPRO_3: samples_per_byte = 3; break;

610 case AV_CODEC_ID_ADPCM_SBPRO_4: samples_per_byte = 2; break;

611 }

612 if (!s->status[0].step_index) {

613 nb_samples++;

614 buf_size -= ch;

615 }

616 nb_samples += buf_size * samples_per_byte / ch;

617 break;

618 }

619 case AV_CODEC_ID_ADPCM_SWF:

620 {

621 int buf_bits = buf_size * 8 - 2;

622 int nbits = (bytestream2_get_byte(gb) >> 6) + 2;

623 int block_hdr_size = 22 * ch;

624 int block_size = block_hdr_size + nbits * ch * 4095;

625 int nblocks = buf_bits / block_size;

626 int bits_left = buf_bits - nblocks * block_size;

627 nb_samples = nblocks * 4096;

628 if (bits_left >= block_hdr_size)

629 nb_samples += 1 + (bits_left - block_hdr_size) / (nbits * ch);

630 break;

631 }

632 case AV_CODEC_ID_ADPCM_THP:

633 if (avctx->extradata) {

634 nb_samples = buf_size / (8 * ch) * 14;

635 break;

636 }

637 has_coded_samples = 1;

638 bytestream2_skip(gb, 4); // channel size

639 *coded_samples = bytestream2_get_be32(gb);

640 *coded_samples -= *coded_samples % 14;

641 nb_samples = (buf_size - (8 + 36 * ch)) / (8 * ch) * 14;

642 break;

643 case AV_CODEC_ID_ADPCM_AFC:

644 nb_samples = buf_size / (9 * ch) * 16;

645 break;

646 case AV_CODEC_ID_ADPCM_XA:

647 nb_samples = (buf_size / 128) * 224 / ch;

648 break;

649 case AV_CODEC_ID_ADPCM_DTK:

650 nb_samples = buf_size / (16 * ch) * 28;

651 break;

652 }

653

654 /* validate coded sample count */

655 if (has_coded_samples && (*coded_samples <= 0 || *coded_samples > nb_samples))

656 return AVERROR_INVALIDDATA;

657

658 return nb_samples;

659 }

660

661 static int adpcm_decode_frame(AVCodecContext *avctx, void *data,

662 int *got_frame_ptr, AVPacket *avpkt)

663 {

664 AVFrame *frame = data;

665 const uint8_t *buf = avpkt->data;

666 int buf_size = avpkt->size;

667 ADPCMDecodeContext *c = avctx->priv_data;

668 ADPCMChannelStatus *cs;

669 int n, m, channel, i;

670 short *samples;

671 int16_t **samples_p;

672 int st; /* stereo */

673 int count1, count2;

674 int nb_samples, coded_samples, approx_nb_samples, ret;

675 GetByteContext gb;

676

677 bytestream2_init(&gb, buf, buf_size);

678 nb_samples = get_nb_samples(avctx, &gb, buf_size, &coded_samples, &approx_nb_samples);

679 if (nb_samples <= 0) {

680 av_log(avctx, AV_LOG_ERROR, "invalid number of samples in packet\n");

681 return AVERROR_INVALIDDATA;

682 }

683

684 /* get output buffer */

685 frame->nb_samples = nb_samples;

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

687 return ret;

688 samples = (short *)frame->data[0];

689 samples_p = (int16_t **)frame->extended_data;

690

691 /* use coded_samples when applicable */

692 /* it is always <= nb_samples, so the output buffer will be large enough */

693 if (coded_samples) {

694 if (!approx_nb_samples && coded_samples != nb_samples)

695 av_log(avctx, AV_LOG_WARNING, "mismatch in coded sample count\n");

696 frame->nb_samples = nb_samples = coded_samples;

697 }

698

699 st = avctx->channels == 2 ? 1 : 0;

700

701 switch(avctx->codec->id) {

702 case AV_CODEC_ID_ADPCM_IMA_QT:

703 /* In QuickTime, IMA is encoded by chunks of 34 bytes (=64 samples).

704 Channel data is interleaved per-chunk. */

705 for (channel = 0; channel < avctx->channels; channel++) {

706 int predictor;

707 int step_index;

708 cs = &(c->status[channel]);

709 /* (pppppp) (piiiiiii) */

710

711 /* Bits 15-7 are the _top_ 9 bits of the 16-bit initial predictor value */

712 predictor = sign_extend(bytestream2_get_be16u(&gb), 16);

713 step_index = predictor & 0x7F;

714 predictor &= ~0x7F;

715

716 if (cs->step_index == step_index) {

717 int diff = predictor - cs->predictor;

718 if (diff < 0)

719 diff = - diff;

720 if (diff > 0x7f)

721 goto update;

722 } else {

723 update:

724 cs->step_index = step_index;

725 cs->predictor = predictor;

726 }

727

728 if (cs->step_index > 88u){

729 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",

730 channel, cs->step_index);

731 return AVERROR_INVALIDDATA;

732 }

733

734 samples = samples_p[channel];

735

736 for (m = 0; m < 64; m += 2) {

737 int byte = bytestream2_get_byteu(&gb);

738 samples[m ] = adpcm_ima_qt_expand_nibble(cs, byte & 0x0F, 3);

739 samples[m + 1] = adpcm_ima_qt_expand_nibble(cs, byte >> 4 , 3);

740 }

741 }

742 break;

743 case AV_CODEC_ID_ADPCM_IMA_WAV:

744 for(i=0; i<avctx->channels; i++){

745 cs = &(c->status[i]);

746 cs->predictor = samples_p[i][0] = sign_extend(bytestream2_get_le16u(&gb), 16);

747

748 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);

749 if (cs->step_index > 88u){

750 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",

751 i, cs->step_index);

752 return AVERROR_INVALIDDATA;

753 }

754 }

755

756 if (avctx->bits_per_coded_sample != 4) {

757 int samples_per_block = ff_adpcm_ima_block_samples[avctx->bits_per_coded_sample - 2];

758 GetBitContext g;

759

760 init_get_bits8(&g, gb.buffer, bytestream2_get_bytes_left(&gb));

761 for (n = 0; n < (nb_samples - 1) / samples_per_block; n++) {

762 for (i = 0; i < avctx->channels; i++) {

763 cs = &c->status[i];

764 samples = &samples_p[i][1 + n * samples_per_block];

765 for (m = 0; m < samples_per_block; m++) {

766 samples[m] = adpcm_ima_wav_expand_nibble(cs, &g,

767 avctx->bits_per_coded_sample);

768 }

769 }

770 }

771 bytestream2_skip(&gb, avctx->block_align - avctx->channels * 4);

772 } else {

773 for (n = 0; n < (nb_samples - 1) / 8; n++) {

774 for (i = 0; i < avctx->channels; i++) {

775 cs = &c->status[i];

776 samples = &samples_p[i][1 + n * 8];

777 for (m = 0; m < 8; m += 2) {

778 int v = bytestream2_get_byteu(&gb);

779 samples[m ] = adpcm_ima_expand_nibble(cs, v & 0x0F, 3);

780 samples[m + 1] = adpcm_ima_expand_nibble(cs, v >> 4 , 3);

781 }

782 }

783 }

784 }

785 break;

786 case AV_CODEC_ID_ADPCM_4XM:

787 for (i = 0; i < avctx->channels; i++)

788 c->status[i].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);

789

790 for (i = 0; i < avctx->channels; i++) {

791 c->status[i].step_index = sign_extend(bytestream2_get_le16u(&gb), 16);

792 if (c->status[i].step_index > 88u) {

793 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",

794 i, c->status[i].step_index);

795 return AVERROR_INVALIDDATA;

796 }

797 }

798

799 for (i = 0; i < avctx->channels; i++) {

800 samples = (int16_t *)frame->data[i];

801 cs = &c->status[i];

802 for (n = nb_samples >> 1; n > 0; n--) {

803 int v = bytestream2_get_byteu(&gb);

804 *samples++ = adpcm_ima_expand_nibble(cs, v & 0x0F, 4);

805 *samples++ = adpcm_ima_expand_nibble(cs, v >> 4 , 4);

806 }

807 }

808 break;

809 case AV_CODEC_ID_ADPCM_MS:

810 {

811 int block_predictor;

812

813 block_predictor = bytestream2_get_byteu(&gb);

814 if (block_predictor > 6) {

815 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[0] = %d\n",

816 block_predictor);

817 return AVERROR_INVALIDDATA;

818 }

819 c->status[0].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];

820 c->status[0].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];

821 if (st) {

822 block_predictor = bytestream2_get_byteu(&gb);

823 if (block_predictor > 6) {

824 av_log(avctx, AV_LOG_ERROR, "ERROR: block_predictor[1] = %d\n",

825 block_predictor);

826 return AVERROR_INVALIDDATA;

827 }

828 c->status[1].coeff1 = ff_adpcm_AdaptCoeff1[block_predictor];

829 c->status[1].coeff2 = ff_adpcm_AdaptCoeff2[block_predictor];

830 }

831 c->status[0].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);

832 if (st){

833 c->status[1].idelta = sign_extend(bytestream2_get_le16u(&gb), 16);

834 }

835

836 c->status[0].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);

837 if (st) c->status[1].sample1 = sign_extend(bytestream2_get_le16u(&gb), 16);

838 c->status[0].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);

839 if (st) c->status[1].sample2 = sign_extend(bytestream2_get_le16u(&gb), 16);

840

841 *samples++ = c->status[0].sample2;

842 if (st) *samples++ = c->status[1].sample2;

843 *samples++ = c->status[0].sample1;

844 if (st) *samples++ = c->status[1].sample1;

845 for(n = (nb_samples - 2) >> (1 - st); n > 0; n--) {

846 int byte = bytestream2_get_byteu(&gb);

847 *samples++ = adpcm_ms_expand_nibble(&c->status[0 ], byte >> 4 );

848 *samples++ = adpcm_ms_expand_nibble(&c->status[st], byte & 0x0F);

849 }

850 break;

851 }

852 case AV_CODEC_ID_ADPCM_IMA_DK4:

853 for (channel = 0; channel < avctx->channels; channel++) {

854 cs = &c->status[channel];

855 cs->predictor = *samples++ = sign_extend(bytestream2_get_le16u(&gb), 16);

856 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);

857 if (cs->step_index > 88u){

858 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",

859 channel, cs->step_index);

860 return AVERROR_INVALIDDATA;

861 }

862 }

863 for (n = (nb_samples - 1) >> (1 - st); n > 0; n--) {

864 int v = bytestream2_get_byteu(&gb);

865 *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v >> 4 , 3);

866 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);

867 }

868 break;

869 case AV_CODEC_ID_ADPCM_IMA_DK3:

870 {

871 int last_byte = 0;

872 int nibble;

873 int decode_top_nibble_next = 0;

874 int diff_channel;

875 const int16_t *samples_end = samples + avctx->channels * nb_samples;

876

877 bytestream2_skipu(&gb, 10);

878 c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);

879 c->status[1].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);

880 c->status[0].step_index = bytestream2_get_byteu(&gb);

881 c->status[1].step_index = bytestream2_get_byteu(&gb);

882 if (c->status[0].step_index > 88u || c->status[1].step_index > 88u){

883 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i/%i\n",

884 c->status[0].step_index, c->status[1].step_index);

885 return AVERROR_INVALIDDATA;

886 }

887 /* sign extend the predictors */

888 diff_channel = c->status[1].predictor;

889

890 /* DK3 ADPCM support macro */

891 #define DK3_GET_NEXT_NIBBLE() \

892 if (decode_top_nibble_next) { \

893 nibble = last_byte >> 4; \

894 decode_top_nibble_next = 0; \

895 } else { \

896 last_byte = bytestream2_get_byteu(&gb); \

897 nibble = last_byte & 0x0F; \

898 decode_top_nibble_next = 1; \

899 }

900

901 while (samples < samples_end) {

902

903 /* for this algorithm, c->status[0] is the sum channel and

904 * c->status[1] is the diff channel */

905

906 /* process the first predictor of the sum channel */

907 DK3_GET_NEXT_NIBBLE();

908 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);

909

910 /* process the diff channel predictor */

911 DK3_GET_NEXT_NIBBLE();

912 adpcm_ima_expand_nibble(&c->status[1], nibble, 3);

913

914 /* process the first pair of stereo PCM samples */

915 diff_channel = (diff_channel + c->status[1].predictor) / 2;

916 *samples++ = c->status[0].predictor + c->status[1].predictor;

917 *samples++ = c->status[0].predictor - c->status[1].predictor;

918

919 /* process the second predictor of the sum channel */

920 DK3_GET_NEXT_NIBBLE();

921 adpcm_ima_expand_nibble(&c->status[0], nibble, 3);

922

923 /* process the second pair of stereo PCM samples */

924 diff_channel = (diff_channel + c->status[1].predictor) / 2;

925 *samples++ = c->status[0].predictor + c->status[1].predictor;

926 *samples++ = c->status[0].predictor - c->status[1].predictor;

927 }

928

929 if ((bytestream2_tell(&gb) & 1))

930 bytestream2_skip(&gb, 1);

931 break;

932 }

933 case AV_CODEC_ID_ADPCM_IMA_ISS:

934 for (channel = 0; channel < avctx->channels; channel++) {

935 cs = &c->status[channel];

936 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);

937 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);

938 if (cs->step_index > 88u){

939 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",

940 channel, cs->step_index);

941 return AVERROR_INVALIDDATA;

942 }

943 }

944

945 for (n = nb_samples >> (1 - st); n > 0; n--) {

946 int v1, v2;

947 int v = bytestream2_get_byteu(&gb);

948 /* nibbles are swapped for mono */

949 if (st) {

950 v1 = v >> 4;

951 v2 = v & 0x0F;

952 } else {

953 v2 = v >> 4;

954 v1 = v & 0x0F;

955 }

956 *samples++ = adpcm_ima_expand_nibble(&c->status[0 ], v1, 3);

957 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v2, 3);

958 }

959 break;

960 case AV_CODEC_ID_ADPCM_IMA_APC:

961 while (bytestream2_get_bytes_left(&gb) > 0) {

962 int v = bytestream2_get_byteu(&gb);

963 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4 , 3);

964 *samples++ = adpcm_ima_expand_nibble(&c->status[st], v & 0x0F, 3);

965 }

966 break;

967 case AV_CODEC_ID_ADPCM_IMA_OKI:

968 while (bytestream2_get_bytes_left(&gb) > 0) {

969 int v = bytestream2_get_byteu(&gb);

970 *samples++ = adpcm_ima_oki_expand_nibble(&c->status[0], v >> 4 );

971 *samples++ = adpcm_ima_oki_expand_nibble(&c->status[st], v & 0x0F);

972 }

973 break;

974 case AV_CODEC_ID_ADPCM_IMA_RAD:

975 for (channel = 0; channel < avctx->channels; channel++) {

976 cs = &c->status[channel];

977 cs->step_index = sign_extend(bytestream2_get_le16u(&gb), 16);

978 cs->predictor = sign_extend(bytestream2_get_le16u(&gb), 16);

979 if (cs->step_index > 88u){

980 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",

981 channel, cs->step_index);

982 return AVERROR_INVALIDDATA;

983 }

984 }

985 for (n = 0; n < nb_samples / 2; n++) {

986 int byte[2];

987

988 byte[0] = bytestream2_get_byteu(&gb);

989 if (st)

990 byte[1] = bytestream2_get_byteu(&gb);

991 for(channel = 0; channel < avctx->channels; channel++) {

992 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] & 0x0F, 3);

993 }

994 for(channel = 0; channel < avctx->channels; channel++) {

995 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], byte[channel] >> 4 , 3);

996 }

997 }

998 break;

999 case AV_CODEC_ID_ADPCM_IMA_WS:

1000 if (c->vqa_version == 3) {

1001 for (channel = 0; channel < avctx->channels; channel++) {

1002 int16_t *smp = samples_p[channel];

1003

1004 for (n = nb_samples / 2; n > 0; n--) {

1005 int v = bytestream2_get_byteu(&gb);

1006 *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);

1007 *smp++ = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);

1008 }

1009 }

1010 } else {

1011 for (n = nb_samples / 2; n > 0; n--) {

1012 for (channel = 0; channel < avctx->channels; channel++) {

1013 int v = bytestream2_get_byteu(&gb);

1014 *samples++ = adpcm_ima_expand_nibble(&c->status[channel], v >> 4 , 3);

1015 samples[st] = adpcm_ima_expand_nibble(&c->status[channel], v & 0x0F, 3);

1016 }

1017 samples += avctx->channels;

1018 }

1019 }

1020 bytestream2_seek(&gb, 0, SEEK_END);

1021 break;

1022 case AV_CODEC_ID_ADPCM_XA:

1023 {

1024 int16_t *out0 = samples_p[0];

1025 int16_t *out1 = samples_p[1];

1026 int samples_per_block = 28 * (3 - avctx->channels) * 4;

1027 int sample_offset = 0;

1028 while (bytestream2_get_bytes_left(&gb) >= 128) {

1029 if ((ret = xa_decode(avctx, out0, out1, buf + bytestream2_tell(&gb),

1030 &c->status[0], &c->status[1],

1031 avctx->channels, sample_offset)) < 0)

1032 return ret;

1033 bytestream2_skipu(&gb, 128);

1034 sample_offset += samples_per_block;

1035 }

1036 break;

1037 }

1038 case AV_CODEC_ID_ADPCM_IMA_EA_EACS:

1039 for (i=0; i<=st; i++) {

1040 c->status[i].step_index = bytestream2_get_le32u(&gb);

1041 if (c->status[i].step_index > 88u) {

1042 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index[%d] = %i\n",

1043 i, c->status[i].step_index);

1044 return AVERROR_INVALIDDATA;

1045 }

1046 }

1047 for (i=0; i<=st; i++)

1048 c->status[i].predictor = bytestream2_get_le32u(&gb);

1049

1050 for (n = nb_samples >> (1 - st); n > 0; n--) {

1051 int byte = bytestream2_get_byteu(&gb);

1052 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 3);

1053 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 3);

1054 }

1055 break;

1056 case AV_CODEC_ID_ADPCM_IMA_EA_SEAD:

1057 for (n = nb_samples >> (1 - st); n > 0; n--) {

1058 int byte = bytestream2_get_byteu(&gb);

1059 *samples++ = adpcm_ima_expand_nibble(&c->status[0], byte >> 4, 6);

1060 *samples++ = adpcm_ima_expand_nibble(&c->status[st], byte & 0x0F, 6);

1061 }

1062 break;

1063 case AV_CODEC_ID_ADPCM_EA:

1064 {

1065 int previous_left_sample, previous_right_sample;

1066 int current_left_sample, current_right_sample;

1067 int next_left_sample, next_right_sample;

1068 int coeff1l, coeff2l, coeff1r, coeff2r;

1069 int shift_left, shift_right;

1070

1071 /* Each EA ADPCM frame has a 12-byte header followed by 30-byte pieces,

1072 each coding 28 stereo samples. */

1073

1074 if(avctx->channels != 2)

1075 return AVERROR_INVALIDDATA;

1076

1077 current_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);

1078 previous_left_sample = sign_extend(bytestream2_get_le16u(&gb), 16);

1079 current_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);

1080 previous_right_sample = sign_extend(bytestream2_get_le16u(&gb), 16);

1081

1082 for (count1 = 0; count1 < nb_samples / 28; count1++) {

1083 int byte = bytestream2_get_byteu(&gb);

1084 coeff1l = ea_adpcm_table[ byte >> 4 ];

1085 coeff2l = ea_adpcm_table[(byte >> 4 ) + 4];

1086 coeff1r = ea_adpcm_table[ byte & 0x0F];

1087 coeff2r = ea_adpcm_table[(byte & 0x0F) + 4];

1088

1089 byte = bytestream2_get_byteu(&gb);

1090 shift_left = 20 - (byte >> 4);

1091 shift_right = 20 - (byte & 0x0F);

1092

1093 for (count2 = 0; count2 < 28; count2++) {

1094 byte = bytestream2_get_byteu(&gb);

1095 next_left_sample = sign_extend(byte >> 4, 4) << shift_left;

1096 next_right_sample = sign_extend(byte, 4) << shift_right;

1097

1098 next_left_sample = (next_left_sample +

1099 (current_left_sample * coeff1l) +

1100 (previous_left_sample * coeff2l) + 0x80) >> 8;

1101 next_right_sample = (next_right_sample +

1102 (current_right_sample * coeff1r) +

1103 (previous_right_sample * coeff2r) + 0x80) >> 8;

1104

1105 previous_left_sample = current_left_sample;

1106 current_left_sample = av_clip_int16(next_left_sample);

1107 previous_right_sample = current_right_sample;

1108 current_right_sample = av_clip_int16(next_right_sample);

1109 *samples++ = current_left_sample;

1110 *samples++ = current_right_sample;

1111 }

1112 }

1113

1114 bytestream2_skip(&gb, 2); // Skip terminating 0x0000

1115

1116 break;

1117 }

1118 case AV_CODEC_ID_ADPCM_EA_MAXIS_XA:

1119 {

1120 int coeff[2][2], shift[2];

1121

1122 for(channel = 0; channel < avctx->channels; channel++) {

1123 int byte = bytestream2_get_byteu(&gb);

1124 for (i=0; i<2; i++)

1125 coeff[channel][i] = ea_adpcm_table[(byte >> 4) + 4*i];

1126 shift[channel] = 20 - (byte & 0x0F);

1127 }

1128 for (count1 = 0; count1 < nb_samples / 2; count1++) {

1129 int byte[2];

1130

1131 byte[0] = bytestream2_get_byteu(&gb);

1132 if (st) byte[1] = bytestream2_get_byteu(&gb);

1133 for(i = 4; i >= 0; i-=4) { /* Pairwise samples LL RR (st) or LL LL (mono) */

1134 for(channel = 0; channel < avctx->channels; channel++) {

1135 int sample = sign_extend(byte[channel] >> i, 4) << shift[channel];

1136 sample = (sample +

1137 c->status[channel].sample1 * coeff[channel][0] +

1138 c->status[channel].sample2 * coeff[channel][1] + 0x80) >> 8;

1139 c->status[channel].sample2 = c->status[channel].sample1;

1140 c->status[channel].sample1 = av_clip_int16(sample);

1141 *samples++ = c->status[channel].sample1;

1142 }

1143 }

1144 }

1145 bytestream2_seek(&gb, 0, SEEK_END);

1146 break;

1147 }

1148 case AV_CODEC_ID_ADPCM_EA_R1:

1149 case AV_CODEC_ID_ADPCM_EA_R2:

1150 case AV_CODEC_ID_ADPCM_EA_R3: {

1151 /* channel numbering

1152 2chan: 0=fl, 1=fr

1153 4chan: 0=fl, 1=rl, 2=fr, 3=rr

1154 6chan: 0=fl, 1=c, 2=fr, 3=rl, 4=rr, 5=sub */

1155 const int big_endian = avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R3;

1156 int previous_sample, current_sample, next_sample;

1157 int coeff1, coeff2;

1158 int shift;

1159 unsigned int channel;

1160 uint16_t *samplesC;

1161 int count = 0;

1162 int offsets[6];

1163

1164 for (channel=0; channel<avctx->channels; channel++)

1165 offsets[channel] = (big_endian ? bytestream2_get_be32(&gb) :

1166 bytestream2_get_le32(&gb)) +

1167 (avctx->channels + 1) * 4;

1168

1169 for (channel=0; channel<avctx->channels; channel++) {

1170 bytestream2_seek(&gb, offsets[channel], SEEK_SET);

1171 samplesC = samples_p[channel];

1172

1173 if (avctx->codec->id == AV_CODEC_ID_ADPCM_EA_R1) {

1174 current_sample = sign_extend(bytestream2_get_le16(&gb), 16);

1175 previous_sample = sign_extend(bytestream2_get_le16(&gb), 16);

1176 } else {

1177 current_sample = c->status[channel].predictor;

1178 previous_sample = c->status[channel].prev_sample;

1179 }

1180

1181 for (count1 = 0; count1 < nb_samples / 28; count1++) {

1182 int byte = bytestream2_get_byte(&gb);

1183 if (byte == 0xEE) { /* only seen in R2 and R3 */

1184 current_sample = sign_extend(bytestream2_get_be16(&gb), 16);

1185 previous_sample = sign_extend(bytestream2_get_be16(&gb), 16);

1186

1187 for (count2=0; count2<28; count2++)

1188 *samplesC++ = sign_extend(bytestream2_get_be16(&gb), 16);

1189 } else {

1190 coeff1 = ea_adpcm_table[ byte >> 4 ];

1191 coeff2 = ea_adpcm_table[(byte >> 4) + 4];

1192 shift = 20 - (byte & 0x0F);

1193

1194 for (count2=0; count2<28; count2++) {

1195 if (count2 & 1)

1196 next_sample = sign_extend(byte, 4) << shift;

1197 else {

1198 byte = bytestream2_get_byte(&gb);

1199 next_sample = sign_extend(byte >> 4, 4) << shift;

1200 }

1201

1202 next_sample += (current_sample * coeff1) +

1203 (previous_sample * coeff2);

1204 next_sample = av_clip_int16(next_sample >> 8);

1205

1206 previous_sample = current_sample;

1207 current_sample = next_sample;

1208 *samplesC++ = current_sample;

1209 }

1210 }

1211 }

1212 if (!count) {

1213 count = count1;

1214 } else if (count != count1) {

1215 av_log(avctx, AV_LOG_WARNING, "per-channel sample count mismatch\n");

1216 count = FFMAX(count, count1);

1217 }

1218

1219 if (avctx->codec->id != AV_CODEC_ID_ADPCM_EA_R1) {

1220 c->status[channel].predictor = current_sample;

1221 c->status[channel].prev_sample = previous_sample;

1222 }

1223 }

1224

1225 frame->nb_samples = count * 28;

1226 bytestream2_seek(&gb, 0, SEEK_END);

1227 break;

1228 }

1229 case AV_CODEC_ID_ADPCM_EA_XAS:

1230 for (channel=0; channel<avctx->channels; channel++) {

1231 int coeff[2][4], shift[4];

1232 int16_t *s = samples_p[channel];

1233 for (n = 0; n < 4; n++, s += 32) {

1234 int val = sign_extend(bytestream2_get_le16u(&gb), 16);

1235 for (i=0; i<2; i++)

1236 coeff[i][n] = ea_adpcm_table[(val&0x0F)+4*i];

1237 s[0] = val & ~0x0F;

1238

1239 val = sign_extend(bytestream2_get_le16u(&gb), 16);

1240 shift[n] = 20 - (val & 0x0F);

1241 s[1] = val & ~0x0F;

1242 }

1243

1244 for (m=2; m<32; m+=2) {

1245 s = &samples_p[channel][m];

1246 for (n = 0; n < 4; n++, s += 32) {

1247 int level, pred;

1248 int byte = bytestream2_get_byteu(&gb);

1249

1250 level = sign_extend(byte >> 4, 4) << shift[n];

1251 pred = s[-1] * coeff[0][n] + s[-2] * coeff[1][n];

1252 s[0] = av_clip_int16((level + pred + 0x80) >> 8);

1253

1254 level = sign_extend(byte, 4) << shift[n];

1255 pred = s[0] * coeff[0][n] + s[-1] * coeff[1][n];

1256 s[1] = av_clip_int16((level + pred + 0x80) >> 8);

1257 }

1258 }

1259 }

1260 break;

1261 case AV_CODEC_ID_ADPCM_IMA_AMV:

1262 c->status[0].predictor = sign_extend(bytestream2_get_le16u(&gb), 16);

1263 c->status[0].step_index = bytestream2_get_le16u(&gb);

1264 bytestream2_skipu(&gb, 4);

1265 if (c->status[0].step_index > 88u) {

1266 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",

1267 c->status[0].step_index);

1268 return AVERROR_INVALIDDATA;

1269 }

1270

1271 for (n = nb_samples >> (1 - st); n > 0; n--) {

1272 int v = bytestream2_get_byteu(&gb);

1273

1274 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v >> 4, 3);

1275 *samples++ = adpcm_ima_expand_nibble(&c->status[0], v & 0xf, 3);

1276 }

1277 break;

1278 case AV_CODEC_ID_ADPCM_IMA_SMJPEG:

1279 for (i = 0; i < avctx->channels; i++) {

1280 c->status[i].predictor = sign_extend(bytestream2_get_be16u(&gb), 16);

1281 c->status[i].step_index = bytestream2_get_byteu(&gb);

1282 bytestream2_skipu(&gb, 1);

1283 if (c->status[i].step_index > 88u) {

1284 av_log(avctx, AV_LOG_ERROR, "ERROR: step_index = %i\n",

1285 c->status[i].step_index);

1286 return AVERROR_INVALIDDATA;

1287 }

1288 }

1289

1290 for (n = nb_samples >> (1 - st); n > 0; n--) {

1291 int v = bytestream2_get_byteu(&gb);

1292

1293 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[0 ], v >> 4, 3);

1294 *samples++ = adpcm_ima_qt_expand_nibble(&c->status[st], v & 0xf, 3);

1295 }

1296 break;

1297 case AV_CODEC_ID_ADPCM_CT:

1298 for (n = nb_samples >> (1 - st); n > 0; n--) {

1299 int v = bytestream2_get_byteu(&gb);

1300 *samples++ = adpcm_ct_expand_nibble(&c->status[0 ], v >> 4 );

1301 *samples++ = adpcm_ct_expand_nibble(&c->status[st], v & 0x0F);

1302 }

1303 break;

1304 case AV_CODEC_ID_ADPCM_SBPRO_4:

1305 case AV_CODEC_ID_ADPCM_SBPRO_3:

1306 case AV_CODEC_ID_ADPCM_SBPRO_2:

1307 if (!c->status[0].step_index) {

1308 /* the first byte is a raw sample */

1309 *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);

1310 if (st)

1311 *samples++ = 128 * (bytestream2_get_byteu(&gb) - 0x80);

1312 c->status[0].step_index = 1;

1313 nb_samples--;

1314 }

1315 if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_4) {

1316 for (n = nb_samples >> (1 - st); n > 0; n--) {

1317 int byte = bytestream2_get_byteu(&gb);

1318 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],

1319 byte >> 4, 4, 0);

1320 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],

1321 byte & 0x0F, 4, 0);

1322 }

1323 } else if (avctx->codec->id == AV_CODEC_ID_ADPCM_SBPRO_3) {

1324 for (n = (nb_samples<<st) / 3; n > 0; n--) {

1325 int byte = bytestream2_get_byteu(&gb);

1326 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],

1327 byte >> 5 , 3, 0);

1328 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],

1329 (byte >> 2) & 0x07, 3, 0);

1330 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],

1331 byte & 0x03, 2, 0);

1332 }

1333 } else {

1334 for (n = nb_samples >> (2 - st); n > 0; n--) {

1335 int byte = bytestream2_get_byteu(&gb);

1336 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],

1337 byte >> 6 , 2, 2);

1338 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],

1339 (byte >> 4) & 0x03, 2, 2);

1340 *samples++ = adpcm_sbpro_expand_nibble(&c->status[0],

1341 (byte >> 2) & 0x03, 2, 2);

1342 *samples++ = adpcm_sbpro_expand_nibble(&c->status[st],

1343 byte & 0x03, 2, 2);

1344 }

1345 }

1346 break;

1347 case AV_CODEC_ID_ADPCM_SWF:

1348 adpcm_swf_decode(avctx, buf, buf_size, samples);

1349 bytestream2_seek(&gb, 0, SEEK_END);

1350 break;

1351 case AV_CODEC_ID_ADPCM_YAMAHA:

1352 for (n = nb_samples >> (1 - st); n > 0; n--) {

1353 int v = bytestream2_get_byteu(&gb);

1354 *samples++ = adpcm_yamaha_expand_nibble(&c->status[0 ], v & 0x0F);

1355 *samples++ = adpcm_yamaha_expand_nibble(&c->status[st], v >> 4 );

1356 }

1357 break;

1358 case AV_CODEC_ID_ADPCM_AFC:

1359 {

1360 int samples_per_block;

1361 int blocks;

1362

1363 if (avctx->extradata && avctx->extradata_size == 1 && avctx->extradata[0]) {

1364 samples_per_block = avctx->extradata[0] / 16;

1365 blocks = nb_samples / avctx->extradata[0];

1366 } else {

1367 samples_per_block = nb_samples / 16;

1368 blocks = 1;

1369 }

1370

1371 for (m = 0; m < blocks; m++) {

1372 for (channel = 0; channel < avctx->channels; channel++) {

1373 int prev1 = c->status[channel].sample1;

1374 int prev2 = c->status[channel].sample2;

1375

1376 samples = samples_p[channel] + m * 16;

1377 /* Read in every sample for this channel. */

1378 for (i = 0; i < samples_per_block; i++) {

1379 int byte = bytestream2_get_byteu(&gb);

1380 int scale = 1 << (byte >> 4);

1381 int index = byte & 0xf;

1382 int factor1 = ff_adpcm_afc_coeffs[0][index];

1383 int factor2 = ff_adpcm_afc_coeffs[1][index];

1384

1385 /* Decode 16 samples. */

1386 for (n = 0; n < 16; n++) {

1387 int32_t sampledat;

1388

1389 if (n & 1) {

1390 sampledat = sign_extend(byte, 4);

1391 } else {

1392 byte = bytestream2_get_byteu(&gb);

1393 sampledat = sign_extend(byte >> 4, 4);

1394 }

1395

1396 sampledat = ((prev1 * factor1 + prev2 * factor2) +

1397 ((sampledat * scale) << 11)) >> 11;

1398 *samples = av_clip_int16(sampledat);

1399 prev2 = prev1;

1400 prev1 = *samples++;

1401 }

1402 }

1403

1404 c->status[channel].sample1 = prev1;

1405 c->status[channel].sample2 = prev2;

1406 }

1407 }

1408 bytestream2_seek(&gb, 0, SEEK_END);

1409 break;

1410 }

1411 case AV_CODEC_ID_ADPCM_THP:

1412 {

1413 int table[6][16];

1414 int ch;

1415

1416 if (avctx->extradata) {

1417 GetByteContext tb;

1418 if (avctx->extradata_size < 32 * avctx->channels) {

1419 av_log(avctx, AV_LOG_ERROR, "Missing coeff table\n");

1420 return AVERROR_INVALIDDATA;

1421 }

1422

1423 bytestream2_init(&tb, avctx->extradata, avctx->extradata_size);

1424 for (i = 0; i < avctx->channels; i++)

1425 for (n = 0; n < 16; n++)

1426 table[i][n] = sign_extend(bytestream2_get_be16u(&tb), 16);

1427 } else {

1428 for (i = 0; i < avctx->channels; i++)

1429 for (n = 0; n < 16; n++)

1430 table[i][n] = sign_extend(bytestream2_get_be16u(&gb), 16);

1431

1432 /* Initialize the previous sample. */

1433 for (i = 0; i < avctx->channels; i++) {

1434 c->status[i].sample1 = sign_extend(bytestream2_get_be16u(&gb), 16);

1435 c->status[i].sample2 = sign_extend(bytestream2_get_be16u(&gb), 16);

1436 }

1437 }

1438

1439 for (ch = 0; ch < avctx->channels; ch++) {

1440 samples = samples_p[ch];

1441

1442 /* Read in every sample for this channel. */

1443 for (i = 0; i < nb_samples / 14; i++) {

1444 int byte = bytestream2_get_byteu(&gb);

1445 int index = (byte >> 4) & 7;

1446 unsigned int exp = byte & 0x0F;

1447 int factor1 = table[ch][index * 2];

1448 int factor2 = table[ch][index * 2 + 1];

1449

1450 /* Decode 14 samples. */

1451 for (n = 0; n < 14; n++) {

1452 int32_t sampledat;

1453

1454 if (n & 1) {

1455 sampledat = sign_extend(byte, 4);

1456 } else {

1457 byte = bytestream2_get_byteu(&gb);

1458 sampledat = sign_extend(byte >> 4, 4);

1459 }

1460

1461 sampledat = ((c->status[ch].sample1 * factor1

1462 + c->status[ch].sample2 * factor2) >> 11) + (sampledat << exp);

1463 *samples = av_clip_int16(sampledat);

1464 c->status[ch].sample2 = c->status[ch].sample1;

1465 c->status[ch].sample1 = *samples++;

1466 }

1467 }

1468 }

1469 break;

1470 }

1471 case AV_CODEC_ID_ADPCM_DTK:

1472 for (channel = 0; channel < avctx->channels; channel++) {

1473 samples = samples_p[channel];

1474

1475 /* Read in every sample for this channel. */

1476 for (i = 0; i < nb_samples / 28; i++) {

1477 int byte, header;

1478 if (channel)

1479 bytestream2_skipu(&gb, 1);

1480 header = bytestream2_get_byteu(&gb);

1481 bytestream2_skipu(&gb, 3 - channel);

1482

1483 /* Decode 28 samples. */

1484 for (n = 0; n < 28; n++) {

1485 int32_t sampledat, prev;

1486

1487 switch (header >> 4) {

1488 case 1:

1489 prev = (c->status[channel].sample1 * 0x3c);

1490 break;

1491 case 2:

1492 prev = (c->status[channel].sample1 * 0x73) - (c->status[channel].sample2 * 0x34);

1493 break;

1494 case 3:

1495 prev = (c->status[channel].sample1 * 0x62) - (c->status[channel].sample2 * 0x37);

1496 break;

1497 default:

1498 prev = 0;

1499 }

1500

1501 prev = av_clip((prev + 0x20) >> 6, -0x200000, 0x1fffff);

1502

1503 byte = bytestream2_get_byteu(&gb);

1504 if (!channel)

1505 sampledat = sign_extend(byte, 4);

1506 else

1507 sampledat = sign_extend(byte >> 4, 4);

1508

1509 sampledat = (((sampledat << 12) >> (header & 0xf)) << 6) + prev;

1510 *samples++ = av_clip_int16(sampledat >> 6);

1511 c->status[channel].sample2 = c->status[channel].sample1;

1512 c->status[channel].sample1 = sampledat;

1513 }

1514 }

1515 if (!channel)

1516 bytestream2_seek(&gb, 0, SEEK_SET);

1517 }

1518 break;

1519

1520 default:

1521 return -1;

1522 }

1523

1524 if (avpkt->size && bytestream2_tell(&gb) == 0) {

1525 av_log(avctx, AV_LOG_ERROR, "Nothing consumed\n");

1526 return AVERROR_INVALIDDATA;

1527 }

1528

1529 *got_frame_ptr = 1;

1530

1531 return bytestream2_tell(&gb);

1532 }

1533

1534

1535 static const enum AVSampleFormat sample_fmts_s16[] = { AV_SAMPLE_FMT_S16,

1536 AV_SAMPLE_FMT_NONE };

1537 static const enum AVSampleFormat sample_fmts_s16p[] = { AV_SAMPLE_FMT_S16P,

1538 AV_SAMPLE_FMT_NONE };

1539 static const enum AVSampleFormat sample_fmts_both[] = { AV_SAMPLE_FMT_S16,

1540 AV_SAMPLE_FMT_S16P,

1541 AV_SAMPLE_FMT_NONE };

1542

1543 #define ADPCM_DECODER(id_, sample_fmts_, name_, long_name_) \

1544 AVCodec ff_ ## name_ ## _decoder = { \

1545 .name = #name_, \

1546 .long_name = NULL_IF_CONFIG_SMALL(long_name_), \

1547 .type = AVMEDIA_TYPE_AUDIO, \

1548 .id = id_, \

1549 .priv_data_size = sizeof(ADPCMDecodeContext), \

1550 .init = adpcm_decode_init, \

1551 .decode = adpcm_decode_frame, \

1552 .capabilities = CODEC_CAP_DR1, \

1553 .sample_fmts = sample_fmts_, \

1554 }

1555

1556 /* Note: Do not forget to add new entries to the Makefile as well. */

1557 ADPCM_DECODER(AV_CODEC_ID_ADPCM_4XM, sample_fmts_s16p, adpcm_4xm, "ADPCM 4X Movie");

1558 ADPCM_DECODER(AV_CODEC_ID_ADPCM_AFC, sample_fmts_s16p, adpcm_afc, "ADPCM Nintendo Gamecube AFC");

1559 ADPCM_DECODER(AV_CODEC_ID_ADPCM_CT, sample_fmts_s16, adpcm_ct, "ADPCM Creative Technology");

1560 ADPCM_DECODER(AV_CODEC_ID_ADPCM_DTK, sample_fmts_s16p, adpcm_dtk, "ADPCM Nintendo Gamecube DTK");

1561 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA, sample_fmts_s16, adpcm_ea, "ADPCM Electronic Arts");

1562 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_MAXIS_XA, sample_fmts_s16, adpcm_ea_maxis_xa, "ADPCM Electronic Arts Maxis CDROM XA");

1563 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R1, sample_fmts_s16p, adpcm_ea_r1, "ADPCM Electronic Arts R1");

1564 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R2, sample_fmts_s16p, adpcm_ea_r2, "ADPCM Electronic Arts R2");

1565 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_R3, sample_fmts_s16p, adpcm_ea_r3, "ADPCM Electronic Arts R3");

1566 ADPCM_DECODER(AV_CODEC_ID_ADPCM_EA_XAS, sample_fmts_s16p, adpcm_ea_xas, "ADPCM Electronic Arts XAS");

1567 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_AMV, sample_fmts_s16, adpcm_ima_amv, "ADPCM IMA AMV");

1568 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_APC, sample_fmts_s16, adpcm_ima_apc, "ADPCM IMA CRYO APC");

1569 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK3, sample_fmts_s16, adpcm_ima_dk3, "ADPCM IMA Duck DK3");

1570 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_DK4, sample_fmts_s16, adpcm_ima_dk4, "ADPCM IMA Duck DK4");

1571 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_EACS, sample_fmts_s16, adpcm_ima_ea_eacs, "ADPCM IMA Electronic Arts EACS");

1572 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_EA_SEAD, sample_fmts_s16, adpcm_ima_ea_sead, "ADPCM IMA Electronic Arts SEAD");

1573 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_ISS, sample_fmts_s16, adpcm_ima_iss, "ADPCM IMA Funcom ISS");

1574 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_OKI, sample_fmts_s16, adpcm_ima_oki, "ADPCM IMA Dialogic OKI");

1575 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_QT, sample_fmts_s16p, adpcm_ima_qt, "ADPCM IMA QuickTime");

1576 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_RAD, sample_fmts_s16, adpcm_ima_rad, "ADPCM IMA Radical");

1577 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_SMJPEG, sample_fmts_s16, adpcm_ima_smjpeg, "ADPCM IMA Loki SDL MJPEG");

1578 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WAV, sample_fmts_s16p, adpcm_ima_wav, "ADPCM IMA WAV");

1579 ADPCM_DECODER(AV_CODEC_ID_ADPCM_IMA_WS, sample_fmts_both, adpcm_ima_ws, "ADPCM IMA Westwood");

1580 ADPCM_DECODER(AV_CODEC_ID_ADPCM_MS, sample_fmts_s16, adpcm_ms, "ADPCM Microsoft");

1581 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_2, sample_fmts_s16, adpcm_sbpro_2, "ADPCM Sound Blaster Pro 2-bit");

1582 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_3, sample_fmts_s16, adpcm_sbpro_3, "ADPCM Sound Blaster Pro 2.6-bit");

1583 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SBPRO_4, sample_fmts_s16, adpcm_sbpro_4, "ADPCM Sound Blaster Pro 4-bit");

1584 ADPCM_DECODER(AV_CODEC_ID_ADPCM_SWF, sample_fmts_s16, adpcm_swf, "ADPCM Shockwave Flash");

1585 ADPCM_DECODER(AV_CODEC_ID_ADPCM_THP, sample_fmts_s16p, adpcm_thp, "ADPCM Nintendo Gamecube THP");

1586 ADPCM_DECODER(AV_CODEC_ID_ADPCM_XA, sample_fmts_s16p, adpcm_xa, "ADPCM CDROM XA");

1587 ADPCM_DECODER(AV_CODEC_ID_ADPCM_YAMAHA, sample_fmts_s16, adpcm_yamaha, "ADPCM Yamaha");

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