FFmpeg: libavcodec/pcm.c Source File

FFmpeg

[フレーム]

libavcodec

pcm.c

Go to the documentation of this file.

1 /*

2 * PCM codecs

4 *

5 * This file is part of FFmpeg.

6 *

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

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

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

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

11 *

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

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

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

15 * Lesser General Public License for more details.

16 *

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

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

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

20 */

22 /**

23 * @file

24 * PCM codecs

25 */

27 #include "config.h"

28 #include "config_components.h"

29 #include "libavutil/attributes.h"

30 #include "libavutil/float_dsp.h"

31 #include "libavutil/mem.h"

32 #include "libavutil/reverse.h"

33 #include "libavutil/thread.h"

34 #include "avcodec.h"

35 #include "bytestream.h"

36 #include "codec_internal.h"

37 #include "decode.h"

38 #include "encode.h"

39 #include "pcm_tablegen.h"

41 av_unused av_cold static int pcm_encode_init(AVCodecContext *avctx)

42 {

43 avctx->frame_size = 0;

44 #if !CONFIG_HARDCODED_TABLES

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

46 #if CONFIG_PCM_ALAW_ENCODER

47 case AV_CODEC_ID_PCM_ALAW: {

48 static AVOnce once_alaw = AV_ONCE_INIT;

49 ff_thread_once(&once_alaw, pcm_alaw_tableinit);

50 break;

51 }

52 #endif

53 #if CONFIG_PCM_MULAW_ENCODER

54 case AV_CODEC_ID_PCM_MULAW: {

55 static AVOnce once_mulaw = AV_ONCE_INIT;

56 ff_thread_once(&once_mulaw, pcm_ulaw_tableinit);

57 break;

58 }

59 #endif

60 #if CONFIG_PCM_VIDC_ENCODER

61 case AV_CODEC_ID_PCM_VIDC: {

62 static AVOnce once_vidc = AV_ONCE_INIT;

63 ff_thread_once(&once_vidc, pcm_vidc_tableinit);

64 break;

65 }

66 #endif

67 default:

68 break;

69 }

70 #endif

72 avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id);

73 avctx->block_align = avctx->ch_layout.nb_channels * avctx->bits_per_coded_sample / 8;

74 avctx->bit_rate = avctx->block_align * 8LL * avctx->sample_rate;

76 return 0;

77 }

79 /**

80 * Write PCM samples macro

81 * @param type Datatype of native machine format

82 * @param endian bytestream_put_xxx() suffix

83 * @param src Source pointer (variable name)

84 * @param dst Destination pointer (variable name)

85 * @param n Total number of samples (variable name)

86 * @param shift Bitshift (bits)

87 * @param offset Sample value offset

88 */

89 #define ENCODE(type, endian, src, dst, n, shift, offset) \

90 samples_ ## type = (const type *) src; \

