falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
13582 Commits
32 Branches
283MB
Tree: abbae514e1
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'abbae514e1'
${ noResults }
FFmpeg/libavcodec/pcm.c

556 lines
15KB
Raw Blame History 

  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 pcm.c

  24.  * PCM codecs

  25.  */

  26. 

  27. #include "avcodec.h"

  28. #include "bitstream.h" // for ff_reverse

  29. #include "bytestream.h"

  30. 

  31. #define MAX_CHANNELS 64

  32. 

  33. /* from g711.c by SUN microsystems (unrestricted use) */

  34. 

  35. #define         SIGN_BIT        (0x80)      /* Sign bit for a A-law byte. */

  36. #define         QUANT_MASK      (0xf)       /* Quantization field mask. */

  37. #define         NSEGS           (8)         /* Number of A-law segments. */

  38. #define         SEG_SHIFT       (4)         /* Left shift for segment number. */

  39. #define         SEG_MASK        (0x70)      /* Segment field mask. */

  40. 

  41. #define         BIAS            (0x84)      /* Bias for linear code. */

  42. 

  43. /*

  44.  * alaw2linear() - Convert an A-law value to 16-bit linear PCM

  45.  *

  46.  */

  47. static av_cold int alaw2linear(unsigned char a_val)

  48. {

  49.         int t;

  50.         int seg;

  51. 

  52.         a_val ^= 0x55;

  53. 

  54.         t = a_val & QUANT_MASK;

  55.         seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;

  56.         if(seg) t= (t + t + 1 + 32) << (seg + 2);

  57.         else    t= (t + t + 1     ) << 3;

  58. 

  59.         return ((a_val & SIGN_BIT) ? t : -t);

  60. }

  61. 

  62. static av_cold int ulaw2linear(unsigned char u_val)

  63. {

  64.         int t;

  65. 

  66.         /* Complement to obtain normal u-law value. */

  67.         u_val = ~u_val;

  68. 

  69.         /*

  70.          * Extract and bias the quantization bits. Then

  71.          * shift up by the segment number and subtract out the bias.

  72.          */

  73.         t = ((u_val & QUANT_MASK) << 3) + BIAS;

  74.         t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;

  75. 

  76.         return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));

  77. }

  78. 

  79. /* 16384 entries per table */

  80. static uint8_t linear_to_alaw[16384];

  81. static uint8_t linear_to_ulaw[16384];

  82. 

  83. static av_cold void build_xlaw_table(uint8_t *linear_to_xlaw,

  84.                              int (*xlaw2linear)(unsigned char),

  85.                              int mask)

  86. {

  87.     int i, j, v, v1, v2;

  88. 

  89.     j = 0;

  90.     for(i=0;i<128;i++) {

  91.         if (i != 127) {

  92.             v1 = xlaw2linear(i ^ mask);

  93.             v2 = xlaw2linear((i + 1) ^ mask);

  94.             v = (v1 + v2 + 4) >> 3;

  95.         } else {

  96.             v = 8192;

  97.         }

  98.         for(;j<v;j++) {

  99.             linear_to_xlaw[8192 + j] = (i ^ mask);

  100.             if (j > 0)

  101.                 linear_to_xlaw[8192 - j] = (i ^ (mask ^ 0x80));

  102.         }

  103.     }

  104.     linear_to_xlaw[0] = linear_to_xlaw[1];

  105. }

  106. 

  107. static av_cold int pcm_encode_init(AVCodecContext *avctx)

  108. {

  109.     avctx->frame_size = 1;

  110.     switch(avctx->codec->id) {

  111.     case CODEC_ID_PCM_ALAW:

  112.         build_xlaw_table(linear_to_alaw, alaw2linear, 0xd5);

  113.         break;

  114.     case CODEC_ID_PCM_MULAW:

  115.         build_xlaw_table(linear_to_ulaw, ulaw2linear, 0xff);

  116.         break;

  117.     default:

  118.         break;

  119.     }

  120. 

  121.     switch(avctx->codec->id) {

  122.     case CODEC_ID_PCM_S32LE:

  123.     case CODEC_ID_PCM_S32BE:

  124.     case CODEC_ID_PCM_U32LE:

  125.     case CODEC_ID_PCM_U32BE:

  126.         avctx->block_align = 4 * avctx->channels;

  127.         break;

  128.     case CODEC_ID_PCM_S24LE:

  129.     case CODEC_ID_PCM_S24BE:

  130.     case CODEC_ID_PCM_U24LE:

  131.     case CODEC_ID_PCM_U24BE:

  132.     case CODEC_ID_PCM_S24DAUD:

  133.         avctx->block_align = 3 * avctx->channels;

  134.         break;

  135.     case CODEC_ID_PCM_S16LE:

  136.     case CODEC_ID_PCM_S16BE:

  137.     case CODEC_ID_PCM_U16LE:

  138.     case CODEC_ID_PCM_U16BE:

  139.         avctx->block_align = 2 * avctx->channels;

  140.         break;

  141.     case CODEC_ID_PCM_S8:

  142.     case CODEC_ID_PCM_U8:

  143.     case CODEC_ID_PCM_MULAW:

  144.     case CODEC_ID_PCM_ALAW:

  145.         avctx->block_align = avctx->channels;

  146.         break;

  147.     default:

  148.         break;

  149.     }

  150. 

  151.     avctx->coded_frame= avcodec_alloc_frame();

  152.     avctx->coded_frame->key_frame= 1;

  153. 

  154.     return 0;

  155. }

  156. 

  157. static av_cold int pcm_encode_close(AVCodecContext *avctx)

  158. {

  159.     av_freep(&avctx->coded_frame);

  160. 

  161.     return 0;

  162. }

  163. 

  164. /**

  165.  * \brief convert samples from 16 bit

  166.  * \param bps byte per sample for the destination format, must be >= 2

  167.  * \param le 0 for big-, 1 for little-endian

  168.  * \param us 0 for signed, 1 for unsigned output

  169.  * \param samples input samples

  170.  * \param dst output samples

  171.  * \param n number of samples in samples buffer.

  172.  */

  173. static inline void encode_from16(int bps, int le, int us,

  174.                                short **samples, uint8_t **dst, int n) {

  175.     int usum = us ? 0x8000 : 0;

  176.     if (bps > 2)

  177.         memset(*dst, 0, n * bps);

  178.     if (le) *dst += bps - 2;

  179.     for(;n>0;n--) {

  180.         register int v = *(*samples)++;

  181.         v += usum;

  182.         if (le) AV_WL16(*dst, v);

  183.         else    AV_WB16(*dst, v);

  184.         *dst += bps;

  185.     }

  186.     if (le) *dst -= bps - 2;

  187. }

  188. 

  189. static int pcm_encode_frame(AVCodecContext *avctx,

  190.                             unsigned char *frame, int buf_size, void *data)

  191. {

  192.     int n, sample_size, v;

  193.     short *samples;

  194.     unsigned char *dst;

  195. 

  196.     switch(avctx->codec->id) {

  197.     case CODEC_ID_PCM_S32LE:

  198.     case CODEC_ID_PCM_S32BE:

  199.     case CODEC_ID_PCM_U32LE:

  200.     case CODEC_ID_PCM_U32BE:

  201.         sample_size = 4;

  202.         break;

  203.     case CODEC_ID_PCM_S24LE:

  204.     case CODEC_ID_PCM_S24BE:

  205.     case CODEC_ID_PCM_U24LE:

  206.     case CODEC_ID_PCM_U24BE:

  207.     case CODEC_ID_PCM_S24DAUD:

  208.         sample_size = 3;

  209.         break;

  210.     case CODEC_ID_PCM_S16LE:

  211.     case CODEC_ID_PCM_S16BE:

  212.     case CODEC_ID_PCM_U16LE:

  213.     case CODEC_ID_PCM_U16BE:

  214.         sample_size = 2;

  215.         break;

  216.     default:

  217.         sample_size = 1;

  218.         break;

  219.     }

  220.     n = buf_size / sample_size;

  221.     samples = data;

  222.     dst = frame;

  223. 

  224.     switch(avctx->codec->id) {

  225.     case CODEC_ID_PCM_S32LE:

  226.         encode_from16(4, 1, 0, &samples, &dst, n);

  227.         break;

  228.     case CODEC_ID_PCM_S32BE:

  229.         encode_from16(4, 0, 0, &samples, &dst, n);

  230.         break;

  231.     case CODEC_ID_PCM_U32LE:

  232.         encode_from16(4, 1, 1, &samples, &dst, n);

  233.         break;

  234.     case CODEC_ID_PCM_U32BE:

  235.         encode_from16(4, 0, 1, &samples, &dst, n);

  236.         break;

  237.     case CODEC_ID_PCM_S24LE:

  238.         encode_from16(3, 1, 0, &samples, &dst, n);

  239.         break;

  240.     case CODEC_ID_PCM_S24BE:

  241.         encode_from16(3, 0, 0, &samples, &dst, n);

  242.         break;

  243.     case CODEC_ID_PCM_U24LE:

  244.         encode_from16(3, 1, 1, &samples, &dst, n);

  245.         break;

  246.     case CODEC_ID_PCM_U24BE:

  247.         encode_from16(3, 0, 1, &samples, &dst, n);

  248.         break;

  249.     case CODEC_ID_PCM_S24DAUD:

  250.         for(;n>0;n--) {

  251.             uint32_t tmp = ff_reverse[*samples >> 8] +

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

  253.             tmp <<= 4; // sync flags would go here

  254.             bytestream_put_be24(&dst, tmp);

  255.             samples++;

  256.         }

  257.         break;

  258.     case CODEC_ID_PCM_S16LE:

  259.         for(;n>0;n--) {

  260.             v = *samples++;

  261.             bytestream_put_le16(&dst, v);

  262.         }

  263.         break;

  264.     case CODEC_ID_PCM_S16BE:

  265.         for(;n>0;n--) {

  266.             v = *samples++;

  267.             bytestream_put_be16(&dst, v);

  268.         }

  269.         break;

  270.     case CODEC_ID_PCM_U16LE:

  271.         for(;n>0;n--) {

  272.             v = *samples++;

  273.             v += 0x8000;

  274.             bytestream_put_le16(&dst, v);

  275.         }

  276.         break;

  277.     case CODEC_ID_PCM_U16BE:

  278.         for(;n>0;n--) {

  279.             v = *samples++;

  280.             v += 0x8000;

  281.             bytestream_put_be16(&dst, v);

  282.         }

  283.         break;

  284.     case CODEC_ID_PCM_S8:

  285.         for(;n>0;n--) {

  286.             v = *samples++;

  287.             *dst++ = v >> 8;

  288.         }

  289.         break;

  290.     case CODEC_ID_PCM_U8:

  291.         for(;n>0;n--) {

  292.             v = *samples++;

  293.             *dst++ = (v >> 8) + 128;

  294.         }

  295.         break;

  296.     case CODEC_ID_PCM_ZORK:

  297.         for(;n>0;n--) {

  298.             v= *samples++ >> 8;

  299.             if(v<0)   v = -v;

  300.             else      v+= 128;

  301.             *dst++ = v;

  302.         }

  303.         break;

  304.     case CODEC_ID_PCM_ALAW:

  305.         for(;n>0;n--) {

  306.             v = *samples++;

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

  308.         }

  309.         break;

  310.     case CODEC_ID_PCM_MULAW:

  311.         for(;n>0;n--) {

  312.             v = *samples++;

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

  314.         }

  315.         break;

  316.     default:

  317.         return -1;

  318.     }

  319.     //avctx->frame_size = (dst - frame) / (sample_size * avctx->channels);

  320. 

  321.     return dst - frame;

  322. }

  323. 

  324. typedef struct PCMDecode {

  325.     short table[256];

  326. } PCMDecode;

  327. 

  328. static av_cold int pcm_decode_init(AVCodecContext * avctx)

  329. {

  330.     PCMDecode *s = avctx->priv_data;

  331.     int i;

  332. 

  333.     switch(avctx->codec->id) {

  334.     case CODEC_ID_PCM_ALAW:

  335.         for(i=0;i<256;i++)

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

  337.         break;

  338.     case CODEC_ID_PCM_MULAW:

  339.         for(i=0;i<256;i++)

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

  341.         break;

  342.     default:

  343.         break;

  344.     }

  345.     return 0;

  346. }

  347. 

  348. /**

  349.  * \brief convert samples to 16 bit

  350.  * \param bps byte per sample for the source format, must be >= 2

  351.  * \param le 0 for big-, 1 for little-endian

  352.  * \param us 0 for signed, 1 for unsigned input

  353.  * \param src input samples

  354.  * \param samples output samples

  355.  * \param src_len number of bytes in src

  356.  */

  357. static inline void decode_to16(int bps, int le, int us,

  358.                                const uint8_t **src, short **samples, int src_len)

  359. {

  360.     int usum = us ? -0x8000 : 0;

  361.     register int n = src_len / bps;

  362.     if (le) *src += bps - 2;

  363.     for(;n>0;n--) {

  364.         register int v;

  365.         if (le) v = AV_RL16(*src);

  366.         else    v = AV_RB16(*src);

  367.         v += usum;

  368.         *(*samples)++ = v;

  369.         *src += bps;

  370.     }

  371.     if (le) *src -= bps - 2;

  372. }

  373. 

  374. static int pcm_decode_frame(AVCodecContext *avctx,

  375.                             void *data, int *data_size,

  376.                             const uint8_t *buf, int buf_size)

  377. {

  378.     PCMDecode *s = avctx->priv_data;

  379.     int c, n;

  380.     short *samples;

  381.     const uint8_t *src, *src2[MAX_CHANNELS];

  382. 

  383.     samples = data;

  384.     src = buf;

  385. 

  386.     n= av_get_bits_per_sample(avctx->codec_id)/8;

  387.     if(n && buf_size % n){

  388.         av_log(avctx, AV_LOG_ERROR, "invalid PCM packet\n");

  389.         return -1;

  390.     }

  391.     if(avctx->channels <= 0 || avctx->channels > MAX_CHANNELS){

  392.         av_log(avctx, AV_LOG_ERROR, "PCM channels out of bounds\n");

  393.         return -1;

  394.     }

  395. 

  396.     buf_size= FFMIN(buf_size, *data_size/2);

  397.     *data_size=0;

  398. 

  399.     n = buf_size/avctx->channels;

  400.     for(c=0;c<avctx->channels;c++)

  401.         src2[c] = &src[c*n];

  402. 

  403.     switch(avctx->codec->id) {

  404.     case CODEC_ID_PCM_S32LE:

  405.         decode_to16(4, 1, 0, &src, &samples, buf_size);

  406.         break;

  407.     case CODEC_ID_PCM_S32BE:

  408.         decode_to16(4, 0, 0, &src, &samples, buf_size);

  409.         break;

  410.     case CODEC_ID_PCM_U32LE:

  411.         decode_to16(4, 1, 1, &src, &samples, buf_size);

  412.         break;

  413.     case CODEC_ID_PCM_U32BE:

  414.         decode_to16(4, 0, 1, &src, &samples, buf_size);

  415.         break;

  416.     case CODEC_ID_PCM_S24LE:

  417.         decode_to16(3, 1, 0, &src, &samples, buf_size);

  418.         break;

  419.     case CODEC_ID_PCM_S24BE:

  420.         decode_to16(3, 0, 0, &src, &samples, buf_size);

  421.         break;

  422.     case CODEC_ID_PCM_U24LE:

  423.         decode_to16(3, 1, 1, &src, &samples, buf_size);

  424.         break;

  425.     case CODEC_ID_PCM_U24BE:

  426.         decode_to16(3, 0, 1, &src, &samples, buf_size);

  427.         break;

  428.     case CODEC_ID_PCM_S24DAUD:

  429.         n = buf_size / 3;

  430.         for(;n>0;n--) {

  431.           uint32_t v = bytestream_get_be24(&src);

  432.           v >>= 4; // sync flags are here

  433.           *samples++ = ff_reverse[(v >> 8) & 0xff] +

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

  435.         }

  436.         break;

  437.     case CODEC_ID_PCM_S16LE:

  438.         n = buf_size >> 1;

  439.         for(;n>0;n--) {

  440.             *samples++ = bytestream_get_le16(&src);

  441.         }

  442.         break;

  443.     case CODEC_ID_PCM_S16LE_PLANAR:

  444.         for(n>>=1;n>0;n--)

  445.             for(c=0;c<avctx->channels;c++)

  446.                 *samples++ = bytestream_get_le16(&src2[c]);

  447.         src = src2[avctx->channels-1];

  448.         break;

  449.     case CODEC_ID_PCM_S16BE:

  450.         n = buf_size >> 1;

  451.         for(;n>0;n--) {

  452.             *samples++ = bytestream_get_be16(&src);

  453.         }

  454.         break;

  455.     case CODEC_ID_PCM_U16LE:

  456.         n = buf_size >> 1;

  457.         for(;n>0;n--) {

  458.             *samples++ = bytestream_get_le16(&src) - 0x8000;

  459.         }

  460.         break;

  461.     case CODEC_ID_PCM_U16BE:

  462.         n = buf_size >> 1;

  463.         for(;n>0;n--) {

  464.             *samples++ = bytestream_get_be16(&src) - 0x8000;

  465.         }

  466.         break;

  467.     case CODEC_ID_PCM_S8:

  468.         n = buf_size;

  469.         for(;n>0;n--) {

  470.             *samples++ = *src++ << 8;

  471.         }

  472.         break;

  473.     case CODEC_ID_PCM_U8:

  474.         n = buf_size;

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

  476.             *samples++ = ((int)*src++ - 128) << 8;

  477.         }

  478.         break;

  479.     case CODEC_ID_PCM_ZORK:

  480.         n = buf_size;

  481.         for(;n>0;n--) {

  482.             int x= *src++;

  483.             if(x&128) x-= 128;

  484.             else      x = -x;

  485.             *samples++ = x << 8;

  486.         }

  487.         break;

  488.     case CODEC_ID_PCM_ALAW:

  489.     case CODEC_ID_PCM_MULAW:

  490.         n = buf_size;

  491.         for(;n>0;n--) {

  492.             *samples++ = s->table[*src++];

  493.         }

  494.         break;

  495.     default:

  496.         return -1;

  497.     }

  498.     *data_size = (uint8_t *)samples - (uint8_t *)data;

  499.     return src - buf;

  500. }

  501. 

  502. #ifdef CONFIG_ENCODERS

  503. #define PCM_ENCODER(id,name)                    \

  504. AVCodec name ## _encoder = {                    \

  505.     #name,                                      \

  506.     CODEC_TYPE_AUDIO,                           \

  507.     id,                                         \

  508.     0,                                          \

  509.     pcm_encode_init,                            \

  510.     pcm_encode_frame,                           \

  511.     pcm_encode_close,                           \

  512.     NULL,                                       \

  513. };

  514. #else

  515. #define PCM_ENCODER(id,name)

  516. #endif

  517. 

  518. #ifdef CONFIG_DECODERS

  519. #define PCM_DECODER(id,name)                    \

  520. AVCodec name ## _decoder = {                    \

  521.     #name,                                      \

  522.     CODEC_TYPE_AUDIO,                           \

  523.     id,                                         \

  524.     sizeof(PCMDecode),                          \

  525.     pcm_decode_init,                            \

  526.     NULL,                                       \

  527.     NULL,                                       \

  528.     pcm_decode_frame,                           \

  529. };

  530. #else

  531. #define PCM_DECODER(id,name)

  532. #endif

  533. 

  534. #define PCM_CODEC(id, name)                     \

  535. PCM_ENCODER(id,name) PCM_DECODER(id,name)

  536. 

  537. PCM_CODEC  (CODEC_ID_PCM_ALAW, pcm_alaw);

  538. PCM_CODEC  (CODEC_ID_PCM_MULAW, pcm_mulaw);

  539. PCM_CODEC  (CODEC_ID_PCM_S8, pcm_s8);

  540. PCM_CODEC  (CODEC_ID_PCM_S16BE, pcm_s16be);

  541. PCM_CODEC  (CODEC_ID_PCM_S16LE, pcm_s16le);

  542. PCM_DECODER(CODEC_ID_PCM_S16LE_PLANAR, pcm_s16le_planar);

  543. PCM_CODEC  (CODEC_ID_PCM_S24BE, pcm_s24be);

  544. PCM_CODEC  (CODEC_ID_PCM_S24DAUD, pcm_s24daud);

  545. PCM_CODEC  (CODEC_ID_PCM_S24LE, pcm_s24le);

  546. PCM_CODEC  (CODEC_ID_PCM_S32BE, pcm_s32be);

  547. PCM_CODEC  (CODEC_ID_PCM_S32LE, pcm_s32le);

  548. PCM_CODEC  (CODEC_ID_PCM_U8, pcm_u8);

  549. PCM_CODEC  (CODEC_ID_PCM_U16BE, pcm_u16be);

  550. PCM_CODEC  (CODEC_ID_PCM_U16LE, pcm_u16le);

  551. PCM_CODEC  (CODEC_ID_PCM_U24BE, pcm_u24be);

  552. PCM_CODEC  (CODEC_ID_PCM_U24LE, pcm_u24le);

  553. PCM_CODEC  (CODEC_ID_PCM_U32BE, pcm_u32be);

  554. PCM_CODEC  (CODEC_ID_PCM_U32LE, pcm_u32le);

  555. PCM_CODEC  (CODEC_ID_PCM_ZORK, pcm_zork);