## ffmpeg / libavcodec / atrac.c @ 53493f9a

History | View | Annotate | Download (3 KB)

1 | 0e1baede | Benjamin Larsson | ```
/*
``` |
---|---|---|---|

2 | ```
* Atrac common functions
``` |
||

3 | ```
* Copyright (c) 2006-2008 Maxim Poliakovski
``` |
||

4 | ```
* Copyright (c) 2006-2008 Benjamin Larsson
``` |
||

5 | ```
*
``` |
||

6 | ```
* This file is part of FFmpeg.
``` |
||

7 | ```
*
``` |
||

8 | ```
* FFmpeg is free software; you can redistribute it and/or
``` |
||

9 | ```
* modify it under the terms of the GNU Lesser General Public
``` |
||

10 | ```
* License as published by the Free Software Foundation; either
``` |
||

11 | ```
* version 2.1 of the License, or (at your option) any later version.
``` |
||

12 | ```
*
``` |
||

13 | ```
* FFmpeg is distributed in the hope that it will be useful,
``` |
||

14 | ```
* but WITHOUT ANY WARRANTY; without even the implied warranty of
``` |
||

15 | ```
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
``` |
||

16 | ```
* Lesser General Public License for more details.
``` |
||

17 | ```
*
``` |
||

18 | ```
* You should have received a copy of the GNU Lesser General Public
``` |
||

19 | ```
* License along with FFmpeg; if not, write to the Free Software
``` |
||

20 | ```
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
``` |
||

21 | ```
*/
``` |
||

22 | |||

23 | ```
/**
``` |
||

24 | ba87f080 | Diego Biurrun | ```
* @file
``` |

25 | 0e1baede | Benjamin Larsson | ```
*/
``` |

26 | |||

27 | #include <math.h> |
||

28 | #include <stddef.h> |
||

29 | #include <stdio.h> |
||

30 | |||

31 | #include "avcodec.h" |
||

32 | #include "dsputil.h" |
||

33 | 862715d3 | Carl Eugen Hoyos | #include "atrac.h" |

34 | 0e1baede | Benjamin Larsson | |

35 | float sf_table[64]; |
||

36 | 53493f9a | Diego Elio PettenÃ² | static float qmf_window[48]; |

37 | 0e1baede | Benjamin Larsson | |

38 | static const float qmf_48tap_half[24] = { |
||

39 | -0.00001461907, -0.00009205479,-0.000056157569,0.00030117269, |
||

40 | 0.0002422519, -0.00085293897,-0.0005205574, 0.0020340169, |
||

41 | 0.00078333891, -0.0042153862, -0.00075614988, 0.0078402944, |
||

42 | -0.000061169922,-0.01344162, 0.0024626821, 0.021736089, |
||

43 | -0.007801671, -0.034090221, 0.01880949, 0.054326009, |
||

44 | -0.043596379, -0.099384367, 0.13207909, 0.46424159 |
||

45 | }; |
||

46 | |||

47 | ```
/**
``` |
||

48 | ```
* Generate common tables
``` |
||

49 | ```
*/
``` |
||

50 | |||

51 | void atrac_generate_tables(void) |
||

52 | { |
||

53 | ```
int i;
``` |
||

54 | ```
float s;
``` |
||

55 | |||

56 | ```
/* Generate scale factors */
``` |
||

57 | if (!sf_table[63]) |
||

58 | for (i=0 ; i<64 ; i++) |
||

59 | sf_table[i] = pow(2.0, (i - 15) / 3.0); |
||

60 | |||

61 | ```
/* Generate the QMF window. */
``` |
||

62 | if (!qmf_window[47]) |
||

63 | for (i=0 ; i<24; i++) { |
||

64 | s = qmf_48tap_half[i] * 2.0; |
||

65 | ```
qmf_window[i] = qmf_window[47 - i] = s;
``` |
||

66 | } |
||

67 | } |
||

68 | |||

69 | |||

70 | ```
/**
``` |
||

71 | ```
* Quadrature mirror synthesis filter.
``` |
||

72 | ```
*
``` |
||

73 | ```
* @param inlo lower part of spectrum
``` |
||

74 | ```
* @param inhi higher part of spectrum
``` |
||

75 | ```
* @param nIn size of spectrum buffer
``` |
||

76 | ```
* @param pOut out buffer
``` |
||

77 | ```
* @param delayBuf delayBuf buffer
``` |
||

78 | ```
* @param temp temp buffer
``` |
||

79 | ```
*/
``` |
||

80 | |||

81 | |||

82 | void atrac_iqmf (float *inlo, float *inhi, unsigned int nIn, float *pOut, float *delayBuf, float *temp) |
||

83 | { |
||

84 | ```
int i, j;
``` |
||

85 | ```
float *p1, *p3;
``` |
||

86 | |||

87 | memcpy(temp, delayBuf, 46*sizeof(float)); |
||

88 | |||

89 | ```
p3 = temp + 46;
``` |
||

90 | |||

91 | ```
/* loop1 */
``` |
||

92 | for(i=0; i<nIn; i+=2){ |
||

93 | p3[2*i+0] = inlo[i ] + inhi[i ]; |
||

94 | p3[2*i+1] = inlo[i ] - inhi[i ]; |
||

95 | p3[2*i+2] = inlo[i+1] + inhi[i+1]; |
||

96 | p3[2*i+3] = inlo[i+1] - inhi[i+1]; |
||

97 | } |
||

98 | |||

99 | ```
/* loop2 */
``` |
||

100 | p1 = temp; |
||

101 | for (j = nIn; j != 0; j--) { |
||

102 | float s1 = 0.0; |
||

103 | float s2 = 0.0; |
||

104 | |||

105 | for (i = 0; i < 48; i += 2) { |
||

106 | s1 += p1[i] * qmf_window[i]; |
||

107 | s2 += p1[i+1] * qmf_window[i+1]; |
||

108 | } |
||

109 | |||

110 | ```
pOut[0] = s2;
``` |
||

111 | ```
pOut[1] = s1;
``` |
||

112 | |||

113 | ```
p1 += 2;
``` |
||

114 | ```
pOut += 2;
``` |
||

115 | } |
||

116 | |||

117 | ```
/* Update the delay buffer. */
``` |
||

118 | memcpy(delayBuf, temp + nIn*2, 46*sizeof(float)); |
||

119 | } |