91 for (; n > 0; n--) { \

92 register type v = (*samples_ ## type++ >> shift) + offset; \

93 bytestream_put_ ## endian(&dst, v); \

94 }

96 #define ENCODE_PLANAR(type, endian, dst, n, shift, offset) \

97 n /= avctx->ch_layout.nb_channels; \

98 for (c = 0; c < avctx->ch_layout.nb_channels; c++) { \

99 int i; \

100 samples_ ## type = (const type *) frame->extended_data[c]; \

101 for (i = n; i > 0; i--) { \

102 register type v = (*samples_ ## type++ >> shift) + offset; \

103 bytestream_put_ ## endian(&dst, v); \

104 } \

105 }

106

107 av_unused static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,

108 const AVFrame *frame, int *got_packet_ptr)

109 {

110 int n, c, sample_size, ret;

111 const short *samples;

112 unsigned char *dst;

113 const uint8_t *samples_uint8_t;

114 const int16_t *samples_int16_t;

115 const int32_t *samples_int32_t;

116 const int64_t *samples_int64_t;

117 const uint16_t *samples_uint16_t;

118 const uint32_t *samples_uint32_t;

119

120 sample_size = av_get_bits_per_sample(avctx->codec->id) / 8;

121 n = frame->nb_samples * avctx->ch_layout.nb_channels;

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

123

124 if ((ret = ff_get_encode_buffer(avctx, avpkt, n * sample_size, 0)) < 0)

125 return ret;

126 dst = avpkt->data;

127

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

129 case AV_CODEC_ID_PCM_U32LE:

130 ENCODE(uint32_t, le32, samples, dst, n, 0, 0x80000000)

131 break;

132 case AV_CODEC_ID_PCM_U32BE:

133 ENCODE(uint32_t, be32, samples, dst, n, 0, 0x80000000)

134 break;

135 case AV_CODEC_ID_PCM_S24LE:

136 ENCODE(int32_t, le24, samples, dst, n, 8, 0)

137 break;

138 case AV_CODEC_ID_PCM_S24LE_PLANAR:

139 ENCODE_PLANAR(int32_t, le24, dst, n, 8, 0)

140 break;

141 case AV_CODEC_ID_PCM_S24BE:

142 ENCODE(int32_t, be24, samples, dst, n, 8, 0)

143 break;

144 case AV_CODEC_ID_PCM_U24LE:

145 ENCODE(uint32_t, le24, samples, dst, n, 8, 0x800000)

146 break;

147 case AV_CODEC_ID_PCM_U24BE:

148 ENCODE(uint32_t, be24, samples, dst, n, 8, 0x800000)

149 break;

150 case AV_CODEC_ID_PCM_S24DAUD:

151 for (; n > 0; n--) {

152 uint32_t tmp = ff_reverse[(*samples >> 8) & 0xff] +

153 (ff_reverse[*samples & 0xff] << 8);

154 tmp <<= 4; // sync flags would go here

155 bytestream_put_be24(&dst, tmp);

156 samples++;

157 }

158 break;

159 case AV_CODEC_ID_PCM_U16LE:

160 ENCODE(uint16_t, le16, samples, dst, n, 0, 0x8000)

161 break;

162 case AV_CODEC_ID_PCM_U16BE:

163 ENCODE(uint16_t, be16, samples, dst, n, 0, 0x8000)

164 break;

165 case AV_CODEC_ID_PCM_S8:

166 ENCODE(uint8_t, byte, samples, dst, n, 0, -128)

167 break;

168 case AV_CODEC_ID_PCM_S8_PLANAR:

169 ENCODE_PLANAR(uint8_t, byte, dst, n, 0, -128)

170 break;

171 #if HAVE_BIGENDIAN

172 case AV_CODEC_ID_PCM_S64LE:

173 case AV_CODEC_ID_PCM_F64LE:

174 ENCODE(int64_t, le64, samples, dst, n, 0, 0)

175 break;

176 case AV_CODEC_ID_PCM_S32LE:

177 case AV_CODEC_ID_PCM_F32LE:

178 ENCODE(int32_t, le32, samples, dst, n, 0, 0)

179 break;

180 case AV_CODEC_ID_PCM_S32LE_PLANAR:

181 ENCODE_PLANAR(int32_t, le32, dst, n, 0, 0)

182 break;

183 case AV_CODEC_ID_PCM_S16LE:

184 ENCODE(int16_t, le16, samples, dst, n, 0, 0)

185 break;

186 case AV_CODEC_ID_PCM_S16LE_PLANAR:

187 ENCODE_PLANAR(int16_t, le16, dst, n, 0, 0)

188 break;

189 case AV_CODEC_ID_PCM_F64BE:

190 case AV_CODEC_ID_PCM_F32BE:

191 case AV_CODEC_ID_PCM_S64BE:

192 case AV_CODEC_ID_PCM_S32BE:

193 case AV_CODEC_ID_PCM_S16BE:

194 #else

195 case AV_CODEC_ID_PCM_S64BE:

196 case AV_CODEC_ID_PCM_F64BE:

197 ENCODE(int64_t, be64, samples, dst, n, 0, 0)

198 break;

199 case AV_CODEC_ID_PCM_F32BE:

200 case AV_CODEC_ID_PCM_S32BE:

201 ENCODE(int32_t, be32, samples, dst, n, 0, 0)

202 break;

203 case AV_CODEC_ID_PCM_S16BE:

204 ENCODE(int16_t, be16, samples, dst, n, 0, 0)

205 break;

206 case AV_CODEC_ID_PCM_S16BE_PLANAR:

207 ENCODE_PLANAR(int16_t, be16, dst, n, 0, 0)

208 break;

209 case AV_CODEC_ID_PCM_F64LE:

210 case AV_CODEC_ID_PCM_F32LE:

211 case AV_CODEC_ID_PCM_S64LE:

212 case AV_CODEC_ID_PCM_S32LE:

213 case AV_CODEC_ID_PCM_S16LE:

214 #endif /* HAVE_BIGENDIAN */

215 case AV_CODEC_ID_PCM_U8:

216 memcpy(dst, samples, n * sample_size);

217 break;

218 #if HAVE_BIGENDIAN

219 case AV_CODEC_ID_PCM_S16BE_PLANAR:

220 #else

221 case AV_CODEC_ID_PCM_S16LE_PLANAR:

222 case AV_CODEC_ID_PCM_S32LE_PLANAR:

223 #endif /* HAVE_BIGENDIAN */

224 n /= avctx->ch_layout.nb_channels;

225 for (c = 0; c < avctx->ch_layout.nb_channels; c++) {

226 const uint8_t *src = frame->extended_data[c];

227 bytestream_put_buffer(&dst, src, n * sample_size);

228 }

229 break;

230 #if CONFIG_PCM_ALAW_ENCODER

231 case AV_CODEC_ID_PCM_ALAW:

232 for (; n > 0; n--) {

233 int v = *samples++;

234 *dst++ = linear_to_alaw[(v + 32768) >> 2];

235 }

236 break;

237 #endif

238 #if CONFIG_PCM_MULAW_ENCODER

239 case AV_CODEC_ID_PCM_MULAW:

240 for (; n > 0; n--) {

241 int v = *samples++;

242 *dst++ = linear_to_ulaw[(v + 32768) >> 2];

243 }

244 break;

245 #endif

246 #if CONFIG_PCM_VIDC_ENCODER

247 case AV_CODEC_ID_PCM_VIDC:

248 for (; n > 0; n--) {

249 int v = *samples++;

250 *dst++ = linear_to_vidc[(v + 32768) >> 2];

251 }

252 break;

253 #endif

254 default:

255 return -1;

256 }

257

258 *got_packet_ptr = 1;

259 return 0;

260 }

261

262 typedef struct PCMDecode {

263 int sample_size;

264 } PCMDecode;

265

266 av_unused av_cold static int pcm_decode_init(AVCodecContext *avctx)

