Statistics
| Branch: | Revision:

ffmpeg / libavcodec / ac3dsp.c @ 63b1866a

History | View | Annotate | Download (5.55 KB)

1
/*
2
 * AC-3 DSP utils
3
 * Copyright (c) 2011 Justin Ruggles
4
 *
5
 * This file is part of Libav.
6
 *
7
 * Libav 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
 * Libav 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 Libav; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
#include "libavutil/avassert.h"
23
#include "avcodec.h"
24
#include "ac3.h"
25
#include "ac3dsp.h"
26

    
27
static void ac3_exponent_min_c(uint8_t *exp, int num_reuse_blocks, int nb_coefs)
28
{
29
    int blk, i;
30

    
31
    if (!num_reuse_blocks)
32
        return;
33

    
34
    for (i = 0; i < nb_coefs; i++) {
35
        uint8_t min_exp = *exp;
36
        uint8_t *exp1 = exp + 256;
37
        for (blk = 0; blk < num_reuse_blocks; blk++) {
38
            uint8_t next_exp = *exp1;
39
            if (next_exp < min_exp)
40
                min_exp = next_exp;
41
            exp1 += 256;
42
        }
43
        *exp++ = min_exp;
44
    }
45
}
46

    
47
static int ac3_max_msb_abs_int16_c(const int16_t *src, int len)
48
{
49
    int i, v = 0;
50
    for (i = 0; i < len; i++)
51
        v |= abs(src[i]);
52
    return v;
53
}
54

    
55
static void ac3_lshift_int16_c(int16_t *src, unsigned int len,
56
                               unsigned int shift)
57
{
58
    uint32_t *src32 = (uint32_t *)src;
59
    const uint32_t mask = ~(((1 << shift) - 1) << 16);
60
    int i;
61
    len >>= 1;
62
    for (i = 0; i < len; i += 8) {
63
        src32[i  ] = (src32[i  ] << shift) & mask;
64
        src32[i+1] = (src32[i+1] << shift) & mask;
65
        src32[i+2] = (src32[i+2] << shift) & mask;
66
        src32[i+3] = (src32[i+3] << shift) & mask;
67
        src32[i+4] = (src32[i+4] << shift) & mask;
68
        src32[i+5] = (src32[i+5] << shift) & mask;
69
        src32[i+6] = (src32[i+6] << shift) & mask;
70
        src32[i+7] = (src32[i+7] << shift) & mask;
71
    }
72
}
73

    
74
static void ac3_rshift_int32_c(int32_t *src, unsigned int len,
75
                               unsigned int shift)
76
{
77
    do {
78
        *src++ >>= shift;
79
        *src++ >>= shift;
80
        *src++ >>= shift;
81
        *src++ >>= shift;
82
        *src++ >>= shift;
83
        *src++ >>= shift;
84
        *src++ >>= shift;
85
        *src++ >>= shift;
86
        len -= 8;
87
    } while (len > 0);
88
}
89

    
90
static void float_to_fixed24_c(int32_t *dst, const float *src, unsigned int len)
91
{
92
    const float scale = 1 << 24;
93
    do {
94
        *dst++ = lrintf(*src++ * scale);
95
        *dst++ = lrintf(*src++ * scale);
96
        *dst++ = lrintf(*src++ * scale);
97
        *dst++ = lrintf(*src++ * scale);
98
        *dst++ = lrintf(*src++ * scale);
99
        *dst++ = lrintf(*src++ * scale);
100
        *dst++ = lrintf(*src++ * scale);
101
        *dst++ = lrintf(*src++ * scale);
102
        len -= 8;
103
    } while (len > 0);
104
}
105

    
106
static void ac3_bit_alloc_calc_bap_c(int16_t *mask, int16_t *psd,
107
                                     int start, int end,
108
                                     int snr_offset, int floor,
109
                                     const uint8_t *bap_tab, uint8_t *bap)
110
{
111
    int bin, band;
112

    
113
    /* special case, if snr offset is -960, set all bap's to zero */
114
    if (snr_offset == -960) {
115
        memset(bap, 0, AC3_MAX_COEFS);
116
        return;
117
    }
118

    
119
    bin  = start;
120
    band = ff_ac3_bin_to_band_tab[start];
121
    do {
122
        int m = (FFMAX(mask[band] - snr_offset - floor, 0) & 0x1FE0) + floor;
123
        int band_end = FFMIN(ff_ac3_band_start_tab[band+1], end);
124
        for (; bin < band_end; bin++) {
125
            int address = av_clip((psd[bin] - m) >> 5, 0, 63);
126
            bap[bin] = bap_tab[address];
127
        }
128
    } while (end > ff_ac3_band_start_tab[band++]);
129
}
130

    
131
static int ac3_compute_mantissa_size_c(int mant_cnt[5], uint8_t *bap,
132
                                       int nb_coefs)
133
{
134
    int bits, b, i;
135

    
136
    bits = 0;
137
    for (i = 0; i < nb_coefs; i++) {
138
        b = bap[i];
139
        if (b <= 4) {
140
            // bap=1 to bap=4 will be counted in compute_mantissa_size_final
141
            mant_cnt[b]++;
142
        } else if (b <= 13) {
143
            // bap=5 to bap=13 use (bap-1) bits
144
            bits += b - 1;
145
        } else {
146
            // bap=14 uses 14 bits and bap=15 uses 16 bits
147
            bits += (b == 14) ? 14 : 16;
148
        }
149
    }
150
    return bits;
151
}
152

    
153
static void ac3_extract_exponents_c(uint8_t *exp, int32_t *coef, int nb_coefs)
154
{
155
    int i;
156

    
157
    for (i = 0; i < nb_coefs; i++) {
158
        int e;
159
        int v = abs(coef[i]);
160
        if (v == 0)
161
            e = 24;
162
        else {
163
            e = 23 - av_log2(v);
164
            if (e >= 24) {
165
                e = 24;
166
                coef[i] = 0;
167
            } else if (e < 0) {
168
                e = 0;
169
                coef[i] = av_clip(coef[i], -16777215, 16777215);
170
            }
171
        }
172
        exp[i] = e;
173
    }
174
}
175

    
176
av_cold void ff_ac3dsp_init(AC3DSPContext *c, int bit_exact)
177
{
178
    c->ac3_exponent_min = ac3_exponent_min_c;
179
    c->ac3_max_msb_abs_int16 = ac3_max_msb_abs_int16_c;
180
    c->ac3_lshift_int16 = ac3_lshift_int16_c;
181
    c->ac3_rshift_int32 = ac3_rshift_int32_c;
182
    c->float_to_fixed24 = float_to_fixed24_c;
183
    c->bit_alloc_calc_bap = ac3_bit_alloc_calc_bap_c;
184
    c->compute_mantissa_size = ac3_compute_mantissa_size_c;
185
    c->extract_exponents = ac3_extract_exponents_c;
186

    
187
    if (ARCH_ARM)
188
        ff_ac3dsp_init_arm(c, bit_exact);
189
    if (HAVE_MMX)
190
        ff_ac3dsp_init_x86(c, bit_exact);
191
}