1/* 2 * PCM codecs 3 * Copyright (c) 2001 Fabrice Bellard 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 */ 21 22/** 23 * @file 24 * PCM codecs 25 */ 26 27#include "avcodec.h" 28#include "libavutil/common.h" /* for av_reverse */ 29#include "bytestream.h" 30#include "pcm_tablegen.h" 31 32#define MAX_CHANNELS 64 33 34static av_cold int pcm_encode_init(AVCodecContext *avctx) 35{ 36 avctx->frame_size = 1; 37 switch(avctx->codec->id) { 38 case CODEC_ID_PCM_ALAW: 39 pcm_alaw_tableinit(); 40 break; 41 case CODEC_ID_PCM_MULAW: 42 pcm_ulaw_tableinit(); 43 break; 44 default: 45 break; 46 } 47 48 avctx->bits_per_coded_sample = av_get_bits_per_sample(avctx->codec->id); 49 avctx->block_align = avctx->channels * avctx->bits_per_coded_sample/8; 50 avctx->coded_frame= avcodec_alloc_frame(); 51 avctx->coded_frame->key_frame= 1; 52 53 return 0; 54} 55 56static av_cold int pcm_encode_close(AVCodecContext *avctx) 57{ 58 av_freep(&avctx->coded_frame); 59 60 return 0; 61} 62 63/** 64 * Write PCM samples macro 65 * @param type Datatype of native machine format 66 * @param endian bytestream_put_xxx() suffix 67 * @param src Source pointer (variable name) 68 * @param dst Destination pointer (variable name) 69 * @param n Total number of samples (variable name) 70 * @param shift Bitshift (bits) 71 * @param offset Sample value offset 72 */ 73#define ENCODE(type, endian, src, dst, n, shift, offset) \ 74 samples_##type = (type*)src; \ 75 for(;n>0;n--) { \ 76 register type v = (*samples_##type++ >> shift) + offset; \ 77 bytestream_put_##endian(&dst, v); \ 78 } 79 80static int pcm_encode_frame(AVCodecContext *avctx, 81 unsigned char *frame, int buf_size, void *data) 82{ 83 int n, sample_size, v; 84 short *samples; 85 unsigned char *dst; 86 uint8_t *srcu8; 87 int16_t *samples_int16_t; 88 int32_t *samples_int32_t; 89 int64_t *samples_int64_t; 90 uint16_t *samples_uint16_t; 91 uint32_t *samples_uint32_t; 92 93 sample_size = av_get_bits_per_sample(avctx->codec->id)/8; 94 n = buf_size / sample_size; 95 samples = data; 96 dst = frame; 97 98 if (avctx->sample_fmt!=avctx->codec->sample_fmts[0]) { 99 av_log(avctx, AV_LOG_ERROR, "invalid sample_fmt\n"); 100 return -1; 101 } 102 103 switch(avctx->codec->id) { 104 case CODEC_ID_PCM_U32LE: 105 ENCODE(uint32_t, le32, samples, dst, n, 0, 0x80000000) 106 break; 107 case CODEC_ID_PCM_U32BE: 108 ENCODE(uint32_t, be32, samples, dst, n, 0, 0x80000000) 109 break; 110 case CODEC_ID_PCM_S24LE: 111 ENCODE(int32_t, le24, samples, dst, n, 8, 0) 112 break; 113 case CODEC_ID_PCM_S24BE: 114 ENCODE(int32_t, be24, samples, dst, n, 8, 0) 115 break; 116 case CODEC_ID_PCM_U24LE: 117 ENCODE(uint32_t, le24, samples, dst, n, 8, 0x800000) 118 break; 119 case CODEC_ID_PCM_U24BE: 120 ENCODE(uint32_t, be24, samples, dst, n, 8, 0x800000) 121 break; 122 case CODEC_ID_PCM_S24DAUD: 123 for(;n>0;n--) { 124 uint32_t tmp = av_reverse[(*samples >> 8) & 0xff] + 125 (av_reverse[*samples & 0xff] << 8); 126 tmp <<= 4; // sync flags would go here 127 bytestream_put_be24(&dst, tmp); 128 samples++; 129 } 130 break; 131 case CODEC_ID_PCM_U16LE: 132 ENCODE(uint16_t, le16, samples, dst, n, 0, 0x8000) 133 break; 134 case CODEC_ID_PCM_U16BE: 135 ENCODE(uint16_t, be16, samples, dst, n, 0, 0x8000) 136 break; 137 case CODEC_ID_PCM_S8: 138 srcu8= data; 139 for(;n>0;n--) { 140 v = *srcu8++; 141 *dst++ = v - 128; 142 } 143 break; 144#if HAVE_BIGENDIAN 145 case CODEC_ID_PCM_F64LE: 146 ENCODE(int64_t, le64, samples, dst, n, 0, 0) 147 break; 148 case CODEC_ID_PCM_S32LE: 149 case CODEC_ID_PCM_F32LE: 150 ENCODE(int32_t, le32, samples, dst, n, 0, 0) 151 break; 152 case CODEC_ID_PCM_S16LE: 153 ENCODE(int16_t, le16, samples, dst, n, 0, 0) 154 break; 155 case CODEC_ID_PCM_F64BE: 156 case CODEC_ID_PCM_F32BE: 157 case CODEC_ID_PCM_S32BE: 158 case CODEC_ID_PCM_S16BE: 159#else 160 case CODEC_ID_PCM_F64BE: 161 ENCODE(int64_t, be64, samples, dst, n, 0, 0) 162 break; 163 case CODEC_ID_PCM_F32BE: 164 case CODEC_ID_PCM_S32BE: 165 ENCODE(int32_t, be32, samples, dst, n, 0, 0) 166 break; 167 case CODEC_ID_PCM_S16BE: 168 ENCODE(int16_t, be16, samples, dst, n, 0, 0) 169 break; 170 case CODEC_ID_PCM_F64LE: 171 case CODEC_ID_PCM_F32LE: 172 case CODEC_ID_PCM_S32LE: 173 case CODEC_ID_PCM_S16LE: 174#endif /* HAVE_BIGENDIAN */ 175 case CODEC_ID_PCM_U8: 176 memcpy(dst, samples, n*sample_size); 177 dst += n*sample_size; 178 break; 179 case CODEC_ID_PCM_ZORK: 180 for(;n>0;n--) { 181 v= *samples++ >> 8; 182 if(v<0) v = -v; 183 else v+= 128; 184 *dst++ = v; 185 } 186 break; 187 case CODEC_ID_PCM_ALAW: 188 for(;n>0;n--) { 189 v = *samples++; 190 *dst++ = linear_to_alaw[(v + 32768) >> 2]; 191 } 192 break; 193 case CODEC_ID_PCM_MULAW: 194 for(;n>0;n--) { 195 v = *samples++; 196 *dst++ = linear_to_ulaw[(v + 32768) >> 2]; 197 } 198 break; 199 default: 200 return -1; 201 } 202 //avctx->frame_size = (dst - frame) / (sample_size * avctx->channels); 203 204 return dst - frame; 205} 206 207typedef struct PCMDecode { 208 short table[256]; 209} PCMDecode; 210 211static av_cold int pcm_decode_init(AVCodecContext * avctx) 212{ 213 PCMDecode *s = avctx->priv_data; 214 int i; 215 216 switch(avctx->codec->id) { 217 case CODEC_ID_PCM_ALAW: 218 for(i=0;i<256;i++) 219 s->table[i] = alaw2linear(i); 220 break; 221 case CODEC_ID_PCM_MULAW: 222 for(i=0;i<256;i++) 223 s->table[i] = ulaw2linear(i); 224 break; 225 default: 226 break; 227 } 228 229 avctx->sample_fmt = avctx->codec->sample_fmts[0]; 230 return 0; 231} 232 233/** 234 * Read PCM samples macro 235 * @param type Datatype of native machine format 236 * @param endian bytestream_get_xxx() endian suffix 237 * @param src Source pointer (variable name) 238 * @param dst Destination pointer (variable name) 239 * @param n Total number of samples (variable name) 240 * @param shift Bitshift (bits) 241 * @param offset Sample value offset 242 */ 243#define DECODE(type, endian, src, dst, n, shift, offset) \ 244 dst_##type = (type*)dst; \ 245 for(;n>0;n--) { \ 246 register type v = bytestream_get_##endian(&src); \ 247 *dst_##type++ = (v - offset) << shift; \ 248 } \ 249 dst = (short*)dst_##type; 250 251static int pcm_decode_frame(AVCodecContext *avctx, 252 void *data, int *data_size, 253 AVPacket *avpkt) 254{ 255 const uint8_t *buf = avpkt->data; 256 int buf_size = avpkt->size; 257 PCMDecode *s = avctx->priv_data; 258 int sample_size, c, n; 259 short *samples; 260 const uint8_t *src, *src8, *src2[MAX_CHANNELS]; 261 uint8_t *dstu8; 262 int16_t *dst_int16_t; 263 int32_t *dst_int32_t; 264 int64_t *dst_int64_t; 265 uint16_t *dst_uint16_t; 266 uint32_t *dst_uint32_t; 267 268 samples = data; 269 src = buf; 270 271 if (avctx->sample_fmt!=avctx->codec->sample_fmts[0]) { 272 av_log(avctx, AV_LOG_ERROR, "invalid sample_fmt\n"); 273 return -1; 274 } 275 276 if(avctx->channels <= 0 || avctx->channels > MAX_CHANNELS){ 277 av_log(avctx, AV_LOG_ERROR, "PCM channels out of bounds\n"); 278 return -1; 279 } 280 281 sample_size = av_get_bits_per_sample(avctx->codec_id)/8; 282 283 /* av_get_bits_per_sample returns 0 for CODEC_ID_PCM_DVD */ 284 if (CODEC_ID_PCM_DVD == avctx->codec_id) 285 /* 2 samples are interleaved per block in PCM_DVD */ 286 sample_size = avctx->bits_per_coded_sample * 2 / 8; 287 288 n = avctx->channels * sample_size; 289 290 if(n && buf_size % n){ 291 if (buf_size < n) { 292 av_log(avctx, AV_LOG_ERROR, "invalid PCM packet\n"); 293 return -1; 294 }else 295 buf_size -= buf_size % n; 296 } 297 298 buf_size= FFMIN(buf_size, *data_size/2); 299 *data_size=0; 300 301 n = buf_size/sample_size; 302 303 switch(avctx->codec->id) { 304 case CODEC_ID_PCM_U32LE: 305 DECODE(uint32_t, le32, src, samples, n, 0, 0x80000000) 306 break; 307 case CODEC_ID_PCM_U32BE: 308 DECODE(uint32_t, be32, src, samples, n, 0, 0x80000000) 309 break; 310 case CODEC_ID_PCM_S24LE: 311 DECODE(int32_t, le24, src, samples, n, 8, 0) 312 break; 313 case CODEC_ID_PCM_S24BE: 314 DECODE(int32_t, be24, src, samples, n, 8, 0) 315 break; 316 case CODEC_ID_PCM_U24LE: 317 DECODE(uint32_t, le24, src, samples, n, 8, 0x800000) 318 break; 319 case CODEC_ID_PCM_U24BE: 320 DECODE(uint32_t, be24, src, samples, n, 8, 0x800000) 321 break; 322 case CODEC_ID_PCM_S24DAUD: 323 for(;n>0;n--) { 324 uint32_t v = bytestream_get_be24(&src); 325 v >>= 4; // sync flags are here 326 *samples++ = av_reverse[(v >> 8) & 0xff] + 327 (av_reverse[v & 0xff] << 8); 328 } 329 break; 330 case CODEC_ID_PCM_S16LE_PLANAR: 331 n /= avctx->channels; 332 for(c=0;c<avctx->channels;c++) 333 src2[c] = &src[c*n*2]; 334 for(;n>0;n--) 335 for(c=0;c<avctx->channels;c++) 336 *samples++ = bytestream_get_le16(&src2[c]); 337 src = src2[avctx->channels-1]; 338 break; 339 case CODEC_ID_PCM_U16LE: 340 DECODE(uint16_t, le16, src, samples, n, 0, 0x8000) 341 break; 342 case CODEC_ID_PCM_U16BE: 343 DECODE(uint16_t, be16, src, samples, n, 0, 0x8000) 344 break; 345 case CODEC_ID_PCM_S8: 346 dstu8= (uint8_t*)samples; 347 for(;n>0;n--) { 348 *dstu8++ = *src++ + 128; 349 } 350 samples= (short*)dstu8; 351 break; 352#if HAVE_BIGENDIAN 353 case CODEC_ID_PCM_F64LE: 354 DECODE(int64_t, le64, src, samples, n, 0, 0) 355 break; 356 case CODEC_ID_PCM_S32LE: 357 case CODEC_ID_PCM_F32LE: 358 DECODE(int32_t, le32, src, samples, n, 0, 0) 359 break; 360 case CODEC_ID_PCM_S16LE: 361 DECODE(int16_t, le16, src, samples, n, 0, 0) 362 break; 363 case CODEC_ID_PCM_F64BE: 364 case CODEC_ID_PCM_F32BE: 365 case CODEC_ID_PCM_S32BE: 366 case CODEC_ID_PCM_S16BE: 367#else 368 case CODEC_ID_PCM_F64BE: 369 DECODE(int64_t, be64, src, samples, n, 0, 0) 370 break; 371 case CODEC_ID_PCM_F32BE: 372 case CODEC_ID_PCM_S32BE: 373 DECODE(int32_t, be32, src, samples, n, 0, 0) 374 break; 375 case CODEC_ID_PCM_S16BE: 376 DECODE(int16_t, be16, src, samples, n, 0, 0) 377 break; 378 case CODEC_ID_PCM_F64LE: 379 case CODEC_ID_PCM_F32LE: 380 case CODEC_ID_PCM_S32LE: 381 case CODEC_ID_PCM_S16LE: 382#endif /* HAVE_BIGENDIAN */ 383 case CODEC_ID_PCM_U8: 384 memcpy(samples, src, n*sample_size); 385 src += n*sample_size; 386 samples = (short*)((uint8_t*)data + n*sample_size); 387 break; 388 case CODEC_ID_PCM_ZORK: 389 for(;n>0;n--) { 390 int x= *src++; 391 if(x&128) x-= 128; 392 else x = -x; 393 *samples++ = x << 8; 394 } 395 break; 396 case CODEC_ID_PCM_ALAW: 397 case CODEC_ID_PCM_MULAW: 398 for(;n>0;n--) { 399 *samples++ = s->table[*src++]; 400 } 401 break; 402 case CODEC_ID_PCM_DVD: 403 dst_int32_t = data; 404 n /= avctx->channels; 405 switch (avctx->bits_per_coded_sample) { 406 case 20: 407 while (n--) { 408 c = avctx->channels; 409 src8 = src + 4*c; 410 while (c--) { 411 *dst_int32_t++ = (bytestream_get_be16(&src) << 16) + ((*src8 &0xf0) << 8); 412 *dst_int32_t++ = (bytestream_get_be16(&src) << 16) + ((*src8++ &0x0f) << 12); 413 } 414 src = src8; 415 } 416 break; 417 case 24: 418 while (n--) { 419 c = avctx->channels; 420 src8 = src + 4*c; 421 while (c--) { 422 *dst_int32_t++ = (bytestream_get_be16(&src) << 16) + ((*src8++) << 8); 423 *dst_int32_t++ = (bytestream_get_be16(&src) << 16) + ((*src8++) << 8); 424 } 425 src = src8; 426 } 427 break; 428 default: 429 av_log(avctx, AV_LOG_ERROR, "PCM DVD unsupported sample depth\n"); 430 return -1; 431 break; 432 } 433 samples = (short *) dst_int32_t; 434 break; 435 default: 436 return -1; 437 } 438 *data_size = (uint8_t *)samples - (uint8_t *)data; 439 return src - buf; 440} 441 442#if CONFIG_ENCODERS 443#define PCM_ENCODER(id,sample_fmt_,name,long_name_) \ 444AVCodec name ## _encoder = { \ 445 #name, \ 446 AVMEDIA_TYPE_AUDIO, \ 447 id, \ 448 0, \ 449 pcm_encode_init, \ 450 pcm_encode_frame, \ 451 pcm_encode_close, \ 452 NULL, \ 453 .sample_fmts = (const enum SampleFormat[]){sample_fmt_,SAMPLE_FMT_NONE}, \ 454 .long_name = NULL_IF_CONFIG_SMALL(long_name_), \ 455}; 456#else 457#define PCM_ENCODER(id,sample_fmt_,name,long_name_) 458#endif 459 460#if CONFIG_DECODERS 461#define PCM_DECODER(id,sample_fmt_,name,long_name_) \ 462AVCodec name ## _decoder = { \ 463 #name, \ 464 AVMEDIA_TYPE_AUDIO, \ 465 id, \ 466 sizeof(PCMDecode), \ 467 pcm_decode_init, \ 468 NULL, \ 469 NULL, \ 470 pcm_decode_frame, \ 471 .sample_fmts = (const enum SampleFormat[]){sample_fmt_,SAMPLE_FMT_NONE}, \ 472 .long_name = NULL_IF_CONFIG_SMALL(long_name_), \ 473}; 474#else 475#define PCM_DECODER(id,sample_fmt_,name,long_name_) 476#endif 477 478#define PCM_CODEC(id, sample_fmt_, name, long_name_) \ 479 PCM_ENCODER(id,sample_fmt_,name,long_name_) PCM_DECODER(id,sample_fmt_,name,long_name_) 480 481/* Note: Do not forget to add new entries to the Makefile as well. */ 482PCM_CODEC (CODEC_ID_PCM_ALAW, SAMPLE_FMT_S16, pcm_alaw, "PCM A-law"); 483PCM_CODEC (CODEC_ID_PCM_DVD, SAMPLE_FMT_S32, pcm_dvd, "PCM signed 20|24-bit big-endian"); 484PCM_CODEC (CODEC_ID_PCM_F32BE, SAMPLE_FMT_FLT, pcm_f32be, "PCM 32-bit floating point big-endian"); 485PCM_CODEC (CODEC_ID_PCM_F32LE, SAMPLE_FMT_FLT, pcm_f32le, "PCM 32-bit floating point little-endian"); 486PCM_CODEC (CODEC_ID_PCM_F64BE, SAMPLE_FMT_DBL, pcm_f64be, "PCM 64-bit floating point big-endian"); 487PCM_CODEC (CODEC_ID_PCM_F64LE, SAMPLE_FMT_DBL, pcm_f64le, "PCM 64-bit floating point little-endian"); 488PCM_CODEC (CODEC_ID_PCM_MULAW, SAMPLE_FMT_S16, pcm_mulaw, "PCM mu-law"); 489PCM_CODEC (CODEC_ID_PCM_S8, SAMPLE_FMT_U8, pcm_s8, "PCM signed 8-bit"); 490PCM_CODEC (CODEC_ID_PCM_S16BE, SAMPLE_FMT_S16, pcm_s16be, "PCM signed 16-bit big-endian"); 491PCM_CODEC (CODEC_ID_PCM_S16LE, SAMPLE_FMT_S16, pcm_s16le, "PCM signed 16-bit little-endian"); 492PCM_DECODER(CODEC_ID_PCM_S16LE_PLANAR, SAMPLE_FMT_S16, pcm_s16le_planar, "PCM 16-bit little-endian planar"); 493PCM_CODEC (CODEC_ID_PCM_S24BE, SAMPLE_FMT_S32, pcm_s24be, "PCM signed 24-bit big-endian"); 494PCM_CODEC (CODEC_ID_PCM_S24DAUD, SAMPLE_FMT_S16, pcm_s24daud, "PCM D-Cinema audio signed 24-bit"); 495PCM_CODEC (CODEC_ID_PCM_S24LE, SAMPLE_FMT_S32, pcm_s24le, "PCM signed 24-bit little-endian"); 496PCM_CODEC (CODEC_ID_PCM_S32BE, SAMPLE_FMT_S32, pcm_s32be, "PCM signed 32-bit big-endian"); 497PCM_CODEC (CODEC_ID_PCM_S32LE, SAMPLE_FMT_S32, pcm_s32le, "PCM signed 32-bit little-endian"); 498PCM_CODEC (CODEC_ID_PCM_U8, SAMPLE_FMT_U8, pcm_u8, "PCM unsigned 8-bit"); 499PCM_CODEC (CODEC_ID_PCM_U16BE, SAMPLE_FMT_S16, pcm_u16be, "PCM unsigned 16-bit big-endian"); 500PCM_CODEC (CODEC_ID_PCM_U16LE, SAMPLE_FMT_S16, pcm_u16le, "PCM unsigned 16-bit little-endian"); 501PCM_CODEC (CODEC_ID_PCM_U24BE, SAMPLE_FMT_S32, pcm_u24be, "PCM unsigned 24-bit big-endian"); 502PCM_CODEC (CODEC_ID_PCM_U24LE, SAMPLE_FMT_S32, pcm_u24le, "PCM unsigned 24-bit little-endian"); 503PCM_CODEC (CODEC_ID_PCM_U32BE, SAMPLE_FMT_S32, pcm_u32be, "PCM unsigned 32-bit big-endian"); 504PCM_CODEC (CODEC_ID_PCM_U32LE, SAMPLE_FMT_S32, pcm_u32le, "PCM unsigned 32-bit little-endian"); 505PCM_CODEC (CODEC_ID_PCM_ZORK, SAMPLE_FMT_S16, pcm_zork, "PCM Zork"); 506