267 {

268 PCMDecode *s = avctx->priv_data;

269 static const struct {

270 enum AVCodecID codec_id;

271 int8_t sample_fmt;

272 uint8_t sample_size;

273 uint8_t bits_per_sample;

274 } codec_id_to_samplefmt[] = {

275 #define ENTRY(CODEC_ID, SAMPLE_FMT, BITS_PER_SAMPLE) \

276 { AV_CODEC_ID_PCM_ ## CODEC_ID, AV_SAMPLE_FMT_ ## SAMPLE_FMT, \

277 BITS_PER_SAMPLE / 8, BITS_PER_SAMPLE }

278 ENTRY(S8, U8, 8), ENTRY(S8_PLANAR, U8P, 8),

279 ENTRY(S16BE, S16, 16), ENTRY(S16BE_PLANAR, S16P, 16),

280 ENTRY(S16LE, S16, 16), ENTRY(S16LE_PLANAR, S16P, 16),

281 ENTRY(S24DAUD, S16, 24), ENTRY(S24BE, S32, 24),

282 ENTRY(S24LE, S32, 24), ENTRY(S24LE_PLANAR, S32P, 24),

283 ENTRY(S32BE, S32, 32), ENTRY(S32LE, S32, 32),

284 ENTRY(S32LE_PLANAR, S32P, 32),

285 ENTRY(S64BE, S64, 64), ENTRY(S64LE, S64, 64),

286 ENTRY(SGA, U8, 8), ENTRY(U8, U8, 8),

287 ENTRY(U16BE, S16, 16), ENTRY(U16LE, S16, 16),

288 ENTRY(U24BE, S32, 24), ENTRY(U24LE, S32, 24),

289 ENTRY(U32BE, S32, 32), ENTRY(U32LE, S32, 32),

290 ENTRY(F32BE, FLT, 32), ENTRY(F32LE, FLT, 32),

291 ENTRY(F64BE, DBL, 64), ENTRY(F64LE, DBL, 64),

292 { .codec_id = AV_CODEC_ID_PCM_LXF, .sample_fmt = AV_SAMPLE_FMT_S32P, .sample_size = 5 },

293 };

294

295 for (unsigned i = 0; i < FF_ARRAY_ELEMS(codec_id_to_samplefmt); ++i) {

296 if (codec_id_to_samplefmt[i].codec_id == avctx->codec_id) {

297 s->sample_size = codec_id_to_samplefmt[i].sample_size;

298 avctx->sample_fmt = codec_id_to_samplefmt[i].sample_fmt;

299 if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)

300 avctx->bits_per_raw_sample = codec_id_to_samplefmt[i].bits_per_sample;

301 break;

302 }

303 av_assert1(i + 1 < FF_ARRAY_ELEMS(codec_id_to_samplefmt));

304 }

305

306 return 0;

307 }

308

309 typedef struct PCMScaleDecode {

310 PCMDecode base;

311 void (*vector_fmul_scalar)(float *dst, const float *src, float mul,

312 int len);

313 float scale;

314 } PCMScaleDecode;

315

316 av_unused av_cold static int pcm_scale_decode_init(AVCodecContext *avctx)

317 {

318 PCMScaleDecode *s = avctx->priv_data;

319 AVFloatDSPContext *fdsp;

320

321 avctx->sample_fmt = AV_SAMPLE_FMT_FLT;

322 s->base.sample_size = 4;

323

324 if (avctx->bits_per_coded_sample < 1 || avctx->bits_per_coded_sample > 24)

325 return AVERROR_INVALIDDATA;

326

327 s->scale = 1. / (1 << (avctx->bits_per_coded_sample - 1));

328 fdsp = avpriv_float_dsp_alloc(0);

329 if (!fdsp)

330 return AVERROR(ENOMEM);

331 s->vector_fmul_scalar = fdsp->vector_fmul_scalar;

332 av_free(fdsp);

333

334 return 0;

335 }

336

337 typedef struct PCMLUTDecode {

338 PCMDecode base;

339 int16_t table[256];

340 } PCMLUTDecode;

341

342 av_unused av_cold static int pcm_lut_decode_init(AVCodecContext *avctx)

343 {

344 PCMLUTDecode *s = avctx->priv_data;

345

346 switch (avctx->codec_id) {

347 default:

348 av_unreachable("pcm_lut_decode_init() only used with alaw, mulaw and vidc");

349 #if CONFIG_PCM_ALAW_DECODER

350 case AV_CODEC_ID_PCM_ALAW:

351 for (int i = 0; i < 256; i++)

352 s->table[i] = alaw2linear(i);

353 break;

354 #endif

355 #if CONFIG_PCM_MULAW_DECODER

356 case AV_CODEC_ID_PCM_MULAW:

357 for (int i = 0; i < 256; i++)

358 s->table[i] = ulaw2linear(i);

359 break;

360 #endif

361 #if CONFIG_PCM_VIDC_DECODER

362 case AV_CODEC_ID_PCM_VIDC:

363 for (int i = 0; i < 256; i++)

364 s->table[i] = vidc2linear(i);

365 break;

366 #endif

367 }

368

369 avctx->sample_fmt = AV_SAMPLE_FMT_S16;

370 s->base.sample_size = 1;

371

372 return 0;

373 }

374

375 /**

376 * Read PCM samples macro

377 * @param size Data size of native machine format

378 * @param endian bytestream_get_xxx() endian suffix

379 * @param src Source pointer (variable name)

380 * @param dst Destination pointer (variable name)

381 * @param n Total number of samples (variable name)

382 * @param shift Bitshift (bits)

383 * @param offset Sample value offset

384 */

385 #define DECODE(size, endian, src, dst, n, shift, offset) \

