GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/mlpdsp.c Lines: 56 56 100.0 %
Date: 2019-11-18 18:00:01 Branches: 18 18 100.0 %

Line Branch Exec Source
1
/*
2
 * Copyright (c) 2007-2008 Ian Caulfield
3
 *               2009 Ramiro Polla
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
#include "config.h"
23
#include "libavutil/attributes.h"
24
#include "mlpdsp.h"
25
#include "mlp.h"
26
27
49156
static void mlp_filter_channel(int32_t *state, const int32_t *coeff,
28
                               int firorder, int iirorder,
29
                               unsigned int filter_shift, int32_t mask,
30
                               int blocksize, int32_t *sample_buffer)
31
{
32
49156
    int32_t *firbuf = state;
33
49156
    int32_t *iirbuf = state + MAX_BLOCKSIZE + MAX_FIR_ORDER;
34
49156
    const int32_t *fircoeff = coeff;
35
49156
    const int32_t *iircoeff = coeff + MAX_FIR_ORDER;
36
    int i;
37
38
1857716
    for (i = 0; i < blocksize; i++) {
39
1808560
        int32_t residual = *sample_buffer;
40
        unsigned int order;
41
1808560
        int64_t accum = 0;
42
        int32_t result;
43
44
9593392
        for (order = 0; order < firorder; order++)
45
7784832
            accum += (int64_t) firbuf[order] * fircoeff[order];
46
2103952
        for (order = 0; order < iirorder; order++)
47
295392
            accum += (int64_t) iirbuf[order] * iircoeff[order];
48
49
1808560
        accum  = accum >> filter_shift;
50
1808560
        result = (accum + residual) & mask;
51
52
1808560
        *--firbuf = result;
53
1808560
        *--iirbuf = result - accum;
54
55
1808560
        *sample_buffer = result;
56
1808560
        sample_buffer += MAX_CHANNELS;
57
    }
58
49156
}
59
60
23757
void ff_mlp_rematrix_channel(int32_t *samples,
61
                             const int32_t *coeffs,
62
                             const uint8_t *bypassed_lsbs,
63
                             const int8_t *noise_buffer,
64
                             int index,
65
                             unsigned int dest_ch,
66
                             uint16_t blockpos,
67
                             unsigned int maxchan,
68
                             int matrix_noise_shift,
69
                             int access_unit_size_pow2,
70
                             int32_t mask)
71
{
72
    unsigned int src_ch, i;
73
23757
    int index2 = 2 * index + 1;
74
974037
    for (i = 0; i < blockpos; i++) {
75
950280
        int64_t accum = 0;
76
77
5571080
        for (src_ch = 0; src_ch <= maxchan; src_ch++)
78
4620800
            accum += (int64_t) samples[src_ch] * coeffs[src_ch];
79
80
950280
        if (matrix_noise_shift) {
81
272800
            index &= access_unit_size_pow2 - 1;
82
272800
            accum += noise_buffer[index] << (matrix_noise_shift + 7);
83
272800
            index += index2;
84
        }
85
86
950280
        samples[dest_ch] = ((accum >> 14) & mask) + *bypassed_lsbs;
87
950280
        bypassed_lsbs += MAX_CHANNELS;
88
950280
        samples += MAX_CHANNELS;
89
    }
90
23757
}
91
92
4238
static int32_t (*mlp_select_pack_output(uint8_t *ch_assign,
93
                                        int8_t *output_shift,
94
                                        uint8_t max_matrix_channel,
95
                                        int is32))(int32_t, uint16_t, int32_t (*)[], void *, uint8_t*, int8_t *, uint8_t, int)
96
{
97
4238
    return ff_mlp_pack_output;
98
}
99
100
15787
int32_t ff_mlp_pack_output(int32_t lossless_check_data,
101
                           uint16_t blockpos,
102
                           int32_t (*sample_buffer)[MAX_CHANNELS],
103
                           void *data,
104
                           uint8_t *ch_assign,
105
                           int8_t *output_shift,
106
                           uint8_t max_matrix_channel,
107
                           int is32)
108
{
109
15787
    unsigned int i, out_ch = 0;
110
15787
    int32_t *data_32 = data;
111
15787
    int16_t *data_16 = data;
112
113
647267
    for (i = 0; i < blockpos; i++) {
114
2440040
        for (out_ch = 0; out_ch <= max_matrix_channel; out_ch++) {
115
1808560
            int mat_ch = ch_assign[out_ch];
116
1808560
            int32_t sample = sample_buffer[i][mat_ch] *
117
1808560
                          (1U << output_shift[mat_ch]);
118
1808560
            lossless_check_data ^= (sample & 0xffffff) << mat_ch;
119
1808560
            if (is32)
120
1091200
                *data_32++ = sample * 256U;
121
            else
122
717360
                *data_16++ = sample >> 8;
123
        }
124
    }
125
15787
    return lossless_check_data;
126
}
127
128
6
av_cold void ff_mlpdsp_init(MLPDSPContext *c)
129
{
130
6
    c->mlp_filter_channel = mlp_filter_channel;
131
6
    c->mlp_rematrix_channel = ff_mlp_rematrix_channel;
132
6
    c->mlp_select_pack_output = mlp_select_pack_output;
133
6
    c->mlp_pack_output = ff_mlp_pack_output;
134
    if (ARCH_ARM)
135
        ff_mlpdsp_init_arm(c);
136
    if (ARCH_X86)
137
6
        ff_mlpdsp_init_x86(c);
138
6
}