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 static av_cold int pcm_encode_init(AVCodecContext *avctx)

42 {

43 avctx->frame_size = 0;

44 #if !CONFIG_HARDCODED_TABLES

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

46 #define INIT_ONCE(id, name) \

47 case AV_CODEC_ID_PCM_ ## id: \

48 if (CONFIG_PCM_ ## id ## _ENCODER) { \

49 static AVOnce init_static_once = AV_ONCE_INIT; \

50 ff_thread_once(&init_static_once, pcm_ ## name ## _tableinit); \

51 } \

52 break

53 INIT_ONCE(ALAW, alaw);

54 INIT_ONCE(MULAW, ulaw);

55 INIT_ONCE(VIDC, vidc);

56 default:

57 break;

58 }

59 #endif

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

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

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

65 return 0;

66 }

68 /**

69 * Write PCM samples macro

70 * @param type Datatype of native machine format

71 * @param endian bytestream_put_xxx() suffix

72 * @param src Source pointer (variable name)

73 * @param dst Destination pointer (variable name)

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

75 * @param shift Bitshift (bits)

76 * @param offset Sample value offset

77 */

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

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

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

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

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

83 }

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

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

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

88 int i; \

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

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

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

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

93 } \

94 }

96 static int pcm_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,

97 const AVFrame *frame, int *got_packet_ptr)

98 {

99 int n, c, sample_size, v, ret;

100 const short *samples;

101 unsigned char *dst;

102 const uint8_t *samples_uint8_t;

103 const int16_t *samples_int16_t;

104 const int32_t *samples_int32_t;

105 const int64_t *samples_int64_t;

106 const uint16_t *samples_uint16_t;

107 const uint32_t *samples_uint32_t;

108

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

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

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

112

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

114 return ret;

115 dst = avpkt->data;

116

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

118 case AV_CODEC_ID_PCM_U32LE:

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

120 break;

121 case AV_CODEC_ID_PCM_U32BE:

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

123 break;

124 case AV_CODEC_ID_PCM_S24LE:

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

126 break;

127 case AV_CODEC_ID_PCM_S24LE_PLANAR:

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

129 break;

130 case AV_CODEC_ID_PCM_S24BE:

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

132 break;

133 case AV_CODEC_ID_PCM_U24LE:

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

135 break;

136 case AV_CODEC_ID_PCM_U24BE:

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

138 break;

139 case AV_CODEC_ID_PCM_S24DAUD:

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

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

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

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

144 bytestream_put_be24(&dst, tmp);

145 samples++;

146 }

147 break;

148 case AV_CODEC_ID_PCM_U16LE:

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

150 break;

151 case AV_CODEC_ID_PCM_U16BE:

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

153 break;

154 case AV_CODEC_ID_PCM_S8:

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

156 break;

157 case AV_CODEC_ID_PCM_S8_PLANAR:

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

159 break;

160 #if HAVE_BIGENDIAN

161 case AV_CODEC_ID_PCM_S64LE:

162 case AV_CODEC_ID_PCM_F64LE:

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

164 break;

165 case AV_CODEC_ID_PCM_S32LE:

166 case AV_CODEC_ID_PCM_F32LE:

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

168 break;

169 case AV_CODEC_ID_PCM_S32LE_PLANAR:

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

171 break;

172 case AV_CODEC_ID_PCM_S16LE:

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

174 break;

175 case AV_CODEC_ID_PCM_S16LE_PLANAR:

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

177 break;

178 case AV_CODEC_ID_PCM_F64BE:

179 case AV_CODEC_ID_PCM_F32BE:

180 case AV_CODEC_ID_PCM_S64BE:

181 case AV_CODEC_ID_PCM_S32BE:

182 case AV_CODEC_ID_PCM_S16BE:

183 #else

184 case AV_CODEC_ID_PCM_S64BE:

185 case AV_CODEC_ID_PCM_F64BE:

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

187 break;

188 case AV_CODEC_ID_PCM_F32BE:

189 case AV_CODEC_ID_PCM_S32BE:

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

191 break;

192 case AV_CODEC_ID_PCM_S16BE:

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

