FFmpeg
aacdec_mips.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012
3  * MIPS Technologies, Inc., California.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  * notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  * notice, this list of conditions and the following disclaimer in the
12  * documentation and/or other materials provided with the distribution.
13  * 3. Neither the name of the MIPS Technologies, Inc., nor the names of its
14  * contributors may be used to endorse or promote products derived from
15  * this software without specific prior written permission.
16  *
17  * THIS SOFTWARE IS PROVIDED BY THE MIPS TECHNOLOGIES, INC. ``AS IS'' AND
18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20  * ARE DISCLAIMED. IN NO EVENT SHALL THE MIPS TECHNOLOGIES, INC. BE LIABLE
21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27  * SUCH DAMAGE.
28  *
29  * Authors: Darko Laus (darko@mips.com)
30  * Djordje Pesut (djordje@mips.com)
31  * Mirjana Vulin (mvulin@mips.com)
32  *
33  * This file is part of FFmpeg.
34  *
35  * FFmpeg is free software; you can redistribute it and/or
36  * modify it under the terms of the GNU Lesser General Public
37  * License as published by the Free Software Foundation; either
38  * version 2.1 of the License, or (at your option) any later version.
39  *
40  * FFmpeg is distributed in the hope that it will be useful,
41  * but WITHOUT ANY WARRANTY; without even the implied warranty of
42  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
43  * Lesser General Public License for more details.
44  *
45  * You should have received a copy of the GNU Lesser General Public
46  * License along with FFmpeg; if not, write to the Free Software
47  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
48  */
49 
50 /**
51  * @file
52  * Reference: libavcodec/aacdec.c
53  */
54 
55 #include "libavutil/attributes.h"
56 #include "libavcodec/aac.h"
57 #include "aacdec_mips.h"
58 #include "libavcodec/aactab.h"
59 #include "libavcodec/sinewin.h"
60 #include "libavutil/mips/asmdefs.h"
61 
62 #if HAVE_INLINE_ASM
63 #if HAVE_MIPSFPU
64 static av_always_inline void float_copy(float *dst, const float *src, int count)
65 {
66  // Copy 'count' floats from src to dst
67  const float *loop_end = src + count;
68  int temp[8];
69 
70  // count must be a multiple of 8
71  av_assert2(count % 8 == 0);
72 
73  // loop unrolled 8 times
74  __asm__ volatile (
75  ".set push \n\t"
76  ".set noreorder \n\t"
77  "1: \n\t"
78  "lw %[temp0], 0(%[src]) \n\t"
79  "lw %[temp1], 4(%[src]) \n\t"
80  "lw %[temp2], 8(%[src]) \n\t"
81  "lw %[temp3], 12(%[src]) \n\t"
82  "lw %[temp4], 16(%[src]) \n\t"
83  "lw %[temp5], 20(%[src]) \n\t"
84  "lw %[temp6], 24(%[src]) \n\t"
85  "lw %[temp7], 28(%[src]) \n\t"
86  PTR_ADDIU "%[src], %[src], 32 \n\t"
87  "sw %[temp0], 0(%[dst]) \n\t"
88  "sw %[temp1], 4(%[dst]) \n\t"
89  "sw %[temp2], 8(%[dst]) \n\t"
90  "sw %[temp3], 12(%[dst]) \n\t"
91  "sw %[temp4], 16(%[dst]) \n\t"
92  "sw %[temp5], 20(%[dst]) \n\t"
93  "sw %[temp6], 24(%[dst]) \n\t"
94  "sw %[temp7], 28(%[dst]) \n\t"
95  "bne %[src], %[loop_end], 1b \n\t"
96  PTR_ADDIU "%[dst], %[dst], 32 \n\t"
97  ".set pop \n\t"
98 
99  : [temp0]"=&r"(temp[0]), [temp1]"=&r"(temp[1]),
100  [temp2]"=&r"(temp[2]), [temp3]"=&r"(temp[3]),
101  [temp4]"=&r"(temp[4]), [temp5]"=&r"(temp[5]),
102  [temp6]"=&r"(temp[6]), [temp7]"=&r"(temp[7]),
103  [src]"+r"(src), [dst]"+r"(dst)
104  : [loop_end]"r"(loop_end)
105  : "memory"
106  );
107 }
108 
109 static av_always_inline int lcg_random(unsigned previous_val)
110 {
111  union { unsigned u; int s; } v = { previous_val * 1664525u + 1013904223 };
112  return v.s;
113 }
114 
115 static void imdct_and_windowing_mips(AACContext *ac, SingleChannelElement *sce)
116 {
117  IndividualChannelStream *ics = &sce->ics;
118  float *in = sce->coeffs;
119  float *out = sce->ret;
120  float *saved = sce->saved;
121  const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
122  const float *lwindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_long_1024 : ff_sine_1024;
123  const float *swindow_prev = ics->use_kb_window[1] ? ff_aac_kbd_short_128 : ff_sine_128;
124  float *buf = ac->buf_mdct;
125  int i;
126 
127  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
128  for (i = 0; i < 1024; i += 128)
129  ac->mdct_small.imdct_half(&ac->mdct_small, buf + i, in + i);
130  } else
131  ac->mdct.imdct_half(&ac->mdct, buf, in);
132 
133  /* window overlapping
134  * NOTE: To simplify the overlapping code, all 'meaningless' short to long
135  * and long to short transitions are considered to be short to short
136  * transitions. This leaves just two cases (long to long and short to short)
137  * with a little special sauce for EIGHT_SHORT_SEQUENCE.
138  */
139  if ((ics->window_sequence[1] == ONLY_LONG_SEQUENCE || ics->window_sequence[1] == LONG_STOP_SEQUENCE) &&
140  (ics->window_sequence[0] == ONLY_LONG_SEQUENCE || ics->window_sequence[0] == LONG_START_SEQUENCE)) {
141  ac->fdsp->vector_fmul_window( out, saved, buf, lwindow_prev, 512);
142  } else {
143  float_copy(out, saved, 448);
144 
145  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
146  {
147  float wi;
148  float wj;
149  int i;
150  float temp0, temp1, temp2, temp3;
151  float *dst0 = out + 448 + 0*128;
152  float *dst1 = dst0 + 64 + 63;
153  float *dst2 = saved + 63;
154  float *win0 = (float*)swindow;
155  float *win1 = win0 + 64 + 63;
156  float *win0_prev = (float*)swindow_prev;
157  float *win1_prev = win0_prev + 64 + 63;
158  float *src0_prev = saved + 448;
159  float *src1_prev = buf + 0*128 + 63;
160  float *src0 = buf + 0*128 + 64;
161  float *src1 = buf + 1*128 + 63;
162 
163  for(i = 0; i < 64; i++)
164  {
165  temp0 = src0_prev[0];
166  temp1 = src1_prev[0];
167  wi = *win0_prev;
168  wj = *win1_prev;
169  temp2 = src0[0];
170  temp3 = src1[0];
171  dst0[0] = temp0 * wj - temp1 * wi;
172  dst1[0] = temp0 * wi + temp1 * wj;
173 
174  wi = *win0;
175  wj = *win1;
176 
177  temp0 = src0[128];
178  temp1 = src1[128];
179  dst0[128] = temp2 * wj - temp3 * wi;
180  dst1[128] = temp2 * wi + temp3 * wj;
181 
182  temp2 = src0[256];
183  temp3 = src1[256];
184  dst0[256] = temp0 * wj - temp1 * wi;
185  dst1[256] = temp0 * wi + temp1 * wj;
186  dst0[384] = temp2 * wj - temp3 * wi;
187  dst1[384] = temp2 * wi + temp3 * wj;
188 
189  temp0 = src0[384];
190  temp1 = src1[384];
191  dst0[512] = temp0 * wj - temp1 * wi;
192  dst2[0] = temp0 * wi + temp1 * wj;
193 
194  src0++;
195  src1--;
196  src0_prev++;
197  src1_prev--;
198  win0++;
199  win1--;
200  win0_prev++;
201  win1_prev--;
202  dst0++;
203  dst1--;
204  dst2--;
205  }
206  }
207  } else {
208  ac->fdsp->vector_fmul_window(out + 448, saved + 448, buf, swindow_prev, 64);
209  float_copy(out + 576, buf + 64, 448);
210  }
211  }
212 
213  // buffer update
214  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
215  ac->fdsp->vector_fmul_window(saved + 64, buf + 4*128 + 64, buf + 5*128, swindow, 64);
216  ac->fdsp->vector_fmul_window(saved + 192, buf + 5*128 + 64, buf + 6*128, swindow, 64);
217  ac->fdsp->vector_fmul_window(saved + 320, buf + 6*128 + 64, buf + 7*128, swindow, 64);
218  float_copy(saved + 448, buf + 7*128 + 64, 64);
219  } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
220  float_copy(saved, buf + 512, 448);
221  float_copy(saved + 448, buf + 7*128 + 64, 64);
222  } else { // LONG_STOP or ONLY_LONG
223  float_copy(saved, buf + 512, 512);
224  }
225 }
226 
227 static void apply_ltp_mips(AACContext *ac, SingleChannelElement *sce)
228 {
229  const LongTermPrediction *ltp = &sce->ics.ltp;
230  const uint16_t *offsets = sce->ics.swb_offset;
231  int i, sfb;
232  int j, k;
233 
234  if (sce->ics.window_sequence[0] != EIGHT_SHORT_SEQUENCE) {
235  float *predTime = sce->ret;
236  float *predFreq = ac->buf_mdct;
237  float *p_predTime;
238  int16_t num_samples = 2048;
239 
240  if (ltp->lag < 1024)
241  num_samples = ltp->lag + 1024;
242  j = (2048 - num_samples) >> 2;
243  k = (2048 - num_samples) & 3;
244  p_predTime = &predTime[num_samples];
245 
246  for (i = 0; i < num_samples; i++)
247  predTime[i] = sce->ltp_state[i + 2048 - ltp->lag] * ltp->coef;
248  for (i = 0; i < j; i++) {
249 
250  /* loop unrolled 4 times */
251  __asm__ volatile (
252  "sw $0, 0(%[p_predTime]) \n\t"
253  "sw $0, 4(%[p_predTime]) \n\t"
254  "sw $0, 8(%[p_predTime]) \n\t"
255  "sw $0, 12(%[p_predTime]) \n\t"
256  PTR_ADDIU "%[p_predTime], %[p_predTime], 16 \n\t"
257 
258  : [p_predTime]"+r"(p_predTime)
259  :
260  : "memory"
261  );
262  }
263  for (i = 0; i < k; i++) {
264 
265  __asm__ volatile (
266  "sw $0, 0(%[p_predTime]) \n\t"
267  PTR_ADDIU "%[p_predTime], %[p_predTime], 4 \n\t"
268 
269  : [p_predTime]"+r"(p_predTime)
270  :
271  : "memory"
272  );
273  }
274 
275  ac->windowing_and_mdct_ltp(ac, predFreq, predTime, &sce->ics);
276 
277  if (sce->tns.present)
278  ac->apply_tns(predFreq, &sce->tns, &sce->ics, 0);
279 
280  for (sfb = 0; sfb < FFMIN(sce->ics.max_sfb, MAX_LTP_LONG_SFB); sfb++)
281  if (ltp->used[sfb])
282  for (i = offsets[sfb]; i < offsets[sfb + 1]; i++)
283  sce->coeffs[i] += predFreq[i];
284  }
285 }
286 
287 static av_always_inline void fmul_and_reverse(float *dst, const float *src0, const float *src1, int count)
288 {
289  /* Multiply 'count' floats in src0 by src1 and store the results in dst in reverse */
290  /* This should be equivalent to a normal fmul, followed by reversing dst */
291 
292  // count must be a multiple of 4
293  av_assert2(count % 4 == 0);
294 
295  // move src0 and src1 to the last element of their arrays
296  src0 += count - 1;
297  src1 += count - 1;
298 
299  for (; count > 0; count -= 4){
300  float temp[12];
301 
302  /* loop unrolled 4 times */
303  __asm__ volatile (
304  "lwc1 %[temp0], 0(%[ptr2]) \n\t"
305  "lwc1 %[temp1], -4(%[ptr2]) \n\t"
306  "lwc1 %[temp2], -8(%[ptr2]) \n\t"
307  "lwc1 %[temp3], -12(%[ptr2]) \n\t"
308  "lwc1 %[temp4], 0(%[ptr3]) \n\t"
309  "lwc1 %[temp5], -4(%[ptr3]) \n\t"
310  "lwc1 %[temp6], -8(%[ptr3]) \n\t"
311  "lwc1 %[temp7], -12(%[ptr3]) \n\t"
312  "mul.s %[temp8], %[temp0], %[temp4] \n\t"
313  "mul.s %[temp9], %[temp1], %[temp5] \n\t"
314  "mul.s %[temp10], %[temp2], %[temp6] \n\t"
315  "mul.s %[temp11], %[temp3], %[temp7] \n\t"
316  "swc1 %[temp8], 0(%[ptr1]) \n\t"
317  "swc1 %[temp9], 4(%[ptr1]) \n\t"
318  "swc1 %[temp10], 8(%[ptr1]) \n\t"
319  "swc1 %[temp11], 12(%[ptr1]) \n\t"
320  PTR_ADDIU "%[ptr1], %[ptr1], 16 \n\t"
321  PTR_ADDIU "%[ptr2], %[ptr2], -16 \n\t"
322  PTR_ADDIU "%[ptr3], %[ptr3], -16 \n\t"
323 
324  : [temp0]"=&f"(temp[0]), [temp1]"=&f"(temp[1]),
325  [temp2]"=&f"(temp[2]), [temp3]"=&f"(temp[3]),
326  [temp4]"=&f"(temp[4]), [temp5]"=&f"(temp[5]),
327  [temp6]"=&f"(temp[6]), [temp7]"=&f"(temp[7]),
328  [temp8]"=&f"(temp[8]), [temp9]"=&f"(temp[9]),
329  [temp10]"=&f"(temp[10]), [temp11]"=&f"(temp[11]),
330  [ptr1]"+r"(dst), [ptr2]"+r"(src0), [ptr3]"+r"(src1)
331  :
332  : "memory"
333  );
334  }
335 }
336 
337 static void update_ltp_mips(AACContext *ac, SingleChannelElement *sce)
338 {
339  IndividualChannelStream *ics = &sce->ics;
340  float *saved = sce->saved;
341  float *saved_ltp = sce->coeffs;
342  const float *lwindow = ics->use_kb_window[0] ? ff_aac_kbd_long_1024 : ff_sine_1024;
343  const float *swindow = ics->use_kb_window[0] ? ff_aac_kbd_short_128 : ff_sine_128;
344  uint32_t temp0, temp1, temp2, temp3, temp4, temp5, temp6, temp7;
345 
346  if (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) {
347  float *p_saved_ltp = saved_ltp + 576;
348  float *loop_end1 = p_saved_ltp + 448;
349 
350  float_copy(saved_ltp, saved, 512);
351 
352  /* loop unrolled 8 times */
353  __asm__ volatile (
354  "1: \n\t"
355  "sw $0, 0(%[p_saved_ltp]) \n\t"
356  "sw $0, 4(%[p_saved_ltp]) \n\t"
357  "sw $0, 8(%[p_saved_ltp]) \n\t"
358  "sw $0, 12(%[p_saved_ltp]) \n\t"
359  "sw $0, 16(%[p_saved_ltp]) \n\t"
360  "sw $0, 20(%[p_saved_ltp]) \n\t"
361  "sw $0, 24(%[p_saved_ltp]) \n\t"
362  "sw $0, 28(%[p_saved_ltp]) \n\t"
363  PTR_ADDIU "%[p_saved_ltp],%[p_saved_ltp], 32 \n\t"
364  "bne %[p_saved_ltp], %[loop_end1], 1b \n\t"
365 
366  : [p_saved_ltp]"+r"(p_saved_ltp)
367  : [loop_end1]"r"(loop_end1)
368  : "memory"
369  );
370 
371  ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960, &swindow[64], 64);
372  fmul_and_reverse(saved_ltp + 512, ac->buf_mdct + 960, swindow, 64);
373  } else if (ics->window_sequence[0] == LONG_START_SEQUENCE) {
374  float *buff0 = saved;
375  float *buff1 = saved_ltp;
376  float *loop_end = saved + 448;
377 
378  /* loop unrolled 8 times */
379  __asm__ volatile (
380  ".set push \n\t"
381  ".set noreorder \n\t"
382  "1: \n\t"
383  "lw %[temp0], 0(%[src]) \n\t"
384  "lw %[temp1], 4(%[src]) \n\t"
385  "lw %[temp2], 8(%[src]) \n\t"
386  "lw %[temp3], 12(%[src]) \n\t"
387  "lw %[temp4], 16(%[src]) \n\t"
388  "lw %[temp5], 20(%[src]) \n\t"
389  "lw %[temp6], 24(%[src]) \n\t"
390  "lw %[temp7], 28(%[src]) \n\t"
391  PTR_ADDIU "%[src], %[src], 32 \n\t"
392  "sw %[temp0], 0(%[dst]) \n\t"
393  "sw %[temp1], 4(%[dst]) \n\t"
394  "sw %[temp2], 8(%[dst]) \n\t"
395  "sw %[temp3], 12(%[dst]) \n\t"
396  "sw %[temp4], 16(%[dst]) \n\t"
397  "sw %[temp5], 20(%[dst]) \n\t"
398  "sw %[temp6], 24(%[dst]) \n\t"
399  "sw %[temp7], 28(%[dst]) \n\t"
400  "sw $0, 2304(%[dst]) \n\t"
401  "sw $0, 2308(%[dst]) \n\t"
402  "sw $0, 2312(%[dst]) \n\t"
403  "sw $0, 2316(%[dst]) \n\t"
404  "sw $0, 2320(%[dst]) \n\t"
405  "sw $0, 2324(%[dst]) \n\t"
406  "sw $0, 2328(%[dst]) \n\t"
407  "sw $0, 2332(%[dst]) \n\t"
408  "bne %[src], %[loop_end], 1b \n\t"
409  PTR_ADDIU "%[dst], %[dst], 32 \n\t"
410  ".set pop \n\t"
411 
412  : [temp0]"=&r"(temp0), [temp1]"=&r"(temp1),
413  [temp2]"=&r"(temp2), [temp3]"=&r"(temp3),
414  [temp4]"=&r"(temp4), [temp5]"=&r"(temp5),
415  [temp6]"=&r"(temp6), [temp7]"=&r"(temp7),
416  [src]"+r"(buff0), [dst]"+r"(buff1)
417  : [loop_end]"r"(loop_end)
418  : "memory"
419  );
420  ac->fdsp->vector_fmul_reverse(saved_ltp + 448, ac->buf_mdct + 960, &swindow[64], 64);
421  fmul_and_reverse(saved_ltp + 512, ac->buf_mdct + 960, swindow, 64);
422  } else { // LONG_STOP or ONLY_LONG
423  ac->fdsp->vector_fmul_reverse(saved_ltp, ac->buf_mdct + 512, &lwindow[512], 512);
424  fmul_and_reverse(saved_ltp + 512, ac->buf_mdct + 512, lwindow, 512);
425  }
426 
427  float_copy(sce->ltp_state, sce->ltp_state + 1024, 1024);
428  float_copy(sce->ltp_state + 1024, sce->ret, 1024);
429  float_copy(sce->ltp_state + 2048, saved_ltp, 1024);
430 }
431 #endif /* HAVE_MIPSFPU */
432 #endif /* HAVE_INLINE_ASM */
433 
434 void ff_aacdec_init_mips(AACContext *c)
435 {
436 #if HAVE_INLINE_ASM
437 #if HAVE_MIPSFPU
438  c->imdct_and_windowing = imdct_and_windowing_mips;
439  c->apply_ltp = apply_ltp_mips;
440  c->update_ltp = update_ltp_mips;
441 #endif /* HAVE_MIPSFPU */
442 #endif /* HAVE_INLINE_ASM */
443 }
lcg_random
static av_always_inline int lcg_random(unsigned previous_val)
linear congruential pseudorandom number generator
Definition: aacdec_template.c:1184
ff_aac_kbd_short_128
float ff_aac_kbd_short_128[128]
out
FILE * out
Definition: movenc.c:54
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:262
src1
const pixel * src1
Definition: h264pred_template.c:421
AVFloatDSPContext::vector_fmul_reverse
void(* vector_fmul_reverse)(float *dst, const float *src0, const float *src1, int len)
Calculate the entry wise product of two vectors of floats, and store the result in a vector of floats...
Definition: float_dsp.h:154
TemporalNoiseShaping::present
int present
Definition: aac.h:200
LongTermPrediction::used
int8_t used[MAX_LTP_LONG_SFB]
Definition: aac.h:169
asmdefs.h
SingleChannelElement::ret
INTFLOAT * ret
PCM output.
Definition: aac.h:270
SingleChannelElement::saved
INTFLOAT saved[1536]
overlap
Definition: aac.h:264
LongTermPrediction::coef
INTFLOAT coef
Definition: aac.h:168
MAX_LTP_LONG_SFB
#define MAX_LTP_LONG_SFB
Definition: aac.h:53
ff_aacdec_init_mips
void ff_aacdec_init_mips(AACContext *c)
Definition: aacdec_mips.c:434
SingleChannelElement::ics
IndividualChannelStream ics
Definition: aac.h:250
AACContext::mdct
FFTContext mdct
Definition: aac.h:329
s
#define s(width, name)
Definition: cbs_vp9.c:256
SingleChannelElement::coeffs
INTFLOAT coeffs[1024]
coefficients for IMDCT, maybe processed
Definition: aac.h:263
offsets
static const int offsets[]
Definition: hevc_pel.c:34
EIGHT_SHORT_SEQUENCE
@ EIGHT_SHORT_SEQUENCE
Definition: aac.h:80
AACContext::fdsp
AVFloatDSPContext * fdsp
Definition: aac.h:339
IndividualChannelStream
Individual Channel Stream.
Definition: aac.h:175
IndividualChannelStream::swb_offset
const uint16_t * swb_offset
table of offsets to the lowest spectral coefficient of a scalefactor band, sfb, for a particular wind...
Definition: aac.h:182
aacdec_mips.h
aac.h
aactab.h
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
FFTContext::imdct_half
void(* imdct_half)(struct FFTContext *s, FFTSample *output, const FFTSample *input)
Definition: fft.h:95
AACContext::apply_tns
void(* apply_tns)(INTFLOAT coef[1024], TemporalNoiseShaping *tns, IndividualChannelStream *ics, int decode)
Definition: aac.h:373
ONLY_LONG_SEQUENCE
@ ONLY_LONG_SEQUENCE
Definition: aac.h:78
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
sinewin.h
attributes.h
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
SingleChannelElement
Single Channel Element - used for both SCE and LFE elements.
Definition: aac.h:249
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
LONG_STOP_SEQUENCE
@ LONG_STOP_SEQUENCE
Definition: aac.h:81
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
LongTermPrediction::lag
int16_t lag
Definition: aac.h:166
ff_aac_kbd_long_1024
float ff_aac_kbd_long_1024[1024]
__asm__
__asm__(".macro parse_r var r\n\t" "\\var = -1\n\t" _IFC_REG(0) _IFC_REG(1) _IFC_REG(2) _IFC_REG(3) _IFC_REG(4) _IFC_REG(5) _IFC_REG(6) _IFC_REG(7) _IFC_REG(8) _IFC_REG(9) _IFC_REG(10) _IFC_REG(11) _IFC_REG(12) _IFC_REG(13) _IFC_REG(14) _IFC_REG(15) _IFC_REG(16) _IFC_REG(17) _IFC_REG(18) _IFC_REG(19) _IFC_REG(20) _IFC_REG(21) _IFC_REG(22) _IFC_REG(23) _IFC_REG(24) _IFC_REG(25) _IFC_REG(26) _IFC_REG(27) _IFC_REG(28) _IFC_REG(29) _IFC_REG(30) _IFC_REG(31) ".iflt \\var\n\t" ".error \"Unable to parse register name \\r\"\n\t" ".endif\n\t" ".endm")
LONG_START_SEQUENCE
@ LONG_START_SEQUENCE
Definition: aac.h:79
SingleChannelElement::tns
TemporalNoiseShaping tns
Definition: aac.h:251
LongTermPrediction
Long Term Prediction.
Definition: aac.h:164
IndividualChannelStream::window_sequence
enum WindowSequence window_sequence[2]
Definition: aac.h:177
temp
else temp
Definition: vf_mcdeint.c:248
PTR_ADDIU
#define PTR_ADDIU
Definition: asmdefs.h:50
AACContext::buf_mdct
INTFLOAT buf_mdct[1024]
Definition: aac.h:322
src0
const pixel *const src0
Definition: h264pred_template.c:420
AACContext::windowing_and_mdct_ltp
void(* windowing_and_mdct_ltp)(AACContext *ac, INTFLOAT *out, INTFLOAT *in, IndividualChannelStream *ics)
Definition: aac.h:375
AVFloatDSPContext::vector_fmul_window
void(* vector_fmul_window)(float *dst, const float *src0, const float *src1, const float *win, int len)
Overlap/add with window function.
Definition: float_dsp.h:119
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AACContext::mdct_small
FFTContext mdct_small
Definition: aac.h:330
AACContext
main AAC context
Definition: aac.h:299
IndividualChannelStream::max_sfb
uint8_t max_sfb
number of scalefactor bands per group
Definition: aac.h:176
SingleChannelElement::ltp_state
INTFLOAT ltp_state[3072]
time signal for LTP
Definition: aac.h:266
IndividualChannelStream::ltp
LongTermPrediction ltp
Definition: aac.h:181
IndividualChannelStream::use_kb_window
uint8_t use_kb_window[2]
If set, use Kaiser-Bessel window, otherwise use a sine window.
Definition: aac.h:178
Generated on Wed Jul 6 2022 19:21:26 for FFmpeg by   doxygen 1.8.17