1 |
|
|
/* |
2 |
|
|
* common functions for the ATRAC family of decoders |
3 |
|
|
* |
4 |
|
|
* Copyright (c) 2006-2013 Maxim Poliakovski |
5 |
|
|
* Copyright (c) 2006-2008 Benjamin Larsson |
6 |
|
|
* |
7 |
|
|
* This file is part of FFmpeg. |
8 |
|
|
* |
9 |
|
|
* FFmpeg is free software; you can redistribute it and/or |
10 |
|
|
* modify it under the terms of the GNU Lesser General Public |
11 |
|
|
* License as published by the Free Software Foundation; either |
12 |
|
|
* version 2.1 of the License, or (at your option) any later version. |
13 |
|
|
* |
14 |
|
|
* FFmpeg is distributed in the hope that it will be useful, |
15 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
16 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
17 |
|
|
* Lesser General Public License for more details. |
18 |
|
|
* |
19 |
|
|
* You should have received a copy of the GNU Lesser General Public |
20 |
|
|
* License along with FFmpeg; if not, write to the Free Software |
21 |
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
22 |
|
|
*/ |
23 |
|
|
|
24 |
|
|
/** |
25 |
|
|
* @file |
26 |
|
|
*/ |
27 |
|
|
|
28 |
|
|
#include <math.h> |
29 |
|
|
#include <stddef.h> |
30 |
|
|
#include <stdio.h> |
31 |
|
|
#include <string.h> |
32 |
|
|
|
33 |
|
|
#include "libavutil/thread.h" |
34 |
|
|
|
35 |
|
|
#include "avcodec.h" |
36 |
|
|
#include "atrac.h" |
37 |
|
|
|
38 |
|
|
float ff_atrac_sf_table[64]; |
39 |
|
|
static float qmf_window[48]; |
40 |
|
|
|
41 |
|
|
static const float qmf_48tap_half[24] = { |
42 |
|
|
-0.00001461907, -0.00009205479,-0.000056157569,0.00030117269, |
43 |
|
|
0.0002422519, -0.00085293897,-0.0005205574, 0.0020340169, |
44 |
|
|
0.00078333891, -0.0042153862, -0.00075614988, 0.0078402944, |
45 |
|
|
-0.000061169922,-0.01344162, 0.0024626821, 0.021736089, |
46 |
|
|
-0.007801671, -0.034090221, 0.01880949, 0.054326009, |
47 |
|
|
-0.043596379, -0.099384367, 0.13207909, 0.46424159 |
48 |
|
|
}; |
49 |
|
|
|
50 |
|
7 |
static av_cold void atrac_generate_tables(void) |
51 |
|
|
{ |
52 |
|
|
/* Generate scale factors */ |
53 |
✓✓ |
455 |
for (int i = 0; i < 64; i++) |
54 |
|
448 |
ff_atrac_sf_table[i] = pow(2.0, (i - 15) / 3.0); |
55 |
|
|
|
56 |
|
|
/* Generate the QMF window. */ |
57 |
✓✓ |
175 |
for (int i = 0; i < 24; i++) { |
58 |
|
168 |
float s = qmf_48tap_half[i] * 2.0; |
59 |
|
168 |
qmf_window[i] = qmf_window[47 - i] = s; |
60 |
|
|
} |
61 |
|
7 |
} |
62 |
|
|
|
63 |
|
9 |
av_cold void ff_atrac_generate_tables(void) |
64 |
|
|
{ |
65 |
|
|
static AVOnce init_static_once = AV_ONCE_INIT; |
66 |
|
9 |
ff_thread_once(&init_static_once, atrac_generate_tables); |
67 |
|
9 |
} |
68 |
|
|
|
69 |
|
11 |
av_cold void ff_atrac_init_gain_compensation(AtracGCContext *gctx, int id2exp_offset, |
70 |
|
|
int loc_scale) |
71 |
|
|
{ |
72 |
|
|
int i; |
73 |
|
|
|
74 |
|
11 |
gctx->loc_scale = loc_scale; |
75 |
|
11 |
gctx->loc_size = 1 << loc_scale; |
76 |
|
11 |
gctx->id2exp_offset = id2exp_offset; |
77 |
|
|
|
78 |
|
|
/* Generate gain level table. */ |
79 |
✓✓ |
187 |
for (i = 0; i < 16; i++) |
80 |
|
176 |
gctx->gain_tab1[i] = powf(2.0, id2exp_offset - i); |
81 |
|
|
|
82 |
|
|
/* Generate gain interpolation table. */ |
83 |
✓✓ |
352 |
for (i = -15; i < 16; i++) |
84 |
|
341 |
gctx->gain_tab2[i + 15] = powf(2.0, -1.0f / gctx->loc_size * i); |
85 |
|
11 |
} |
86 |
|
|
|
87 |
|
26104 |
void ff_atrac_gain_compensation(AtracGCContext *gctx, float *in, float *prev, |
88 |
|
|
AtracGainInfo *gc_now, AtracGainInfo *gc_next, |
89 |
|
|
int num_samples, float *out) |
90 |
|
|
{ |
91 |
|
|
float lev, gc_scale, gain_inc; |
92 |
|
|
int i, pos, lastpos; |
93 |
|
|
|
94 |
|
53768 |
gc_scale = gc_next->num_points ? gctx->gain_tab1[gc_next->lev_code[0]] |
95 |
✓✓ |
26104 |
: 1.0f; |
96 |
|
|
|
97 |
✓✓ |
26104 |
if (!gc_now->num_points) { |
98 |
✓✓ |
3659489 |
for (pos = 0; pos < num_samples; pos++) |
99 |
|
3634944 |
out[pos] = in[pos] * gc_scale + prev[pos]; |
100 |
|
|
} else { |
101 |
|
1559 |
pos = 0; |
102 |
|
|
|
103 |
✓✓ |
3564 |
for (i = 0; i < gc_now->num_points; i++) { |
104 |
|
2005 |
lastpos = gc_now->loc_code[i] << gctx->loc_scale; |
105 |
|
|
|
106 |
|
2005 |
lev = gctx->gain_tab1[gc_now->lev_code[i]]; |
107 |
|
4456 |
gain_inc = gctx->gain_tab2[(i + 1 < gc_now->num_points ? gc_now->lev_code[i + 1] |
108 |
✓✓ |
2005 |
: gctx->id2exp_offset) - |
109 |
|
2005 |
gc_now->lev_code[i] + 15]; |
110 |
|
|
|
111 |
|
|
/* apply constant gain level and overlap */ |
112 |
✓✓ |
123893 |
for (; pos < lastpos; pos++) |
113 |
|
121888 |
out[pos] = (in[pos] * gc_scale + prev[pos]) * lev; |
114 |
|
|
|
115 |
|
|
/* interpolate between two different gain levels */ |
116 |
✓✓ |
13521 |
for (; pos < lastpos + gctx->loc_size; pos++) { |
117 |
|
11516 |
out[pos] = (in[pos] * gc_scale + prev[pos]) * lev; |
118 |
|
11516 |
lev *= gain_inc; |
119 |
|
|
} |
120 |
|
|
} |
121 |
|
|
|
122 |
✓✓ |
141819 |
for (; pos < num_samples; pos++) |
123 |
|
140260 |
out[pos] = in[pos] * gc_scale + prev[pos]; |
124 |
|
|
} |
125 |
|
|
|
126 |
|
|
/* copy the overlapping part into the delay buffer */ |
127 |
|
26104 |
memcpy(prev, &in[num_samples], num_samples * sizeof(float)); |
128 |
|
26104 |
} |
129 |
|
|
|
130 |
|
8056 |
void ff_atrac_iqmf(float *inlo, float *inhi, unsigned int nIn, float *pOut, |
131 |
|
|
float *delayBuf, float *temp) |
132 |
|
|
{ |
133 |
|
|
int i, j; |
134 |
|
|
float *p1, *p3; |
135 |
|
|
|
136 |
|
8056 |
memcpy(temp, delayBuf, 46*sizeof(float)); |
137 |
|
|
|
138 |
|
8056 |
p3 = temp + 46; |
139 |
|
|
|
140 |
|
|
/* loop1 */ |
141 |
✓✓ |
1029624 |
for(i=0; i<nIn; i+=2){ |
142 |
|
1021568 |
p3[2*i+0] = inlo[i ] + inhi[i ]; |
143 |
|
1021568 |
p3[2*i+1] = inlo[i ] - inhi[i ]; |
144 |
|
1021568 |
p3[2*i+2] = inlo[i+1] + inhi[i+1]; |
145 |
|
1021568 |
p3[2*i+3] = inlo[i+1] - inhi[i+1]; |
146 |
|
|
} |
147 |
|
|
|
148 |
|
|
/* loop2 */ |
149 |
|
8056 |
p1 = temp; |
150 |
✓✓ |
2051192 |
for (j = nIn; j != 0; j--) { |
151 |
|
2043136 |
float s1 = 0.0; |
152 |
|
2043136 |
float s2 = 0.0; |
153 |
|
|
|
154 |
✓✓ |
51078400 |
for (i = 0; i < 48; i += 2) { |
155 |
|
49035264 |
s1 += p1[i] * qmf_window[i]; |
156 |
|
49035264 |
s2 += p1[i+1] * qmf_window[i+1]; |
157 |
|
|
} |
158 |
|
|
|
159 |
|
2043136 |
pOut[0] = s2; |
160 |
|
2043136 |
pOut[1] = s1; |
161 |
|
|
|
162 |
|
2043136 |
p1 += 2; |
163 |
|
2043136 |
pOut += 2; |
164 |
|
|
} |
165 |
|
|
|
166 |
|
|
/* Update the delay buffer. */ |
167 |
|
8056 |
memcpy(delayBuf, temp + nIn*2, 46*sizeof(float)); |
168 |
|
8056 |
} |