194 break;

195 case AV_CODEC_ID_PCM_S16BE_PLANAR:

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

197 break;

198 case AV_CODEC_ID_PCM_F64LE:

199 case AV_CODEC_ID_PCM_F32LE:

200 case AV_CODEC_ID_PCM_S64LE:

201 case AV_CODEC_ID_PCM_S32LE:

202 case AV_CODEC_ID_PCM_S16LE:

203 #endif /* HAVE_BIGENDIAN */

204 case AV_CODEC_ID_PCM_U8:

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

206 break;

207 #if HAVE_BIGENDIAN

208 case AV_CODEC_ID_PCM_S16BE_PLANAR:

209 #else

210 case AV_CODEC_ID_PCM_S16LE_PLANAR:

211 case AV_CODEC_ID_PCM_S32LE_PLANAR:

212 #endif /* HAVE_BIGENDIAN */

213 n /= avctx->ch_layout.nb_channels;

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

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

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

217 }

218 break;

219 case AV_CODEC_ID_PCM_ALAW:

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

221 v = *samples++;

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

223 }

224 break;

225 case AV_CODEC_ID_PCM_MULAW:

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

227 v = *samples++;

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

229 }

230 break;

231 case AV_CODEC_ID_PCM_VIDC:

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

233 v = *samples++;

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

235 }

236 break;

237 default:

238 return -1;

239 }

240

241 *got_packet_ptr = 1;

242 return 0;

243 }

244

245 typedef struct PCMDecode {

246 short table[256];

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

248 int len);

249 float scale;

250 } PCMDecode;

251

252 static av_cold int pcm_decode_init(AVCodecContext *avctx)

253 {

254 PCMDecode *s = avctx->priv_data;

255 AVFloatDSPContext *fdsp;

256 int i;

257

258 switch (avctx->codec_id) {

259 case AV_CODEC_ID_PCM_ALAW:

260 for (i = 0; i < 256; i++)

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

262 break;

263 case AV_CODEC_ID_PCM_MULAW:

264 for (i = 0; i < 256; i++)

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

266 break;

267 case AV_CODEC_ID_PCM_VIDC:

268 for (i = 0; i < 256; i++)

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

270 break;

271 case AV_CODEC_ID_PCM_F16LE:

272 case AV_CODEC_ID_PCM_F24LE:

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

274 return AVERROR_INVALIDDATA;

275

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

277 fdsp = avpriv_float_dsp_alloc(0);

278 if (!fdsp)

279 return AVERROR(ENOMEM);

280 s->vector_fmul_scalar = fdsp->vector_fmul_scalar;

281 av_free(fdsp);

282 break;

283 default:

284 break;

285 }

286

287 avctx->sample_fmt = avctx->codec->sample_fmts[0];

288

289 if (avctx->sample_fmt == AV_SAMPLE_FMT_S32)

290 avctx->bits_per_raw_sample = av_get_bits_per_sample(avctx->codec_id);

291

292 return 0;

293 }

294

295 /**

296 * Read PCM samples macro

297 * @param size Data size of native machine format

298 * @param endian bytestream_get_xxx() endian suffix

299 * @param src Source pointer (variable name)

300 * @param dst Destination pointer (variable name)

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

302 * @param shift Bitshift (bits)

303 * @param offset Sample value offset

304 */

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

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

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

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

309 dst += size / 8; \

310 }

311

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

313 n /= channels; \

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

315 int i; \

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

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

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

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

320 dst += size / 8; \

321 } \

322 }

323

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

325 int *got_frame_ptr, AVPacket *avpkt)

326 {

327 const uint8_t *src = avpkt->data;

328 int buf_size = avpkt->size;

329 PCMDecode *s = avctx->priv_data;

330 int channels = avctx->ch_layout.nb_channels;

331 int sample_size, c, n, ret, samples_per_block;

332 uint8_t *samples;

333 int32_t *dst_int32_t;

334

335 sample_size = av_get_bits_per_sample(avctx->codec_id) / 8;

336

337 /* av_get_bits_per_sample returns 0 for AV_CODEC_ID_PCM_DVD */

338 samples_per_block = 1;

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

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

341 samples_per_block = 2;

342 sample_size = 5;

343 }

