FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/dcaadpcm.c
Date: 2024-04-20 14:10:07
Exec Total Coverage
Lines: 21 108 19.4%
Functions: 3 9 33.3%
Branches: 11 40 27.5%

Line Branch Exec Source
1 /*
2 * DCA ADPCM engine
3 * Copyright (C) 2017 Daniil Cherednik
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22
23 #include "libavutil/mem.h"
24 #include "dcaadpcm.h"
25 #include "dcaenc.h"
26 #include "dca_core.h"
27 #include "mathops.h"
28
29 typedef int32_t premultiplied_coeffs[10];
30
31 //assume we have DCA_ADPCM_COEFFS values before x
32 static inline int64_t calc_corr(const int32_t *x, int len, int j, int k)
33 {
34 int n;
35 int64_t s = 0;
36 for (n = 0; n < len; n++)
37 s += MUL64(x[n-j], x[n-k]);
38 return s;
39 }
40
41 static inline int64_t apply_filter(const int16_t a[DCA_ADPCM_COEFFS], const int64_t corr[15], const int32_t aa[10])
42 {
43 int64_t err = 0;
44 int64_t tmp = 0;
45
46 err = corr[0];
47
48 tmp += MUL64(a[0], corr[1]);
49 tmp += MUL64(a[1], corr[2]);
50 tmp += MUL64(a[2], corr[3]);
51 tmp += MUL64(a[3], corr[4]);
52
53 tmp = norm__(tmp, 13);
54 tmp += tmp;
55
56 err -= tmp;
57 tmp = 0;
58
59 tmp += MUL64(corr[5], aa[0]);
60 tmp += MUL64(corr[6], aa[1]);
61 tmp += MUL64(corr[7], aa[2]);
62 tmp += MUL64(corr[8], aa[3]);
63
64 tmp += MUL64(corr[9], aa[4]);
65 tmp += MUL64(corr[10], aa[5]);
66 tmp += MUL64(corr[11], aa[6]);
67
68 tmp += MUL64(corr[12], aa[7]);
69 tmp += MUL64(corr[13], aa[8]);
70
71 tmp += MUL64(corr[14], aa[9]);
72
73 tmp = norm__(tmp, 26);
74
75 err += tmp;
76
77 return llabs(err);
78 }
79
80 static int64_t find_best_filter(const DCAADPCMEncContext *s, const int32_t *in, int len)
81 {
82 const premultiplied_coeffs *precalc_data = s->private_data;
83 int i, j, k = 0;
84 int vq = -1;
85 int64_t err;
86 int64_t min_err = 1ll << 62;
87 int64_t corr[15];
88
89 for (i = 0; i <= DCA_ADPCM_COEFFS; i++)
90 for (j = i; j <= DCA_ADPCM_COEFFS; j++)
91 corr[k++] = calc_corr(in+4, len, i, j);
92
93 for (i = 0; i < DCA_ADPCM_VQCODEBOOK_SZ; i++) {
94 err = apply_filter(ff_dca_adpcm_vb[i], corr, *precalc_data);
95 if (err < min_err) {
96 min_err = err;
97 vq = i;
98 }
99 precalc_data++;
100 }
101
102 return vq;
103 }
104
105 static inline int64_t calc_prediction_gain(int pred_vq, const int32_t *in, int32_t *out, int len)
106 {
107 int i;
108 int32_t error;
109
110 int64_t signal_energy = 0;
111 int64_t error_energy = 0;
112
113 for (i = 0; i < len; i++) {
114 error = in[DCA_ADPCM_COEFFS + i] - ff_dcaadpcm_predict(pred_vq, in + i);
115 out[i] = error;
116 signal_energy += MUL64(in[DCA_ADPCM_COEFFS + i], in[DCA_ADPCM_COEFFS + i]);
117 error_energy += MUL64(error, error);
118 }
119
120 if (!error_energy)
121 return -1;
122
123 return signal_energy / error_energy;
124 }
125
126 int ff_dcaadpcm_subband_analysis(const DCAADPCMEncContext *s, const int32_t *in, int len, int *diff)
127 {
128 int pred_vq, i;
129 int32_t input_buffer[16 + DCA_ADPCM_COEFFS];
130 int32_t input_buffer2[16 + DCA_ADPCM_COEFFS];
131
132 int32_t max = 0;
133 int shift_bits;
134 uint64_t pg = 0;
135
136 for (i = 0; i < len + DCA_ADPCM_COEFFS; i++)
137 max |= FFABS(in[i]);
138
139 // normalize input to simplify apply_filter
140 shift_bits = av_log2(max) - 11;
141
142 for (i = 0; i < len + DCA_ADPCM_COEFFS; i++) {
143 input_buffer[i] = norm__(in[i], 7);
144 input_buffer2[i] = norm__(in[i], shift_bits);
145 }
146
147 pred_vq = find_best_filter(s, input_buffer2, len);
148
149 if (pred_vq < 0)
150 return -1;
151
152 pg = calc_prediction_gain(pred_vq, input_buffer, diff, len);
153
154 // Greater than 10db (10*log(10)) prediction gain to use ADPCM.
155 // TODO: Tune it.
156 if (pg < 10)
157 return -1;
158
159 for (i = 0; i < len; i++)
160 diff[i] <<= 7;
161
162 return pred_vq;
163 }
164
165 2 static void precalc(premultiplied_coeffs *data)
166 {
167 int i, j, k;
168
169
2/2
✓ Branch 0 taken 8192 times.
✓ Branch 1 taken 2 times.
8194 for (i = 0; i < DCA_ADPCM_VQCODEBOOK_SZ; i++) {
170 8192 int id = 0;
171 8192 int32_t t = 0;
172
2/2
✓ Branch 0 taken 32768 times.
✓ Branch 1 taken 8192 times.
40960 for (j = 0; j < DCA_ADPCM_COEFFS; j++) {
173
2/2
✓ Branch 0 taken 81920 times.
✓ Branch 1 taken 32768 times.
114688 for (k = j; k < DCA_ADPCM_COEFFS; k++) {
174 81920 t = (int32_t)ff_dca_adpcm_vb[i][j] * (int32_t)ff_dca_adpcm_vb[i][k];
175
2/2
✓ Branch 0 taken 49152 times.
✓ Branch 1 taken 32768 times.
81920 if (j != k)
176 49152 t *= 2;
177 81920 (*data)[id++] = t;
178 }
179 }
180 8192 data++;
181 }
182 2 }
183
184 int ff_dcaadpcm_do_real(int pred_vq_index,
185 softfloat quant, int32_t scale_factor, int32_t step_size,
186 const int32_t *prev_hist, const int32_t *in, int32_t *next_hist, int32_t *out,
187 int len, int32_t peak)
188 {
189 int i;
190 int64_t delta;
191 int32_t dequant_delta;
192 int32_t work_bufer[16 + DCA_ADPCM_COEFFS];
193
194 memcpy(work_bufer, prev_hist, sizeof(int32_t) * DCA_ADPCM_COEFFS);
195
196 for (i = 0; i < len; i++) {
197 work_bufer[DCA_ADPCM_COEFFS + i] = ff_dcaadpcm_predict(pred_vq_index, &work_bufer[i]);
198
199 delta = (int64_t)in[i] - ((int64_t)work_bufer[DCA_ADPCM_COEFFS + i] << 7);
200
201 out[i] = quantize_value(av_clip64(delta, -peak, peak), quant);
202
203 ff_dca_core_dequantize(&dequant_delta, &out[i], step_size, scale_factor, 0, 1);
204
205 work_bufer[DCA_ADPCM_COEFFS+i] += dequant_delta;
206 }
207
208 memcpy(next_hist, &work_bufer[len], sizeof(int32_t) * DCA_ADPCM_COEFFS);
209
210 return 0;
211 }
212
213 2 av_cold int ff_dcaadpcm_init(DCAADPCMEncContext *s)
214 {
215
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (!s)
216 return -1;
217
218 2 s->private_data = av_malloc(sizeof(premultiplied_coeffs) * DCA_ADPCM_VQCODEBOOK_SZ);
219
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (!s->private_data)
220 return AVERROR(ENOMEM);
221
222 2 precalc(s->private_data);
223 2 return 0;
224 }
225
226 2 av_cold void ff_dcaadpcm_free(DCAADPCMEncContext *s)
227 {
228
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
2 if (!s)
229 return;
230
231 2 av_freep(&s->private_data);
232 }
233