386 for (; n > 0; n--) { \

387 uint ## size ## _t v = bytestream_get_ ## endian(&src); \

388 AV_WN ## size ## A(dst, (uint ## size ## _t)(v - offset) << shift); \

389 dst += size / 8; \

390 }

391

392 #define DECODE_PLANAR(size, endian, src, dst, n, shift, offset) \

393 n /= channels; \

394 for (c = 0; c < avctx->ch_layout.nb_channels; c++) { \

395 int i; \

396 dst = frame->extended_data[c]; \

397 for (i = n; i > 0; i--) { \

398 uint ## size ## _t v = bytestream_get_ ## endian(&src); \

399 AV_WN ## size ## A(dst, (uint ## size ##_t)(v - offset) << shift); \

400 dst += size / 8; \

401 } \

402 }

403

404 static int pcm_decode_frame(AVCodecContext *avctx, AVFrame *frame,

405 int *got_frame_ptr, AVPacket *avpkt)

406 {

407 const uint8_t *src = avpkt->data;

408 int buf_size = avpkt->size;

409 PCMDecode *s = avctx->priv_data;

410 int channels = avctx->ch_layout.nb_channels;

411 int sample_size = s->sample_size;

412 int c, n, ret, samples_per_block;

413 uint8_t *samples;

414 int32_t *dst_int32_t;

415

416 samples_per_block = 1;

417 if (avctx->codec_id == AV_CODEC_ID_PCM_LXF) {

418 /* we process 40-bit blocks per channel for LXF */

419 samples_per_block = 2;

420 }

421

422 if (channels == 0) {

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

424 return AVERROR(EINVAL);

425 }

426

427 if (avctx->codec_id != avctx->codec->id) {

428 av_log(avctx, AV_LOG_ERROR, "codec ids mismatch\n");

429 return AVERROR(EINVAL);

430 }

431

432 n = channels * sample_size;

433

434 if (n && buf_size % n) {

435 if (buf_size < n) {

436 av_log(avctx, AV_LOG_ERROR,

437 "Invalid PCM packet, data has size %d but at least a size of %d was expected\n",

438 buf_size, n);

439 return AVERROR_INVALIDDATA;

440 } else

441 buf_size -= buf_size % n;

442 }

443

444 n = buf_size / sample_size;

445

446 /* get output buffer */

447 frame->nb_samples = n * samples_per_block / channels;

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

449 return ret;

450 samples = frame->data[0];

451

452 switch (avctx->codec_id) {

453 case AV_CODEC_ID_PCM_U32LE:

454 DECODE(32, le32, src, samples, n, 0, 0x80000000)

455 break;

456 case AV_CODEC_ID_PCM_U32BE:

457 DECODE(32, be32, src, samples, n, 0, 0x80000000)

458 break;

459 case AV_CODEC_ID_PCM_S24LE:

460 DECODE(32, le24, src, samples, n, 8, 0)

461 break;

462 case AV_CODEC_ID_PCM_S24LE_PLANAR:

463 DECODE_PLANAR(32, le24, src, samples, n, 8, 0);

464 break;

465 case AV_CODEC_ID_PCM_S24BE:

466 DECODE(32, be24, src, samples, n, 8, 0)

467 break;

468 case AV_CODEC_ID_PCM_U24LE:

469 DECODE(32, le24, src, samples, n, 8, 0x800000)

470 break;

471 case AV_CODEC_ID_PCM_U24BE:

472 DECODE(32, be24, src, samples, n, 8, 0x800000)

473 break;

474 case AV_CODEC_ID_PCM_S24DAUD:

475 for (; n > 0; n--) {

476 uint32_t v = bytestream_get_be24(&src);

477 v >>= 4; // sync flags are here

478 AV_WN16A(samples, ff_reverse[(v >> 8) & 0xff] +

479 (ff_reverse[v & 0xff] << 8));

480 samples += 2;

481 }

482 break;

483 case AV_CODEC_ID_PCM_U16LE:

484 DECODE(16, le16, src, samples, n, 0, 0x8000)

485 break;

486 case AV_CODEC_ID_PCM_U16BE:

487 DECODE(16, be16, src, samples, n, 0, 0x8000)

488 break;

489 case AV_CODEC_ID_PCM_S8:

490 for (; n > 0; n--)

491 *samples++ = *src++ + 128;

492 break;

493 case AV_CODEC_ID_PCM_SGA:

494 for (; n > 0; n--) {

495 int sign = *src >> 7;

496 int magn = *src & 0x7f;

497 *samples++ = sign ? 128 - magn : 128 + magn;

498 src++;

499 }

500 break;

501 case AV_CODEC_ID_PCM_S8_PLANAR:

502 n /= avctx->ch_layout.nb_channels;

503 for (c = 0; c < avctx->ch_layout.nb_channels; c++) {

504 int i;

505 samples = frame->extended_data[c];

506 for (i = n; i > 0; i--)

507 *samples++ = *src++ + 128;

508 }

509 break;

510 #if HAVE_BIGENDIAN

511 case AV_CODEC_ID_PCM_S64LE:

512 case AV_CODEC_ID_PCM_F64LE:

513 DECODE(64, le64, src, samples, n, 0, 0)

514 break;

515 case AV_CODEC_ID_PCM_S32LE:

516 case AV_CODEC_ID_PCM_F32LE:

517 case AV_CODEC_ID_PCM_F24LE:

518 case AV_CODEC_ID_PCM_F16LE:

519 DECODE(32, le32, src, samples, n, 0, 0)

520 break;

521 case AV_CODEC_ID_PCM_S32LE_PLANAR:

522 DECODE_PLANAR(32, le32, src, samples, n, 0, 0);

523 break;

524 case AV_CODEC_ID_PCM_S16LE:

525 DECODE(16, le16, src, samples, n, 0, 0)

526 break;

527 case AV_CODEC_ID_PCM_S16LE_PLANAR:

528 DECODE_PLANAR(16, le16, src, samples, n, 0, 0);

529 break;

530 case AV_CODEC_ID_PCM_F64BE:

531 case AV_CODEC_ID_PCM_F32BE:

532 case AV_CODEC_ID_PCM_S64BE:

533 case AV_CODEC_ID_PCM_S32BE:

534 case AV_CODEC_ID_PCM_S16BE:

535 #else

536 case AV_CODEC_ID_PCM_S64BE:

537 case AV_CODEC_ID_PCM_F64BE:

538 DECODE(64, be64, src, samples, n, 0, 0)

539 break;

540 case AV_CODEC_ID_PCM_F32BE:

541 case AV_CODEC_ID_PCM_S32BE:

542 DECODE(32, be32, src, samples, n, 0, 0)

543 break;

544 case AV_CODEC_ID_PCM_S16BE:

545 DECODE(16, be16, src, samples, n, 0, 0)

546 break;

547 case AV_CODEC_ID_PCM_S16BE_PLANAR:

548 DECODE_PLANAR(16, be16, src, samples, n, 0, 0);

549 break;

550 case AV_CODEC_ID_PCM_F64LE:

551 case AV_CODEC_ID_PCM_F32LE:

552 case AV_CODEC_ID_PCM_F24LE:

553 case AV_CODEC_ID_PCM_F16LE:

554 case AV_CODEC_ID_PCM_S64LE:

555 case AV_CODEC_ID_PCM_S32LE:

556 case AV_CODEC_ID_PCM_S16LE:

557 #endif /* HAVE_BIGENDIAN */

558 case AV_CODEC_ID_PCM_U8:

559 memcpy(samples, src, n * sample_size);

560 break;

561 #if HAVE_BIGENDIAN

562 case AV_CODEC_ID_PCM_S16BE_PLANAR:

563 #else

564 case AV_CODEC_ID_PCM_S16LE_PLANAR:

565 case AV_CODEC_ID_PCM_S32LE_PLANAR:

566 #endif /* HAVE_BIGENDIAN */

567 n /= avctx->ch_layout.nb_channels;

568 for (c = 0; c < avctx->ch_layout.nb_channels; c++) {

569 samples = frame->extended_data[c];

570 bytestream_get_buffer(&src, samples, n * sample_size);

571 }

572 break;

573 #if CONFIG_PCM_ALAW_DECODER || CONFIG_PCM_MULAW_DECODER || \

574 CONFIG_PCM_VIDC_DECODER

575 case AV_CODEC_ID_PCM_ALAW:

576 case AV_CODEC_ID_PCM_MULAW:

577 case AV_CODEC_ID_PCM_VIDC: {

578 const int16_t *const lut = ((PCMLUTDecode*)avctx->priv_data)->table;

579 int16_t *restrict samples_16 = (int16_t*)samples;

580

581 for (; n > 0; n--)

582 *samples_16++ = lut[*src++];

583 break;

584 }

585 #endif

586 case AV_CODEC_ID_PCM_LXF:

587 {

588 int i;

589 n /= channels;

590 for (c = 0; c < channels; c++) {

591 dst_int32_t = (int32_t *)frame->extended_data[c];

592 for (i = 0; i < n; i++) {

593 // extract low 20 bits and expand to 32 bits

594 *dst_int32_t++ = ((uint32_t)src[2]<<28) |

595 (src[1] << 20) |

596 (src[0] << 12) |

597 ((src[2] & 0x0F) << 8) |

598 src[1];

599 // extract high 20 bits and expand to 32 bits

600 *dst_int32_t++ = ((uint32_t)src[4]<<24) |

601 (src[3] << 16) |

602 ((src[2] & 0xF0) << 8) |

603 (src[4] << 4) |

604 (src[3] >> 4);

605 src += 5;

606 }

607 }

608 break;

609 }

610 default:

611 return -1;

612 }

613

614 if (avctx->codec_id == AV_CODEC_ID_PCM_F16LE ||

615 avctx->codec_id == AV_CODEC_ID_PCM_F24LE) {

616 PCMScaleDecode *s2 = avctx->priv_data;

617 s2->vector_fmul_scalar((float *)frame->extended_data[0],

618 (const float *)frame->extended_data[0],

619 s2->scale, FFALIGN(frame->nb_samples * avctx->ch_layout.nb_channels, 4));

620 }

621

622 *got_frame_ptr = 1;

623

624 return buf_size;

625 }