344

345 if (sample_size == 0) {

346 av_log(avctx, AV_LOG_ERROR, "Invalid sample_size\n");

347 return AVERROR(EINVAL);

348 }

349

350 if (channels == 0) {

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

352 return AVERROR(EINVAL);

353 }

354

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

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

357 return AVERROR(EINVAL);

358 }

359

360 n = channels * sample_size;

361

362 if (n && buf_size % n) {

363 if (buf_size < n) {

364 av_log(avctx, AV_LOG_ERROR,

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

366 buf_size, n);

367 return AVERROR_INVALIDDATA;

368 } else

369 buf_size -= buf_size % n;

370 }

371

372 n = buf_size / sample_size;

373

374 /* get output buffer */

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

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

377 return ret;

378 samples = frame->data[0];

379

380 switch (avctx->codec_id) {

381 case AV_CODEC_ID_PCM_U32LE:

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

383 break;

384 case AV_CODEC_ID_PCM_U32BE:

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

386 break;

387 case AV_CODEC_ID_PCM_S24LE:

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

389 break;

390 case AV_CODEC_ID_PCM_S24LE_PLANAR:

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

392 break;

393 case AV_CODEC_ID_PCM_S24BE:

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

395 break;

396 case AV_CODEC_ID_PCM_U24LE:

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

398 break;

399 case AV_CODEC_ID_PCM_U24BE:

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

401 break;

402 case AV_CODEC_ID_PCM_S24DAUD:

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

404 uint32_t v = bytestream_get_be24(&src);

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

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

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

408 samples += 2;

409 }

410 break;

411 case AV_CODEC_ID_PCM_U16LE:

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

413 break;

414 case AV_CODEC_ID_PCM_U16BE:

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

416 break;

417 case AV_CODEC_ID_PCM_S8:

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

419 *samples++ = *src++ + 128;

420 break;

421 case AV_CODEC_ID_PCM_SGA:

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

423 int sign = *src >> 7;

424 int magn = *src & 0x7f;

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

426 src++;

427 }

428 break;

429 case AV_CODEC_ID_PCM_S8_PLANAR:

430 n /= avctx->ch_layout.nb_channels;

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

432 int i;

433 samples = frame->extended_data[c];

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

435 *samples++ = *src++ + 128;

436 }

437 break;

438 #if HAVE_BIGENDIAN

439 case AV_CODEC_ID_PCM_S64LE:

440 case AV_CODEC_ID_PCM_F64LE:

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

442 break;

443 case AV_CODEC_ID_PCM_S32LE:

444 case AV_CODEC_ID_PCM_F32LE:

445 case AV_CODEC_ID_PCM_F24LE:

446 case AV_CODEC_ID_PCM_F16LE:

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

448 break;

449 case AV_CODEC_ID_PCM_S32LE_PLANAR:

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

451 break;

452 case AV_CODEC_ID_PCM_S16LE:

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

454 break;

455 case AV_CODEC_ID_PCM_S16LE_PLANAR:

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

457 break;

458 case AV_CODEC_ID_PCM_F64BE:

459 case AV_CODEC_ID_PCM_F32BE:

460 case AV_CODEC_ID_PCM_S64BE:

461 case AV_CODEC_ID_PCM_S32BE:

462 case AV_CODEC_ID_PCM_S16BE:

463 #else

464 case AV_CODEC_ID_PCM_S64BE:

465 case AV_CODEC_ID_PCM_F64BE:

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

467 break;

468 case AV_CODEC_ID_PCM_F32BE:

469 case AV_CODEC_ID_PCM_S32BE:

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

471 break;

472 case AV_CODEC_ID_PCM_S16BE:

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

474 break;

475 case AV_CODEC_ID_PCM_S16BE_PLANAR:

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

477 break;

478 case AV_CODEC_ID_PCM_F64LE:

479 case AV_CODEC_ID_PCM_F32LE:

480 case AV_CODEC_ID_PCM_F24LE:

