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.
4842 Commits
32 Branches
866MB
Tree: b461b3bc4a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'b461b3bc4a'
${ noResults }
FFmpeg/libavcodec/pcm.c

545 lines
15KB
Raw Blame History 

  1. /*

  2.  * PCM codecs

  3.  * Copyright (c) 2001 Fabrice Bellard.

  4.  *

  5.  * This library is free software; you can redistribute it and/or

  6.  * modify it under the terms of the GNU Lesser General Public

  7.  * License as published by the Free Software Foundation; either

  8.  * version 2 of the License, or (at your option) any later version.

  9.  *

  10.  * This library is distributed in the hope that it will be useful,

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

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

  13.  * Lesser General Public License for more details.

  14.  *

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

  16.  * License along with this library; if not, write to the Free Software

  17.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  18.  */

  19.  

  20. /**

  21.  * @file pcm.c

  22.  * PCM codecs

  23.  */

  24.  

  25. #include "avcodec.h"

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

  27. 

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

  29. 

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

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

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

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

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

  35. 

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

  37. 

  38. /*

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

  40.  *

  41.  */

  42. static int alaw2linear(unsigned char	a_val)

  43. {

  44. 	int		t;

  45. 	int		seg;

  46. 

  47. 	a_val ^= 0x55;

  48. 

  49. 	t = a_val & QUANT_MASK;

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

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

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

  53. 

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

  55. }

  56. 

  57. static int ulaw2linear(unsigned char	u_val)

  58. {

  59. 	int		t;

  60. 

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

  62. 	u_val = ~u_val;

  63. 

  64. 	/*

  65. 	 * Extract and bias the quantization bits. Then

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

  67. 	 */

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

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

  70. 

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

  72. }

  73. 

  74. /* 16384 entries per table */

  75. static uint8_t *linear_to_alaw = NULL;

  76. static int linear_to_alaw_ref = 0;

  77. 

  78. static uint8_t *linear_to_ulaw = NULL;

  79. static int linear_to_ulaw_ref = 0;

  80. 

  81. static void build_xlaw_table(uint8_t *linear_to_xlaw, 

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

  83.                              int mask) 

  84. {

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

  86. 

  87.     j = 0;

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

  89.         if (i != 127) {

  90.             v1 = xlaw2linear(i ^ mask);

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

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

  93.         } else {

  94.             v = 8192;

  95.         }

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

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

  98.             if (j > 0)

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

  100.         }

  101.     }

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

  103. }

  104. 

  105. static int pcm_encode_init(AVCodecContext *avctx)

  106. {

  107.     avctx->frame_size = 1;

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

  109.     case CODEC_ID_PCM_ALAW:

  110.         if (linear_to_alaw_ref == 0) {

  111.             linear_to_alaw = av_malloc(16384);

  112.             if (!linear_to_alaw)

  113.                 return -1;

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

  115.         }

  116.         linear_to_alaw_ref++;

  117.         break;

  118.     case CODEC_ID_PCM_MULAW:

  119.         if (linear_to_ulaw_ref == 0) {

  120.             linear_to_ulaw = av_malloc(16384);

  121.             if (!linear_to_ulaw)

  122.                 return -1;

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

  124.         }

  125.         linear_to_ulaw_ref++;

  126.         break;

  127.     default:

  128.         break;

  129.     }

  130.     

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

  132.     case CODEC_ID_PCM_S32LE:

  133.     case CODEC_ID_PCM_S32BE:

  134.     case CODEC_ID_PCM_U32LE:

  135.     case CODEC_ID_PCM_U32BE:

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

  137.         break;

  138.     case CODEC_ID_PCM_S24LE:

  139.     case CODEC_ID_PCM_S24BE:

  140.     case CODEC_ID_PCM_U24LE:

  141.     case CODEC_ID_PCM_U24BE:

  142.     case CODEC_ID_PCM_S24DAUD:

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

  144.         break;

  145.     case CODEC_ID_PCM_S16LE:

  146.     case CODEC_ID_PCM_S16BE:

  147.     case CODEC_ID_PCM_U16LE:

  148.     case CODEC_ID_PCM_U16BE:

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

  150.         break;

  151.     case CODEC_ID_PCM_S8:

  152.     case CODEC_ID_PCM_U8:

  153.     case CODEC_ID_PCM_MULAW:

  154.     case CODEC_ID_PCM_ALAW:

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

  156.         break;

  157.     default:

  158.         break;

  159.     }

  160. 

  161.     avctx->coded_frame= avcodec_alloc_frame();

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

  163.     

  164.     return 0;

  165. }

  166. 

  167. static int pcm_encode_close(AVCodecContext *avctx)

  168. {

  169.     av_freep(&avctx->coded_frame);

  170. 

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

  172.     case CODEC_ID_PCM_ALAW:

  173.         if (--linear_to_alaw_ref == 0)

  174.             av_free(linear_to_alaw);

  175.         break;

  176.     case CODEC_ID_PCM_MULAW:

  177.         if (--linear_to_ulaw_ref == 0)

  178.             av_free(linear_to_ulaw);

  179.         break;

  180.     default:

  181.         /* nothing to free */

  182.         break;

  183.     }

  184.     return 0;

  185. }

  186. 

  187. /**

  188.  * \brief convert samples from 16 bit

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

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

  191.  * \param samples input samples

  192.  * \param dst output samples

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

  194.  */

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

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

  197.     if (bps > 2)

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

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

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

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

  202.         if (us) v += 0x8000;

  203.         (*dst)[le] = v >> 8;

  204.         (*dst)[1 - le] = v;

  205.         *dst += bps;

  206.     }

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

  208. }

  209. 

  210. static int pcm_encode_frame(AVCodecContext *avctx,

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

  212. {

  213.     int n, sample_size, v;

  214.     short *samples;

  215.     unsigned char *dst;

  216. 

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

  218.     case CODEC_ID_PCM_S32LE:

  219.     case CODEC_ID_PCM_S32BE:

  220.     case CODEC_ID_PCM_U32LE:

  221.     case CODEC_ID_PCM_U32BE:

  222.         sample_size = 4;

  223.         break;

  224.     case CODEC_ID_PCM_S24LE:

  225.     case CODEC_ID_PCM_S24BE:

  226.     case CODEC_ID_PCM_U24LE:

  227.     case CODEC_ID_PCM_U24BE:

  228.     case CODEC_ID_PCM_S24DAUD:

  229.         sample_size = 3;

  230.         break;

  231.     case CODEC_ID_PCM_S16LE:

  232.     case CODEC_ID_PCM_S16BE:

  233.     case CODEC_ID_PCM_U16LE:

  234.     case CODEC_ID_PCM_U16BE:

  235.         sample_size = 2;

  236.         break;

  237.     default:

  238.         sample_size = 1;

  239.         break;

  240.     }

  241.     n = buf_size / sample_size;

  242.     samples = data;

  243.     dst = frame;

  244. 

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

  246.     case CODEC_ID_PCM_S32LE:

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

  248.         break;

  249.     case CODEC_ID_PCM_S32BE:

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

  251.         break;

  252.     case CODEC_ID_PCM_U32LE:

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

  254.         break;

  255.     case CODEC_ID_PCM_U32BE:

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

  257.         break;

  258.     case CODEC_ID_PCM_S24LE:

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

  260.         break;

  261.     case CODEC_ID_PCM_S24BE:

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

  263.         break;

  264.     case CODEC_ID_PCM_U24LE:

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

  266.         break;

  267.     case CODEC_ID_PCM_U24BE:

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

  269.         break;

  270.     case CODEC_ID_PCM_S24DAUD:

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

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

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

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

  275.             dst[2] = tmp & 0xff;

  276.             tmp >>= 8;

  277.             dst[1] = tmp & 0xff;

  278.             dst[0] = tmp >> 8;

  279.             samples++;

  280.             dst += 3;

  281.         }

  282.         break;

  283.     case CODEC_ID_PCM_S16LE:

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

  285.             v = *samples++;

  286.             dst[0] = v & 0xff;

  287.             dst[1] = v >> 8;

  288.             dst += 2;

  289.         }

  290.         break;

  291.     case CODEC_ID_PCM_S16BE:

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

  293.             v = *samples++;

  294.             dst[0] = v >> 8;

  295.             dst[1] = v;

  296.             dst += 2;

  297.         }

  298.         break;

  299.     case CODEC_ID_PCM_U16LE:

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

  301.             v = *samples++;

  302.             v += 0x8000;

  303.             dst[0] = v & 0xff;

  304.             dst[1] = v >> 8;

  305.             dst += 2;

  306.         }

  307.         break;

  308.     case CODEC_ID_PCM_U16BE:

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

  310.             v = *samples++;

  311.             v += 0x8000;

  312.             dst[0] = v >> 8;

  313.             dst[1] = v;

  314.             dst += 2;

  315.         }

  316.         break;

  317.     case CODEC_ID_PCM_S8:

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

  319.             v = *samples++;

  320.             dst[0] = v >> 8;

  321.             dst++;

  322.         }

  323.         break;

  324.     case CODEC_ID_PCM_U8:

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

  326.             v = *samples++;

  327.             dst[0] = (v >> 8) + 128;

  328.             dst++;

  329.         }

  330.         break;

  331.     case CODEC_ID_PCM_ALAW:

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

  333.             v = *samples++;

  334.             dst[0] = linear_to_alaw[(v + 32768) >> 2];

  335.             dst++;

  336.         }

  337.         break;

  338.     case CODEC_ID_PCM_MULAW:

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

  340.             v = *samples++;

  341.             dst[0] = linear_to_ulaw[(v + 32768) >> 2];

  342.             dst++;

  343.         }

  344.         break;

  345.     default:

  346.         return -1;

  347.     }

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

  349. 

  350.     return dst - frame;

  351. }

  352. 

  353. typedef struct PCMDecode {

  354.     short table[256];

  355. } PCMDecode;

  356. 

  357. static int pcm_decode_init(AVCodecContext * avctx)

  358. {

  359.     PCMDecode *s = avctx->priv_data;

  360.     int i;

  361. 

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

  363.     case CODEC_ID_PCM_ALAW:

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

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

  366.         break;

  367.     case CODEC_ID_PCM_MULAW:

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

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

  370.         break;

  371.     default:

  372.         break;

  373.     }

  374.     return 0;

  375. }

  376. 

  377. /**

  378.  * \brief convert samples to 16 bit

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

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

  381.  * \param src input samples

  382.  * \param samples output samples

  383.  * \param src_len number of bytes in src

  384.  */

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

  386.                                uint8_t **src, short **samples, int src_len)

  387. {

  388.     register int n = src_len / bps;

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

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

  391.         *(*samples)++ = ((*src)[le] << 8 | (*src)[1 - le]) - (us?0x8000:0);

  392.         *src += bps;

  393.     }

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

  395. }

  396. 

  397. static int pcm_decode_frame(AVCodecContext *avctx,

  398. 			    void *data, int *data_size,

  399. 			    uint8_t *buf, int buf_size)

  400. {

  401.     PCMDecode *s = avctx->priv_data;

  402.     int n;

  403.     short *samples;

  404.     uint8_t *src;

  405. 

  406.     samples = data;

  407.     src = buf;

  408. 

  409.     if(buf_size > AVCODEC_MAX_AUDIO_FRAME_SIZE/2)

  410.         buf_size = AVCODEC_MAX_AUDIO_FRAME_SIZE/2;

  411. 

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

  413.     case CODEC_ID_PCM_S32LE:

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

  415.         break;

  416.     case CODEC_ID_PCM_S32BE:

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

  418.         break;

  419.     case CODEC_ID_PCM_U32LE:

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

  421.         break;

  422.     case CODEC_ID_PCM_U32BE:

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

  424.         break;

  425.     case CODEC_ID_PCM_S24LE:

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

  427.         break;

  428.     case CODEC_ID_PCM_S24BE:

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

  430.         break;

  431.     case CODEC_ID_PCM_U24LE:

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

  433.         break;

  434.     case CODEC_ID_PCM_U24BE:

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

  436.         break;

  437.     case CODEC_ID_PCM_S24DAUD:

  438.         n = buf_size / 3;

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

  440.           uint32_t v = src[0] << 16 | src[1] << 8 | src[2];

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

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

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

  444.           src += 3;

  445.         }

  446.         break;

  447.     case CODEC_ID_PCM_S16LE:

  448.         n = buf_size >> 1;

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

  450.             *samples++ = src[0] | (src[1] << 8);

  451.             src += 2;

  452.         }

  453.         break;

  454.     case CODEC_ID_PCM_S16BE:

  455.         n = buf_size >> 1;

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

  457.             *samples++ = (src[0] << 8) | src[1];

  458.             src += 2;

  459.         }

  460.         break;

  461.     case CODEC_ID_PCM_U16LE:

  462.         n = buf_size >> 1;

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

  464.             *samples++ = (src[0] | (src[1] << 8)) - 0x8000;

  465.             src += 2;

  466.         }

  467.         break;

  468.     case CODEC_ID_PCM_U16BE:

  469.         n = buf_size >> 1;

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

  471.             *samples++ = ((src[0] << 8) | src[1]) - 0x8000;

  472.             src += 2;

  473.         }

  474.         break;

  475.     case CODEC_ID_PCM_S8:

  476.         n = buf_size;

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

  478.             *samples++ = src[0] << 8;

  479.             src++;

  480.         }

  481.         break;

  482.     case CODEC_ID_PCM_U8:

  483.         n = buf_size;

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

  485.             *samples++ = ((int)src[0] - 128) << 8;

  486.             src++;

  487.         }

  488.         break;

  489.     case CODEC_ID_PCM_ALAW:

  490.     case CODEC_ID_PCM_MULAW:

  491.         n = buf_size;

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

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

  494.             src++;

  495.         }

  496.         break;

  497.     default:

  498.         return -1;

  499.     }

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

  501.     return src - buf;

  502. }

  503. 

  504. #define PCM_CODEC(id, name)                     \

  505. AVCodec name ## _encoder = {                    \

  506.     #name,                                      \

  507.     CODEC_TYPE_AUDIO,                           \

  508.     id,                                         \

  509.     0,                                          \

  510.     pcm_encode_init,				\

  511.     pcm_encode_frame,				\

  512.     pcm_encode_close,				\

  513.     NULL,                                       \

  514. };                                              \

  515. AVCodec name ## _decoder = {                    \

  516.     #name,                                      \

  517.     CODEC_TYPE_AUDIO,                           \

  518.     id,                                         \

  519.     sizeof(PCMDecode),                          \

  520.     pcm_decode_init,				\

  521.     NULL,                                       \

  522.     NULL,                                       \

  523.     pcm_decode_frame,                           \

  524. }

  525. 

  526. PCM_CODEC(CODEC_ID_PCM_S32LE, pcm_s32le);

  527. PCM_CODEC(CODEC_ID_PCM_S32BE, pcm_s32be);

  528. PCM_CODEC(CODEC_ID_PCM_U32LE, pcm_u32le);

  529. PCM_CODEC(CODEC_ID_PCM_U32BE, pcm_u32be);

  530. PCM_CODEC(CODEC_ID_PCM_S24LE, pcm_s24le);

  531. PCM_CODEC(CODEC_ID_PCM_S24BE, pcm_s24be);

  532. PCM_CODEC(CODEC_ID_PCM_U24LE, pcm_u24le);

  533. PCM_CODEC(CODEC_ID_PCM_U24BE, pcm_u24be);

  534. PCM_CODEC(CODEC_ID_PCM_S24DAUD, pcm_s24daud);

  535. PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le);

  536. PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be);

  537. PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le);

  538. PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be);

  539. PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8);

  540. PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8);

  541. PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw);

  542. PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw);

  543. 

  544. #undef PCM_CODEC