626

627 #define PCM_ENCODER_0(id_, sample_fmt_, name_, long_name_)

628 #define PCM_ENCODER_1(id_, sample_fmt_, name_, long_name_) \

629 const FFCodec ff_ ## name_ ## _encoder = { \

630 .p.name = #name_, \

631 CODEC_LONG_NAME(long_name_), \

632 .p.type = AVMEDIA_TYPE_AUDIO, \

633 .p.id = id_, \

634 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_VARIABLE_FRAME_SIZE | \

635 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, \

636 .init = pcm_encode_init, \

637 FF_CODEC_ENCODE_CB(pcm_encode_frame), \

638 CODEC_SAMPLEFMTS(sample_fmt_), \

639 }

640

641 #define PCM_ENCODER_2(cf, id, sample_fmt, name, long_name) \

642 PCM_ENCODER_ ## cf(id, sample_fmt, name, long_name)

643 #define PCM_ENCODER_3(cf, id, sample_fmt, name, long_name) \

644 PCM_ENCODER_2(cf, id, sample_fmt, name, long_name)

645 #define PCM_ENCODER(id, sample_fmt, name, long_name) \

646 PCM_ENCODER_3(CONFIG_PCM_ ## id ## _ENCODER, AV_CODEC_ID_PCM_ ## id, \

647 AV_SAMPLE_FMT_ ## sample_fmt, pcm_ ## name, long_name)

648

649 #define PCM_DECODER_0(id, sample_fmt, name, long_name, Context, init_func)

650 #define PCM_DECODER_1(id_, sample_fmt, name_, long_name, Context, init_func)\

651 const FFCodec ff_ ## name_ ## _decoder = { \

652 .p.name = #name_, \

653 CODEC_LONG_NAME(long_name), \

654 .p.type = AVMEDIA_TYPE_AUDIO, \

655 .p.id = id_, \

656 .priv_data_size = sizeof(Context), \

657 .init = init_func, \

658 FF_CODEC_DECODE_CB(pcm_decode_frame), \

659 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_PARAM_CHANGE, \

660 }