481 case AV_CODEC_ID_PCM_F16LE:

482 case AV_CODEC_ID_PCM_S64LE:

483 case AV_CODEC_ID_PCM_S32LE:

484 case AV_CODEC_ID_PCM_S16LE:

485 #endif /* HAVE_BIGENDIAN */

486 case AV_CODEC_ID_PCM_U8:

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

488 break;

489 #if HAVE_BIGENDIAN

490 case AV_CODEC_ID_PCM_S16BE_PLANAR:

491 #else

492 case AV_CODEC_ID_PCM_S16LE_PLANAR:

493 case AV_CODEC_ID_PCM_S32LE_PLANAR:

494 #endif /* HAVE_BIGENDIAN */

495 n /= avctx->ch_layout.nb_channels;

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

497 samples = frame->extended_data[c];

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

499 }

500 break;

501 case AV_CODEC_ID_PCM_ALAW:

502 case AV_CODEC_ID_PCM_MULAW:

503 case AV_CODEC_ID_PCM_VIDC:

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

505 AV_WN16A(samples, s->table[*src++]);

506 samples += 2;

507 }

508 break;

509 case AV_CODEC_ID_PCM_LXF:

510 {

511 int i;

512 n /= channels;

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

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

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

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

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

518 (src[1] << 20) |

519 (src[0] << 12) |

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

521 src[1];

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

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

524 (src[3] << 16) |

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

526 (src[4] << 4) |

527 (src[3] >> 4);

528 src += 5;

529 }

530 }

531 break;

532 }

533 default:

534 return -1;

535 }

536

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

538 avctx->codec_id == AV_CODEC_ID_PCM_F24LE) {

539 s->vector_fmul_scalar((float *)frame->extended_data[0],

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

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

542 }

543

544 *got_frame_ptr = 1;

545

546 return buf_size;

547 }

548

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

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

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

552 .p.name = #name_, \

553 CODEC_LONG_NAME(long_name_), \

554 .p.type = AVMEDIA_TYPE_AUDIO, \

555 .p.id = AV_CODEC_ID_ ## id_, \

556 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_VARIABLE_FRAME_SIZE | \

557 AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, \

558 .init = pcm_encode_init, \

559 FF_CODEC_ENCODE_CB(pcm_encode_frame), \

560 .p.sample_fmts = (const enum AVSampleFormat[]){ sample_fmt_, \

561 AV_SAMPLE_FMT_NONE }, \

562 }

563

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

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

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

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

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

569 PCM_ENCODER_3(CONFIG_ ## id ## _ENCODER, id, sample_fmt, name, long_name)

570

571 #define PCM_DECODER_0(id, sample_fmt, name, long_name)

572 #define PCM_DECODER_1(id_, sample_fmt_, name_, long_name_) \

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

574 .p.name = #name_, \

575 CODEC_LONG_NAME(long_name_), \

576 .p.type = AVMEDIA_TYPE_AUDIO, \

577 .p.id = AV_CODEC_ID_ ## id_, \

578 .priv_data_size = sizeof(PCMDecode), \

579 .init = pcm_decode_init, \

580 FF_CODEC_DECODE_CB(pcm_decode_frame), \

581 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_PARAM_CHANGE, \

582 .p.sample_fmts = (const enum AVSampleFormat[]){ sample_fmt_, \

583 AV_SAMPLE_FMT_NONE }, \

584 }

585

586 #define PCM_DECODER_2(cf, id, sample_fmt, name, long_name) \

587 PCM_DECODER_ ## cf(id, sample_fmt, name, long_name)

588 #define PCM_DECODER_3(cf, id, sample_fmt, name, long_name) \

589 PCM_DECODER_2(cf, id, sample_fmt, name, long_name)

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

