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.

320 lines
8.1KB

  1. /*
  2. * Sample rate convertion for both audio and video
  3. * Copyright (c) 2000 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 resample.c
  21. * Sample rate convertion for both audio and video.
  22. */
  23. #include "avcodec.h"
  24. #include "os_support.h"
  25. typedef struct {
  26. /* fractional resampling */
  27. uint32_t incr; /* fractional increment */
  28. uint32_t frac;
  29. int last_sample;
  30. /* integer down sample */
  31. int iratio; /* integer divison ratio */
  32. int icount, isum;
  33. int inv;
  34. } ReSampleChannelContext;
  35. struct ReSampleContext {
  36. ReSampleChannelContext channel_ctx[2];
  37. float ratio;
  38. /* channel convert */
  39. int input_channels, output_channels, filter_channels;
  40. };
  41. #define FRAC_BITS 16
  42. #define FRAC (1 << FRAC_BITS)
  43. static void init_mono_resample(ReSampleChannelContext *s, float ratio)
  44. {
  45. ratio = 1.0 / ratio;
  46. s->iratio = (int)floorf(ratio);
  47. if (s->iratio == 0)
  48. s->iratio = 1;
  49. s->incr = (int)((ratio / s->iratio) * FRAC);
  50. s->frac = FRAC;
  51. s->last_sample = 0;
  52. s->icount = s->iratio;
  53. s->isum = 0;
  54. s->inv = (FRAC / s->iratio);
  55. }
  56. /* fractional audio resampling */
  57. static int fractional_resample(ReSampleChannelContext *s, short *output, short *input, int nb_samples)
  58. {
  59. unsigned int frac, incr;
  60. int l0, l1;
  61. short *q, *p, *pend;
  62. l0 = s->last_sample;
  63. incr = s->incr;
  64. frac = s->frac;
  65. p = input;
  66. pend = input + nb_samples;
  67. q = output;
  68. l1 = *p++;
  69. for(;;) {
  70. /* interpolate */
  71. *q++ = (l0 * (FRAC - frac) + l1 * frac) >> FRAC_BITS;
  72. frac = frac + s->incr;
  73. while (frac >= FRAC) {
  74. frac -= FRAC;
  75. if (p >= pend)
  76. goto the_end;
  77. l0 = l1;
  78. l1 = *p++;
  79. }
  80. }
  81. the_end:
  82. s->last_sample = l1;
  83. s->frac = frac;
  84. return q - output;
  85. }
  86. static int integer_downsample(ReSampleChannelContext *s, short *output, short *input, int nb_samples)
  87. {
  88. short *q, *p, *pend;
  89. int c, sum;
  90. p = input;
  91. pend = input + nb_samples;
  92. q = output;
  93. c = s->icount;
  94. sum = s->isum;
  95. for(;;) {
  96. sum += *p++;
  97. if (--c == 0) {
  98. *q++ = (sum * s->inv) >> FRAC_BITS;
  99. c = s->iratio;
  100. sum = 0;
  101. }
  102. if (p >= pend)
  103. break;
  104. }
  105. s->isum = sum;
  106. s->icount = c;
  107. return q - output;
  108. }
  109. /* n1: number of samples */
  110. static void stereo_to_mono(short *output, short *input, int n1)
  111. {
  112. short *p, *q;
  113. int n = n1;
  114. p = input;
  115. q = output;
  116. while (n >= 4) {
  117. q[0] = (p[0] + p[1]) >> 1;
  118. q[1] = (p[2] + p[3]) >> 1;
  119. q[2] = (p[4] + p[5]) >> 1;
  120. q[3] = (p[6] + p[7]) >> 1;
  121. q += 4;
  122. p += 8;
  123. n -= 4;
  124. }
  125. while (n > 0) {
  126. q[0] = (p[0] + p[1]) >> 1;
  127. q++;
  128. p += 2;
  129. n--;
  130. }
  131. }
  132. /* n1: number of samples */
  133. static void mono_to_stereo(short *output, short *input, int n1)
  134. {
  135. short *p, *q;
  136. int n = n1;
  137. int v;
  138. p = input;
  139. q = output;
  140. while (n >= 4) {
  141. v = p[0]; q[0] = v; q[1] = v;
  142. v = p[1]; q[2] = v; q[3] = v;
  143. v = p[2]; q[4] = v; q[5] = v;
  144. v = p[3]; q[6] = v; q[7] = v;
  145. q += 8;
  146. p += 4;
  147. n -= 4;
  148. }
  149. while (n > 0) {
  150. v = p[0]; q[0] = v; q[1] = v;
  151. q += 2;
  152. p += 1;
  153. n--;
  154. }
  155. }
  156. /* XXX: should use more abstract 'N' channels system */
  157. static void stereo_split(short *output1, short *output2, short *input, int n)
  158. {
  159. int i;
  160. for(i=0;i<n;i++) {
  161. *output1++ = *input++;
  162. *output2++ = *input++;
  163. }
  164. }
  165. static void stereo_mux(short *output, short *input1, short *input2, int n)
  166. {
  167. int i;
  168. for(i=0;i<n;i++) {
  169. *output++ = *input1++;
  170. *output++ = *input2++;
  171. }
  172. }
  173. static int mono_resample(ReSampleChannelContext *s, short *output, short *input, int nb_samples)
  174. {
  175. short *buf1;
  176. short *buftmp;
  177. buf1= (short*)av_malloc( nb_samples * sizeof(short) );
  178. /* first downsample by an integer factor with averaging filter */
  179. if (s->iratio > 1) {
  180. buftmp = buf1;
  181. nb_samples = integer_downsample(s, buftmp, input, nb_samples);
  182. } else {
  183. buftmp = input;
  184. }
  185. /* then do a fractional resampling with linear interpolation */
  186. if (s->incr != FRAC) {
  187. nb_samples = fractional_resample(s, output, buftmp, nb_samples);
  188. } else {
  189. memcpy(output, buftmp, nb_samples * sizeof(short));
  190. }
  191. av_free(buf1);
  192. return nb_samples;
  193. }
  194. ReSampleContext *audio_resample_init(int output_channels, int input_channels,
  195. int output_rate, int input_rate)
  196. {
  197. ReSampleContext *s;
  198. int i;
  199. if (output_channels > 2 || input_channels > 2)
  200. return NULL;
  201. s = av_mallocz(sizeof(ReSampleContext));
  202. if (!s)
  203. return NULL;
  204. s->ratio = (float)output_rate / (float)input_rate;
  205. s->input_channels = input_channels;
  206. s->output_channels = output_channels;
  207. s->filter_channels = s->input_channels;
  208. if (s->output_channels < s->filter_channels)
  209. s->filter_channels = s->output_channels;
  210. for(i=0;i<s->filter_channels;i++) {
  211. init_mono_resample(&s->channel_ctx[i], s->ratio);
  212. }
  213. return s;
  214. }
  215. /* resample audio. 'nb_samples' is the number of input samples */
  216. /* XXX: optimize it ! */
  217. /* XXX: do it with polyphase filters, since the quality here is
  218. HORRIBLE. Return the number of samples available in output */
  219. int audio_resample(ReSampleContext *s, short *output, short *input, int nb_samples)
  220. {
  221. int i, nb_samples1;
  222. short *bufin[2];
  223. short *bufout[2];
  224. short *buftmp2[2], *buftmp3[2];
  225. int lenout;
  226. if (s->input_channels == s->output_channels && s->ratio == 1.0) {
  227. /* nothing to do */
  228. memcpy(output, input, nb_samples * s->input_channels * sizeof(short));
  229. return nb_samples;
  230. }
  231. /* XXX: move those malloc to resample init code */
  232. bufin[0]= (short*) av_malloc( nb_samples * sizeof(short) );
  233. bufin[1]= (short*) av_malloc( nb_samples * sizeof(short) );
  234. /* make some zoom to avoid round pb */
  235. lenout= (int)(nb_samples * s->ratio) + 16;
  236. bufout[0]= (short*) av_malloc( lenout * sizeof(short) );
  237. bufout[1]= (short*) av_malloc( lenout * sizeof(short) );
  238. if (s->input_channels == 2 &&
  239. s->output_channels == 1) {
  240. buftmp2[0] = bufin[0];
  241. buftmp3[0] = output;
  242. stereo_to_mono(buftmp2[0], input, nb_samples);
  243. } else if (s->output_channels == 2 && s->input_channels == 1) {
  244. buftmp2[0] = input;
  245. buftmp3[0] = bufout[0];
  246. } else if (s->output_channels == 2) {
  247. buftmp2[0] = bufin[0];
  248. buftmp2[1] = bufin[1];
  249. buftmp3[0] = bufout[0];
  250. buftmp3[1] = bufout[1];
  251. stereo_split(buftmp2[0], buftmp2[1], input, nb_samples);
  252. } else {
  253. buftmp2[0] = input;
  254. buftmp3[0] = output;
  255. }
  256. /* resample each channel */
  257. nb_samples1 = 0; /* avoid warning */
  258. for(i=0;i<s->filter_channels;i++) {
  259. nb_samples1 = mono_resample(&s->channel_ctx[i], buftmp3[i], buftmp2[i], nb_samples);
  260. }
  261. if (s->output_channels == 2 && s->input_channels == 1) {
  262. mono_to_stereo(output, buftmp3[0], nb_samples1);
  263. } else if (s->output_channels == 2) {
  264. stereo_mux(output, buftmp3[0], buftmp3[1], nb_samples1);
  265. }
  266. av_free(bufin[0]);
  267. av_free(bufin[1]);
  268. av_free(bufout[0]);
  269. av_free(bufout[1]);
  270. return nb_samples1;
  271. }
  272. void audio_resample_close(ReSampleContext *s)
  273. {
  274. av_free(s);
  275. }