661

662 #define PCM_DECODER_2(cf, id, sample_fmt, name, long_name, Context, init_func) \

663 PCM_DECODER_ ## cf(id, sample_fmt, name, long_name, Context, init_func)

664 #define PCM_DECODER_3(cf, id, sample_fmt, name, long_name, Context, init_func) \

665 PCM_DECODER_2(cf, id, sample_fmt, name, long_name, Context, init_func)

666 #define PCM_DEC_EXT(id, sample_fmt, name, long_name, Context, init_func) \

667 PCM_DECODER_3(CONFIG_PCM_ ## id ## _DECODER, AV_CODEC_ID_PCM_ ## id, \

668 AV_SAMPLE_FMT_ ## sample_fmt, pcm_ ## name, long_name, \

669 Context, init_func)

670

671 #define PCM_DECODER(id, sample_fmt, name, long_name) \

672 PCM_DEC_EXT(id, sample_fmt, name, long_name, PCMDecode, pcm_decode_init)

673

674 #define PCM_CODEC(id, sample_fmt_, name, long_name_) \

675 PCM_ENCODER(id, sample_fmt_, name, long_name_); \

676 PCM_DECODER(id, sample_fmt_, name, long_name_)

677

678 #define PCM_CODEC_EXT(id, sample_fmt, name, long_name, DecContext, dec_init_func) \

679 PCM_DEC_EXT(id, sample_fmt, name, long_name, DecContext, dec_init_func); \

680 PCM_ENCODER(id, sample_fmt, name, long_name)

681

682 /* Note: Do not forget to add new entries to the Makefile and

683 * to the table in pcm_decode_init() as well. */

684 // AV_CODEC_ID_* pcm_* name

685 // AV_SAMPLE_FMT_* long name DecodeContext decode init func

686 PCM_CODEC_EXT(ALAW, S16, alaw, "PCM A-law / G.711 A-law", PCMLUTDecode, pcm_lut_decode_init);

687 PCM_DEC_EXT (F16LE, FLT, f16le, "PCM 16.8 floating point little-endian", PCMScaleDecode, pcm_scale_decode_init);

688 PCM_DEC_EXT (F24LE, FLT, f24le, "PCM 24.0 floating point little-endian", PCMScaleDecode, pcm_scale_decode_init);

689 PCM_CODEC (F32BE, FLT, f32be, "PCM 32-bit floating point big-endian");

690 PCM_CODEC (F32LE, FLT, f32le, "PCM 32-bit floating point little-endian");

691 PCM_CODEC (F64BE, DBL, f64be, "PCM 64-bit floating point big-endian");

692 PCM_CODEC (F64LE, DBL, f64le, "PCM 64-bit floating point little-endian");

693 PCM_DECODER (LXF, S32P,lxf, "PCM signed 20-bit little-endian planar");

694 PCM_CODEC_EXT(MULAW, S16, mulaw, "PCM mu-law / G.711 mu-law", PCMLUTDecode, pcm_lut_decode_init);

695 PCM_CODEC (S8, U8, s8, "PCM signed 8-bit");

696 PCM_CODEC (S8_PLANAR, U8P, s8_planar, "PCM signed 8-bit planar");

697 PCM_CODEC (S16BE, S16, s16be, "PCM signed 16-bit big-endian");

698 PCM_CODEC (S16BE_PLANAR, S16P,s16be_planar, "PCM signed 16-bit big-endian planar");

699 PCM_CODEC (S16LE, S16, s16le, "PCM signed 16-bit little-endian");

700 PCM_CODEC (S16LE_PLANAR, S16P,s16le_planar, "PCM signed 16-bit little-endian planar");

701 PCM_CODEC (S24BE, S32, s24be, "PCM signed 24-bit big-endian");

702 PCM_CODEC (S24DAUD, S16, s24daud, "PCM D-Cinema audio signed 24-bit");

703 PCM_CODEC (S24LE, S32, s24le, "PCM signed 24-bit little-endian");

704 PCM_CODEC (S24LE_PLANAR, S32P,s24le_planar, "PCM signed 24-bit little-endian planar");

705 PCM_CODEC (S32BE, S32, s32be, "PCM signed 32-bit big-endian");

706 PCM_CODEC (S32LE, S32, s32le, "PCM signed 32-bit little-endian");

