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.

384 lines
9.4KB

  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. * @file pcm.c
  21. * PCM codecs
  22. */
  23. #include "avcodec.h"
  24. /* from g711.c by SUN microsystems (unrestricted use) */
  25. #define SIGN_BIT (0x80) /* Sign bit for a A-law byte. */
  26. #define QUANT_MASK (0xf) /* Quantization field mask. */
  27. #define NSEGS (8) /* Number of A-law segments. */
  28. #define SEG_SHIFT (4) /* Left shift for segment number. */
  29. #define SEG_MASK (0x70) /* Segment field mask. */
  30. #define BIAS (0x84) /* Bias for linear code. */
  31. /*
  32. * alaw2linear() - Convert an A-law value to 16-bit linear PCM
  33. *
  34. */
  35. static int alaw2linear(unsigned char a_val)
  36. {
  37. int t;
  38. int seg;
  39. a_val ^= 0x55;
  40. t = (a_val & QUANT_MASK) << 4;
  41. seg = ((unsigned)a_val & SEG_MASK) >> SEG_SHIFT;
  42. switch (seg) {
  43. case 0:
  44. t += 8;
  45. break;
  46. case 1:
  47. t += 0x108;
  48. break;
  49. default:
  50. t += 0x108;
  51. t <<= seg - 1;
  52. }
  53. return ((a_val & SIGN_BIT) ? t : -t);
  54. }
  55. static int ulaw2linear(unsigned char u_val)
  56. {
  57. int t;
  58. /* Complement to obtain normal u-law value. */
  59. u_val = ~u_val;
  60. /*
  61. * Extract and bias the quantization bits. Then
  62. * shift up by the segment number and subtract out the bias.
  63. */
  64. t = ((u_val & QUANT_MASK) << 3) + BIAS;
  65. t <<= ((unsigned)u_val & SEG_MASK) >> SEG_SHIFT;
  66. return ((u_val & SIGN_BIT) ? (BIAS - t) : (t - BIAS));
  67. }
  68. /* 16384 entries per table */
  69. static uint8_t *linear_to_alaw = NULL;
  70. static int linear_to_alaw_ref = 0;
  71. static uint8_t *linear_to_ulaw = NULL;
  72. static int linear_to_ulaw_ref = 0;
  73. static void build_xlaw_table(uint8_t *linear_to_xlaw,
  74. int (*xlaw2linear)(unsigned char),
  75. int mask)
  76. {
  77. int i, j, v, v1, v2;
  78. j = 0;
  79. for(i=0;i<128;i++) {
  80. if (i != 127) {
  81. v1 = xlaw2linear(i ^ mask);
  82. v2 = xlaw2linear((i + 1) ^ mask);
  83. v = (v1 + v2 + 4) >> 3;
  84. } else {
  85. v = 8192;
  86. }
  87. for(;j<v;j++) {
  88. linear_to_xlaw[8192 + j] = (i ^ mask);
  89. if (j > 0)
  90. linear_to_xlaw[8192 - j] = (i ^ (mask ^ 0x80));
  91. }
  92. }
  93. linear_to_xlaw[0] = linear_to_xlaw[1];
  94. }
  95. static int pcm_encode_init(AVCodecContext *avctx)
  96. {
  97. avctx->frame_size = 1;
  98. switch(avctx->codec->id) {
  99. case CODEC_ID_PCM_ALAW:
  100. if (linear_to_alaw_ref == 0) {
  101. linear_to_alaw = av_malloc(16384);
  102. if (!linear_to_alaw)
  103. return -1;
  104. build_xlaw_table(linear_to_alaw, alaw2linear, 0xd5);
  105. }
  106. linear_to_alaw_ref++;
  107. break;
  108. case CODEC_ID_PCM_MULAW:
  109. if (linear_to_ulaw_ref == 0) {
  110. linear_to_ulaw = av_malloc(16384);
  111. if (!linear_to_ulaw)
  112. return -1;
  113. build_xlaw_table(linear_to_ulaw, ulaw2linear, 0xff);
  114. }
  115. linear_to_ulaw_ref++;
  116. break;
  117. default:
  118. break;
  119. }
  120. avctx->coded_frame= avcodec_alloc_frame();
  121. avctx->coded_frame->key_frame= 1;
  122. return 0;
  123. }
  124. static int pcm_encode_close(AVCodecContext *avctx)
  125. {
  126. av_freep(&avctx->coded_frame);
  127. switch(avctx->codec->id) {
  128. case CODEC_ID_PCM_ALAW:
  129. if (--linear_to_alaw_ref == 0)
  130. av_free(linear_to_alaw);
  131. break;
  132. case CODEC_ID_PCM_MULAW:
  133. if (--linear_to_ulaw_ref == 0)
  134. av_free(linear_to_ulaw);
  135. break;
  136. default:
  137. /* nothing to free */
  138. break;
  139. }
  140. return 0;
  141. }
  142. static int pcm_encode_frame(AVCodecContext *avctx,
  143. unsigned char *frame, int buf_size, void *data)
  144. {
  145. int n, sample_size, v;
  146. short *samples;
  147. unsigned char *dst;
  148. switch(avctx->codec->id) {
  149. case CODEC_ID_PCM_S16LE:
  150. case CODEC_ID_PCM_S16BE:
  151. case CODEC_ID_PCM_U16LE:
  152. case CODEC_ID_PCM_U16BE:
  153. sample_size = 2;
  154. break;
  155. default:
  156. sample_size = 1;
  157. break;
  158. }
  159. n = buf_size / sample_size;
  160. samples = data;
  161. dst = frame;
  162. switch(avctx->codec->id) {
  163. case CODEC_ID_PCM_S16LE:
  164. for(;n>0;n--) {
  165. v = *samples++;
  166. dst[0] = v & 0xff;
  167. dst[1] = v >> 8;
  168. dst += 2;
  169. }
  170. break;
  171. case CODEC_ID_PCM_S16BE:
  172. for(;n>0;n--) {
  173. v = *samples++;
  174. dst[0] = v >> 8;
  175. dst[1] = v;
  176. dst += 2;
  177. }
  178. break;
  179. case CODEC_ID_PCM_U16LE:
  180. for(;n>0;n--) {
  181. v = *samples++;
  182. v += 0x8000;
  183. dst[0] = v & 0xff;
  184. dst[1] = v >> 8;
  185. dst += 2;
  186. }
  187. break;
  188. case CODEC_ID_PCM_U16BE:
  189. for(;n>0;n--) {
  190. v = *samples++;
  191. v += 0x8000;
  192. dst[0] = v >> 8;
  193. dst[1] = v;
  194. dst += 2;
  195. }
  196. break;
  197. case CODEC_ID_PCM_S8:
  198. for(;n>0;n--) {
  199. v = *samples++;
  200. dst[0] = v >> 8;
  201. dst++;
  202. }
  203. break;
  204. case CODEC_ID_PCM_U8:
  205. for(;n>0;n--) {
  206. v = *samples++;
  207. dst[0] = (v >> 8) + 128;
  208. dst++;
  209. }
  210. break;
  211. case CODEC_ID_PCM_ALAW:
  212. for(;n>0;n--) {
  213. v = *samples++;
  214. dst[0] = linear_to_alaw[(v + 32768) >> 2];
  215. dst++;
  216. }
  217. break;
  218. case CODEC_ID_PCM_MULAW:
  219. for(;n>0;n--) {
  220. v = *samples++;
  221. dst[0] = linear_to_ulaw[(v + 32768) >> 2];
  222. dst++;
  223. }
  224. break;
  225. default:
  226. return -1;
  227. }
  228. //avctx->frame_size = (dst - frame) / (sample_size * avctx->channels);
  229. return dst - frame;
  230. }
  231. typedef struct PCMDecode {
  232. short table[256];
  233. } PCMDecode;
  234. static int pcm_decode_init(AVCodecContext * avctx)
  235. {
  236. PCMDecode *s = avctx->priv_data;
  237. int i;
  238. switch(avctx->codec->id) {
  239. case CODEC_ID_PCM_ALAW:
  240. for(i=0;i<256;i++)
  241. s->table[i] = alaw2linear(i);
  242. break;
  243. case CODEC_ID_PCM_MULAW:
  244. for(i=0;i<256;i++)
  245. s->table[i] = ulaw2linear(i);
  246. break;
  247. default:
  248. break;
  249. }
  250. return 0;
  251. }
  252. static int pcm_decode_frame(AVCodecContext *avctx,
  253. void *data, int *data_size,
  254. uint8_t *buf, int buf_size)
  255. {
  256. PCMDecode *s = avctx->priv_data;
  257. int n;
  258. short *samples;
  259. uint8_t *src;
  260. samples = data;
  261. src = buf;
  262. switch(avctx->codec->id) {
  263. case CODEC_ID_PCM_S16LE:
  264. n = buf_size >> 1;
  265. for(;n>0;n--) {
  266. *samples++ = src[0] | (src[1] << 8);
  267. src += 2;
  268. }
  269. break;
  270. case CODEC_ID_PCM_S16BE:
  271. n = buf_size >> 1;
  272. for(;n>0;n--) {
  273. *samples++ = (src[0] << 8) | src[1];
  274. src += 2;
  275. }
  276. break;
  277. case CODEC_ID_PCM_U16LE:
  278. n = buf_size >> 1;
  279. for(;n>0;n--) {
  280. *samples++ = (src[0] | (src[1] << 8)) - 0x8000;
  281. src += 2;
  282. }
  283. break;
  284. case CODEC_ID_PCM_U16BE:
  285. n = buf_size >> 1;
  286. for(;n>0;n--) {
  287. *samples++ = ((src[0] << 8) | src[1]) - 0x8000;
  288. src += 2;
  289. }
  290. break;
  291. case CODEC_ID_PCM_S8:
  292. n = buf_size;
  293. for(;n>0;n--) {
  294. *samples++ = src[0] << 8;
  295. src++;
  296. }
  297. break;
  298. case CODEC_ID_PCM_U8:
  299. n = buf_size;
  300. for(;n>0;n--) {
  301. *samples++ = ((int)src[0] - 128) << 8;
  302. src++;
  303. }
  304. break;
  305. case CODEC_ID_PCM_ALAW:
  306. case CODEC_ID_PCM_MULAW:
  307. n = buf_size;
  308. for(;n>0;n--) {
  309. *samples++ = s->table[src[0]];
  310. src++;
  311. }
  312. break;
  313. default:
  314. *data_size = 0;
  315. return -1;
  316. }
  317. *data_size = (uint8_t *)samples - (uint8_t *)data;
  318. return src - buf;
  319. }
  320. #define PCM_CODEC(id, name) \
  321. AVCodec name ## _encoder = { \
  322. #name, \
  323. CODEC_TYPE_AUDIO, \
  324. id, \
  325. 0, \
  326. pcm_encode_init, \
  327. pcm_encode_frame, \
  328. pcm_encode_close, \
  329. NULL, \
  330. }; \
  331. AVCodec name ## _decoder = { \
  332. #name, \
  333. CODEC_TYPE_AUDIO, \
  334. id, \
  335. sizeof(PCMDecode), \
  336. pcm_decode_init, \
  337. NULL, \
  338. NULL, \
  339. pcm_decode_frame, \
  340. }
  341. PCM_CODEC(CODEC_ID_PCM_S16LE, pcm_s16le);
  342. PCM_CODEC(CODEC_ID_PCM_S16BE, pcm_s16be);
  343. PCM_CODEC(CODEC_ID_PCM_U16LE, pcm_u16le);
  344. PCM_CODEC(CODEC_ID_PCM_U16BE, pcm_u16be);
  345. PCM_CODEC(CODEC_ID_PCM_S8, pcm_s8);
  346. PCM_CODEC(CODEC_ID_PCM_U8, pcm_u8);
  347. PCM_CODEC(CODEC_ID_PCM_ALAW, pcm_alaw);
  348. PCM_CODEC(CODEC_ID_PCM_MULAW, pcm_mulaw);
  349. #undef PCM_CODEC