591 PCM_DECODER_3(CONFIG_ ## id ## _DECODER, id, sample_fmt, name, long_name)

592

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

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

595 PCM_DECODER(id, sample_fmt_, name, long_name_)

596

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

598 PCM_CODEC (PCM_ALAW, AV_SAMPLE_FMT_S16, pcm_alaw, "PCM A-law / G.711 A-law");

599 PCM_DECODER(PCM_F16LE, AV_SAMPLE_FMT_FLT, pcm_f16le, "PCM 16.8 floating point little-endian");

600 PCM_DECODER(PCM_F24LE, AV_SAMPLE_FMT_FLT, pcm_f24le, "PCM 24.0 floating point little-endian");

601 PCM_CODEC (PCM_F32BE, AV_SAMPLE_FMT_FLT, pcm_f32be, "PCM 32-bit floating point big-endian");

602 PCM_CODEC (PCM_F32LE, AV_SAMPLE_FMT_FLT, pcm_f32le, "PCM 32-bit floating point little-endian");

603 PCM_CODEC (PCM_F64BE, AV_SAMPLE_FMT_DBL, pcm_f64be, "PCM 64-bit floating point big-endian");

604 PCM_CODEC (PCM_F64LE, AV_SAMPLE_FMT_DBL, pcm_f64le, "PCM 64-bit floating point little-endian");

605 PCM_DECODER(PCM_LXF, AV_SAMPLE_FMT_S32P,pcm_lxf, "PCM signed 20-bit little-endian planar");

606 PCM_CODEC (PCM_MULAW, AV_SAMPLE_FMT_S16, pcm_mulaw, "PCM mu-law / G.711 mu-law");

607 PCM_CODEC (PCM_S8, AV_SAMPLE_FMT_U8, pcm_s8, "PCM signed 8-bit");

608 PCM_CODEC (PCM_S8_PLANAR, AV_SAMPLE_FMT_U8P, pcm_s8_planar, "PCM signed 8-bit planar");

609 PCM_CODEC (PCM_S16BE, AV_SAMPLE_FMT_S16, pcm_s16be, "PCM signed 16-bit big-endian");

610 PCM_CODEC (PCM_S16BE_PLANAR, AV_SAMPLE_FMT_S16P,pcm_s16be_planar, "PCM signed 16-bit big-endian planar");

611 PCM_CODEC (PCM_S16LE, AV_SAMPLE_FMT_S16, pcm_s16le, "PCM signed 16-bit little-endian");

612 PCM_CODEC (PCM_S16LE_PLANAR, AV_SAMPLE_FMT_S16P,pcm_s16le_planar, "PCM signed 16-bit little-endian planar");

613 PCM_CODEC (PCM_S24BE, AV_SAMPLE_FMT_S32, pcm_s24be, "PCM signed 24-bit big-endian");

614 PCM_CODEC (PCM_S24DAUD, AV_SAMPLE_FMT_S16, pcm_s24daud, "PCM D-Cinema audio signed 24-bit");

615 PCM_CODEC (PCM_S24LE, AV_SAMPLE_FMT_S32, pcm_s24le, "PCM signed 24-bit little-endian");

616 PCM_CODEC (PCM_S24LE_PLANAR, AV_SAMPLE_FMT_S32P,pcm_s24le_planar, "PCM signed 24-bit little-endian planar");

617 PCM_CODEC (PCM_S32BE, AV_SAMPLE_FMT_S32, pcm_s32be, "PCM signed 32-bit big-endian");

618 PCM_CODEC (PCM_S32LE, AV_SAMPLE_FMT_S32, pcm_s32le, "PCM signed 32-bit little-endian");

619 PCM_CODEC (PCM_S32LE_PLANAR, AV_SAMPLE_FMT_S32P,pcm_s32le_planar, "PCM signed 32-bit little-endian planar");

620 PCM_CODEC (PCM_U8, AV_SAMPLE_FMT_U8, pcm_u8, "PCM unsigned 8-bit");

621 PCM_CODEC (PCM_U16BE, AV_SAMPLE_FMT_S16, pcm_u16be, "PCM unsigned 16-bit big-endian");

622 PCM_CODEC (PCM_U16LE, AV_SAMPLE_FMT_S16, pcm_u16le, "PCM unsigned 16-bit little-endian");

623 PCM_CODEC (PCM_U24BE, AV_SAMPLE_FMT_S32, pcm_u24be, "PCM unsigned 24-bit big-endian");

624 PCM_CODEC (PCM_U24LE, AV_SAMPLE_FMT_S32, pcm_u24le, "PCM unsigned 24-bit little-endian");

625 PCM_CODEC (PCM_U32BE, AV_SAMPLE_FMT_S32, pcm_u32be, "PCM unsigned 32-bit big-endian");

626 PCM_CODEC (PCM_U32LE, AV_SAMPLE_FMT_S32, pcm_u32le, "PCM unsigned 32-bit little-endian");

627 PCM_CODEC (PCM_S64BE, AV_SAMPLE_FMT_S64, pcm_s64be, "PCM signed 64-bit big-endian");

628 PCM_CODEC (PCM_S64LE, AV_SAMPLE_FMT_S64, pcm_s64le, "PCM signed 64-bit little-endian");

629 PCM_CODEC (PCM_VIDC, AV_SAMPLE_FMT_S16, pcm_vidc, "PCM Archimedes VIDC");

630 PCM_DECODER(PCM_SGA, AV_SAMPLE_FMT_U8, pcm_sga, "PCM SGA");

AV_CODEC_ID_PCM_S16LE

@ AV_CODEC_ID_PCM_S16LE

Definition: codec_id.h:328

PCMDecode::scale

float scale

Definition: pcm.c:249

AVCodecContext::frame_size

int frame_size

Number of samples per channel in an audio frame.

Definition: avcodec.h:1083

PCM_CODEC

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

Definition: pcm.c:593

linear_to_alaw

static uint8_t linear_to_alaw[16384]

Definition: pcm_tablegen.h:99

AV_CODEC_ID_PCM_F32BE

@ AV_CODEC_ID_PCM_F32BE

Definition: codec_id.h:348

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:78

pcm_tablegen.h

AVCodecContext::sample_rate

int sample_rate

samples per second

Definition: avcodec.h:1056

thread.h

vidc2linear

static av_cold int vidc2linear(unsigned char u_val)

Definition: pcm_tablegen.h:78

int64_t

long long int64_t

Definition: coverity.c:34

AV_CODEC_ID_PCM_S32LE_PLANAR

@ AV_CODEC_ID_PCM_S32LE_PLANAR

Definition: codec_id.h:357

AVFrame

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

Definition: frame.h:389

tmp

static uint8_t tmp[11]

Definition: aes_ctr.c:28

AVPacket::data

uint8_t * data

Definition: packet.h:539

AV_CODEC_ID_PCM_S16BE_PLANAR

@ AV_CODEC_ID_PCM_S16BE_PLANAR

Definition: codec_id.h:358

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:342

AV_CODEC_ID_PCM_SGA

@ AV_CODEC_ID_PCM_SGA

Definition: codec_id.h:364

reverse.h

AVChannelLayout::nb_channels

int nb_channels

Number of channels in this layout.

Definition: channel_layout.h:321

AV_CODEC_ID_PCM_S16LE_PLANAR

@ AV_CODEC_ID_PCM_S16LE_PLANAR

Definition: codec_id.h:346

AV_CODEC_ID_PCM_S64LE

@ AV_CODEC_ID_PCM_S64LE

Definition: codec_id.h:359

AVCodecContext::codec

const struct AVCodec * codec

Definition: avcodec.h:460

AV_CODEC_ID_PCM_S16BE

@ AV_CODEC_ID_PCM_S16BE

Definition: codec_id.h:329

AVCodecContext::ch_layout

AVChannelLayout ch_layout

Audio channel layout.

Definition: avcodec.h:1071

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

PCM_DECODER

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

Definition: pcm.c:590

av_get_bits_per_sample

int av_get_bits_per_sample(enum AVCodecID codec_id)

Return codec bits per sample.

Definition: utils.c:550

AV_CODEC_ID_PCM_S8

@ AV_CODEC_ID_PCM_S8

Definition: codec_id.h:332

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:180

av_cold

#define av_cold

Definition: attributes.h:90

#define s(width, name)

Definition: cbs_vp9.c:198

AV_CODEC_ID_PCM_LXF

@ AV_CODEC_ID_PCM_LXF

Definition: codec_id.h:353

linear_to_ulaw

static uint8_t linear_to_ulaw[16384]

Definition: pcm_tablegen.h:100

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

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

Definition: avcodec.h:1585

AV_CODEC_ID_PCM_F24LE

@ AV_CODEC_ID_PCM_F24LE

Definition: codec_id.h:362

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:334

AV_CODEC_ID_PCM_U16BE

@ AV_CODEC_ID_PCM_U16BE

Definition: codec_id.h:331

AVCodecContext::codec_id

enum AVCodecID codec_id

Definition: avcodec.h:461

if(ret)

Definition: filter_design.txt:179

AV_CODEC_ID_PCM_ALAW

@ AV_CODEC_ID_PCM_ALAW

Definition: codec_id.h:335

AV_CODEC_ID_PCM_U24BE

@ AV_CODEC_ID_PCM_U24BE

Definition: codec_id.h:343

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

AV_CODEC_ID_PCM_U32BE

@ AV_CODEC_ID_PCM_U32BE

Definition: codec_id.h:339

AVCodecContext::bit_rate

int64_t bit_rate

the average bitrate

Definition: avcodec.h:501

AV_CODEC_ID_PCM_S64BE

@ AV_CODEC_ID_PCM_S64BE

Definition: codec_id.h:360

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:312

PCMDecode::vector_fmul_scalar

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

Definition: pcm.c:247

pcm_decode_frame

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

Definition: pcm.c:324

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

pcm_decode_init

static av_cold int pcm_decode_init(AVCodecContext *avctx)

Definition: pcm.c:252

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:356

float_dsp.h

AV_CODEC_ID_PCM_VIDC

@ AV_CODEC_ID_PCM_VIDC

Definition: codec_id.h:363

pcm_encode_frame

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

Definition: pcm.c:96

AV_CODEC_ID_PCM_S24LE

@ AV_CODEC_ID_PCM_S24LE

Definition: codec_id.h:340

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1719

AVPacket::size

int size

Definition: packet.h:540

AV_SAMPLE_FMT_U8P

@ AV_SAMPLE_FMT_U8P

unsigned 8 bits, planar

Definition: samplefmt.h:63

codec_internal.h

alaw2linear

static av_cold int alaw2linear(unsigned char a_val)

Definition: pcm_tablegen.h:46

dst

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

Definition: dsp.h:83

for

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

Definition: h264pred_template.c:425

AVCodecContext::sample_fmt

enum AVSampleFormat sample_fmt

audio sample format

Definition: avcodec.h:1063

AVFloatDSPContext

Definition: float_dsp.h:24

DECODE

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

Read PCM samples macro.

Definition: pcm.c:305

ENCODE_PLANAR

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

Definition: pcm.c:85

attributes.h

AV_SAMPLE_FMT_S16P

@ AV_SAMPLE_FMT_S16P

signed 16 bits, planar

Definition: samplefmt.h:64

AVCodec::id

enum AVCodecID id

Definition: codec.h:201

AVCodecContext::bits_per_coded_sample

int bits_per_coded_sample

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

Definition: avcodec.h:1578

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

PCMDecode::table

short table[256]

Definition: pcm.c:246

AV_SAMPLE_FMT_U8

@ AV_SAMPLE_FMT_U8

unsigned 8 bits

Definition: samplefmt.h:57

AV_CODEC_ID_PCM_F64BE

@ AV_CODEC_ID_PCM_F64BE

Definition: codec_id.h:350

AV_CODEC_ID_PCM_S32BE

@ AV_CODEC_ID_PCM_S32BE

Definition: codec_id.h:337

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:361

len

int len

Definition: vorbis_enc_data.h:426

AVCodec::sample_fmts

attribute_deprecated enum AVSampleFormat * sample_fmts

Definition: codec.h:219

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:1089

frame

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

Definition: filter_design.txt:264

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:245

le16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL le16

Definition: bytestream.h:94

linear_to_vidc

static uint8_t linear_to_vidc[16384]

Definition: pcm_tablegen.h:101

AVCodecContext

main external API structure.

Definition: avcodec.h:451