707 PCM_CODEC (S32LE_PLANAR, S32P,s32le_planar, "PCM signed 32-bit little-endian planar");

708 PCM_CODEC (U8, U8, u8, "PCM unsigned 8-bit");

709 PCM_CODEC (U16BE, S16, u16be, "PCM unsigned 16-bit big-endian");

710 PCM_CODEC (U16LE, S16, u16le, "PCM unsigned 16-bit little-endian");

711 PCM_CODEC (U24BE, S32, u24be, "PCM unsigned 24-bit big-endian");

712 PCM_CODEC (U24LE, S32, u24le, "PCM unsigned 24-bit little-endian");

713 PCM_CODEC (U32BE, S32, u32be, "PCM unsigned 32-bit big-endian");

714 PCM_CODEC (U32LE, S32, u32le, "PCM unsigned 32-bit little-endian");

715 PCM_CODEC (S64BE, S64, s64be, "PCM signed 64-bit big-endian");

716 PCM_CODEC (S64LE, S64, s64le, "PCM signed 64-bit little-endian");

717 PCM_CODEC_EXT(VIDC, S16, vidc, "PCM Archimedes VIDC", PCMLUTDecode, pcm_lut_decode_init);

718 PCM_DECODER (SGA, U8, sga, "PCM SGA");

AV_CODEC_ID_PCM_S16LE

@ AV_CODEC_ID_PCM_S16LE

Definition: codec_id.h:337

AVCodecContext::frame_size

int frame_size

Number of samples per channel in an audio frame.

Definition: avcodec.h:1051

PCM_CODEC_EXT

#define PCM_CODEC_EXT(id, sample_fmt, name, long_name, DecContext, dec_init_func)

Definition: pcm.c:678

PCM_CODEC

#define PCM_CODEC(id, sample_fmt_, name, long_name_)

Definition: pcm.c:674

AV_CODEC_ID_PCM_F32BE

@ AV_CODEC_ID_PCM_F32BE

Definition: codec_id.h:357

le32

uint64_t_TMPL AV_WL64 unsigned int_TMPL le32

Definition: bytestream.h:92

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

ENCODE

#define ENCODE(type, endian, src, dst, n, shift, offset)

Write PCM samples macro.

Definition: pcm.c:89

pcm_tablegen.h

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1024

thread.h

int64_t

long long int64_t

Definition: coverity.c:34

av_unused

#define av_unused

Definition: attributes.h:151

AV_CODEC_ID_PCM_S32LE_PLANAR

@ AV_CODEC_ID_PCM_S32LE_PLANAR

Definition: codec_id.h:366

AVFrame

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

Definition: frame.h:427

pcm_scale_decode_init

av_unused static av_cold int pcm_scale_decode_init(AVCodecContext *avctx)

Definition: pcm.c:316

AVPacket::data

uint8_t * data

Definition: packet.h:558

AV_CODEC_ID_PCM_S16BE_PLANAR

@ AV_CODEC_ID_PCM_S16BE_PLANAR

Definition: codec_id.h:367

encode.h

ff_reverse

const uint8_t ff_reverse[256]

Definition: reverse.c:23

AV_SAMPLE_FMT_S32P

@ AV_SAMPLE_FMT_S32P

signed 32 bits, planar

Definition: samplefmt.h:65

AV_CODEC_ID_PCM_U24LE

@ AV_CODEC_ID_PCM_U24LE

Definition: codec_id.h:351

AV_CODEC_ID_PCM_SGA

@ AV_CODEC_ID_PCM_SGA

Definition: codec_id.h:373

reverse.h

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:329

AV_CODEC_ID_PCM_S16LE_PLANAR

@ AV_CODEC_ID_PCM_S16LE_PLANAR

Definition: codec_id.h:355

AV_CODEC_ID_PCM_S64LE

@ AV_CODEC_ID_PCM_S64LE

Definition: codec_id.h:368

pcm_decode_init

av_unused static av_cold int pcm_decode_init(AVCodecContext *avctx)

Definition: pcm.c:266

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:440

AV_CODEC_ID_PCM_S16BE

@ AV_CODEC_ID_PCM_S16BE

Definition: codec_id.h:338

PCMScaleDecode::base

PCMDecode base

Definition: pcm.c:310

PCMScaleDecode::scale

float scale

Definition: pcm.c:313

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1039

be24

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL be24

Definition: bytestream.h:97

le24

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL le24

Definition: bytestream.h:93

PCMLUTDecode

Definition: pcm.c:337

PCMScaleDecode::vector_fmul_scalar

void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)

Definition: pcm.c:311

PCM_DECODER

#define PCM_DECODER(id, sample_fmt, name, long_name)

Definition: pcm.c:671

av_get_bits_per_sample

int av_get_bits_per_sample(enum AVCodecID codec_id)

Return codec bits per sample.

Definition: utils.c:549

AV_CODEC_ID_PCM_S8

@ AV_CODEC_ID_PCM_S8

Definition: codec_id.h:341

ff_thread_once

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

Definition: thread.h:205

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:106

@ U8

Definition: sw_ops.c:39

#define s(width, name)

Definition: cbs_vp9.c:198

AV_CODEC_ID_PCM_LXF

@ AV_CODEC_ID_PCM_LXF

Definition: codec_id.h:362

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

Bits per sample/pixel of internal libavcodec pixel/sample format.

Definition: avcodec.h:1553

AV_CODEC_ID_PCM_F24LE

@ AV_CODEC_ID_PCM_F24LE

Definition: codec_id.h:371

channels

Definition: aptx.h:31

decode.h

AV_WN16A

#define AV_WN16A(p, v)

Definition: intreadwrite.h:530

AV_CODEC_ID_PCM_MULAW

@ AV_CODEC_ID_PCM_MULAW

Definition: codec_id.h:343

AV_CODEC_ID_PCM_U16BE

@ AV_CODEC_ID_PCM_U16BE

Definition: codec_id.h:340

codec_id

enum AVCodecID codec_id

Definition: vaapi_decode.c:410

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:441

if(ret)

Definition: filter_design.txt:179

pcm_encode_frame

static av_unused int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)

Definition: pcm.c:107

AV_CODEC_ID_PCM_ALAW

@ AV_CODEC_ID_PCM_ALAW

Definition: codec_id.h:344

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

pcm_lut_decode_init

av_unused static av_cold int pcm_lut_decode_init(AVCodecContext *avctx)

Definition: pcm.c:342

AV_CODEC_ID_PCM_U24BE

@ AV_CODEC_ID_PCM_U24BE

Definition: codec_id.h:352

AVFloatDSPContext::vector_fmul_scalar

void(* vector_fmul_scalar)(float *dst, const float *src, float mul, int len)

Multiply a vector of floats by a scalar float.

Definition: float_dsp.h:85

ENTRY

#define ENTRY(CODEC_ID, SAMPLE_FMT, BITS_PER_SAMPLE)

av_unreachable

#define av_unreachable(msg)

Asserts that are used as compiler optimization hints depending upon ASSERT_LEVEL and NBDEBUG.

Definition: avassert.h:108

AV_CODEC_ID_PCM_U32BE

@ AV_CODEC_ID_PCM_U32BE

Definition: codec_id.h:348

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:481

AV_CODEC_ID_PCM_S64BE

@ AV_CODEC_ID_PCM_S64BE

Definition: codec_id.h:369

be64

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL be64

Definition: bytestream.h:95

DECODE_PLANAR

#define DECODE_PLANAR(size, endian, src, dst, n, shift, offset)

Definition: pcm.c:392

pcm_decode_frame

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

Definition: pcm.c:404

be32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL be32

Definition: bytestream.h:96

AVOnce

#define AVOnce

Definition: thread.h:202

Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c

Definition: undefined.txt:32

AV_CODEC_ID_PCM_S24LE_PLANAR

@ AV_CODEC_ID_PCM_S24LE_PLANAR

Definition: codec_id.h:365

float_dsp.h

AVCodecID

Identify the syntax and semantics of the bitstream.

Definition: codec_id.h:49

AV_CODEC_ID_PCM_VIDC

@ AV_CODEC_ID_PCM_VIDC

Definition: codec_id.h:372

AV_CODEC_ID_PCM_S24LE

@ AV_CODEC_ID_PCM_S24LE

Definition: codec_id.h:349

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1720

AVPacket::size

int size

Definition: packet.h:559

codec_internal.h

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

for

for(k=2;k<=8;++k)

Definition: h264pred_template.c:424

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1031

AVFloatDSPContext

Definition: float_dsp.h:24

DECODE

#define DECODE(size, endian, src, dst, n, shift, offset)

Read PCM samples macro.

Definition: pcm.c:385

PCMLUTDecode::table

int16_t table[256]

Definition: pcm.c:339

ENCODE_PLANAR

#define ENCODE_PLANAR(type, endian, dst, n, shift, offset)

Definition: pcm.c:96

attributes.h

AVCodec::id

enum AVCodecID id

Definition: codec.h:186

PCMLUTDecode::base

PCMDecode base

Definition: pcm.c:338

AVCodecContext::bits_per_coded_sample

int bits_per_coded_sample

bits per sample/pixel from the demuxer (needed for huffyuv).

Definition: avcodec.h:1546

bytestream_put_buffer

static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)

Definition: bytestream.h:372

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

Definition: cbs_h2645.c:256

av_assert1

#define av_assert1(cond)

assert() equivalent, that does not lie in speed critical code.

Definition: avassert.h:57

AV_CODEC_ID_PCM_F64BE

@ AV_CODEC_ID_PCM_F64BE

Definition: codec_id.h:359

AV_CODEC_ID_PCM_S32BE

@ AV_CODEC_ID_PCM_S32BE

Definition: codec_id.h:346

AV_SAMPLE_FMT_S16

@ AV_SAMPLE_FMT_S16

signed 16 bits

Definition: samplefmt.h:58

le64

uint64_t_TMPL le64

Definition: bytestream.h:91

AV_CODEC_ID_PCM_F16LE

@ AV_CODEC_ID_PCM_F16LE

Definition: codec_id.h:370

len

int len

Definition: vorbis_enc_data.h:426

avcodec.h

bytestream_get_buffer

static av_always_inline unsigned int bytestream_get_buffer(const uint8_t **b, uint8_t *dst, unsigned int size)

Definition: bytestream.h:363

ret

Definition: filter_design.txt:187

AVCodecContext::block_align

int block_align

number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.

Definition: avcodec.h:1057

frame

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

Definition: filter_design.txt:265

be16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL be16

Definition: bytestream.h:98

PCMDecode

Definition: pcm.c:262

le16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL le16

Definition: bytestream.h:94

PCM_DEC_EXT

#define PCM_DEC_EXT(id, sample_fmt, name, long_name, Context, init_func)

Definition: pcm.c:666

AVCodecContext

main external API structure.

Definition: avcodec.h:431