Mercurial > libavcodec.hg
annotate alsdec.c @ 11352:6e0af2cfdcfe libavcodec
Do MC and IDCT in coding (hilbert) order
This increases the slice size to 64 pixels, due to having to decode an
entire chroma superblock row per slice.
This can be up to 6% slower depending on clip and CPU, but is necessary
for future optimizations that gain significantly more than was lost.
author | conrad |
---|---|
date | Wed, 03 Mar 2010 23:27:40 +0000 |
parents | 8173c059f769 |
children | e6e95656937d |
rev | line source |
---|---|
10522 | 1 /* |
2 * MPEG-4 ALS decoder | |
3 * Copyright (c) 2009 Thilo Borgmann <thilo.borgmann _at_ googlemail.com> | |
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 * @file libavcodec/alsdec.c | |
24 * MPEG-4 ALS decoder | |
25 * @author Thilo Borgmann <thilo.borgmann _at_ googlemail.com> | |
26 */ | |
27 | |
28 | |
29 //#define DEBUG | |
30 | |
31 | |
32 #include "avcodec.h" | |
33 #include "get_bits.h" | |
34 #include "unary.h" | |
35 #include "mpeg4audio.h" | |
36 #include "bytestream.h" | |
11148 | 37 #include "bgmc.h" |
10522 | 38 |
10531
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
39 #include <stdint.h> |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
40 |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
41 /** Rice parameters and corresponding index offsets for decoding the |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
42 * indices of scaled PARCOR values. The table choosen is set globally |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
43 * by the encoder and stored in ALSSpecificConfig. |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
44 */ |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
45 static const int8_t parcor_rice_table[3][20][2] = { |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
46 { {-52, 4}, {-29, 5}, {-31, 4}, { 19, 4}, {-16, 4}, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
47 { 12, 3}, { -7, 3}, { 9, 3}, { -5, 3}, { 6, 3}, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
48 { -4, 3}, { 3, 3}, { -3, 2}, { 3, 2}, { -2, 2}, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
49 { 3, 2}, { -1, 2}, { 2, 2}, { -1, 2}, { 2, 2} }, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
50 { {-58, 3}, {-42, 4}, {-46, 4}, { 37, 5}, {-36, 4}, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
51 { 29, 4}, {-29, 4}, { 25, 4}, {-23, 4}, { 20, 4}, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
52 {-17, 4}, { 16, 4}, {-12, 4}, { 12, 3}, {-10, 4}, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
53 { 7, 3}, { -4, 4}, { 3, 3}, { -1, 3}, { 1, 3} }, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
54 { {-59, 3}, {-45, 5}, {-50, 4}, { 38, 4}, {-39, 4}, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
55 { 32, 4}, {-30, 4}, { 25, 3}, {-23, 3}, { 20, 3}, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
56 {-20, 3}, { 16, 3}, {-13, 3}, { 10, 3}, { -7, 3}, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
57 { 3, 3}, { 0, 3}, { -1, 3}, { 2, 3}, { -1, 2} } |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
58 }; |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
59 |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
60 |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
61 /** Scaled PARCOR values used for the first two PARCOR coefficients. |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
62 * To be indexed by the Rice coded indices. |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
63 * Generated by: parcor_scaled_values[i] = 32 + ((i * (i+1)) << 7) - (1 << 20) |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
64 * Actual values are divided by 32 in order to be stored in 16 bits. |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
65 */ |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
66 static const int16_t parcor_scaled_values[] = { |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
67 -1048544 / 32, -1048288 / 32, -1047776 / 32, -1047008 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
68 -1045984 / 32, -1044704 / 32, -1043168 / 32, -1041376 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
69 -1039328 / 32, -1037024 / 32, -1034464 / 32, -1031648 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
70 -1028576 / 32, -1025248 / 32, -1021664 / 32, -1017824 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
71 -1013728 / 32, -1009376 / 32, -1004768 / 32, -999904 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
72 -994784 / 32, -989408 / 32, -983776 / 32, -977888 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
73 -971744 / 32, -965344 / 32, -958688 / 32, -951776 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
74 -944608 / 32, -937184 / 32, -929504 / 32, -921568 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
75 -913376 / 32, -904928 / 32, -896224 / 32, -887264 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
76 -878048 / 32, -868576 / 32, -858848 / 32, -848864 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
77 -838624 / 32, -828128 / 32, -817376 / 32, -806368 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
78 -795104 / 32, -783584 / 32, -771808 / 32, -759776 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
79 -747488 / 32, -734944 / 32, -722144 / 32, -709088 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
80 -695776 / 32, -682208 / 32, -668384 / 32, -654304 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
81 -639968 / 32, -625376 / 32, -610528 / 32, -595424 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
82 -580064 / 32, -564448 / 32, -548576 / 32, -532448 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
83 -516064 / 32, -499424 / 32, -482528 / 32, -465376 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
84 -447968 / 32, -430304 / 32, -412384 / 32, -394208 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
85 -375776 / 32, -357088 / 32, -338144 / 32, -318944 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
86 -299488 / 32, -279776 / 32, -259808 / 32, -239584 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
87 -219104 / 32, -198368 / 32, -177376 / 32, -156128 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
88 -134624 / 32, -112864 / 32, -90848 / 32, -68576 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
89 -46048 / 32, -23264 / 32, -224 / 32, 23072 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
90 46624 / 32, 70432 / 32, 94496 / 32, 118816 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
91 143392 / 32, 168224 / 32, 193312 / 32, 218656 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
92 244256 / 32, 270112 / 32, 296224 / 32, 322592 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
93 349216 / 32, 376096 / 32, 403232 / 32, 430624 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
94 458272 / 32, 486176 / 32, 514336 / 32, 542752 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
95 571424 / 32, 600352 / 32, 629536 / 32, 658976 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
96 688672 / 32, 718624 / 32, 748832 / 32, 779296 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
97 810016 / 32, 840992 / 32, 872224 / 32, 903712 / 32, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
98 935456 / 32, 967456 / 32, 999712 / 32, 1032224 / 32 |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
99 }; |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
100 |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
101 |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
102 /** Gain values of p(0) for long-term prediction. |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
103 * To be indexed by the Rice coded indices. |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
104 */ |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
105 static const uint8_t ltp_gain_values [4][4] = { |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
106 { 0, 8, 16, 24}, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
107 {32, 40, 48, 56}, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
108 {64, 70, 76, 82}, |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
109 {88, 92, 96, 100} |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
110 }; |
142645a57180
Merge data tables from als_data.h with the decoder source to reduce
thilo.borgmann
parents:
10530
diff
changeset
|
111 |
10522 | 112 |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
113 /** Inter-channel weighting factors for multi-channel correlation. |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
114 * To be indexed by the Rice coded indices. |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
115 */ |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
116 static const int16_t mcc_weightings[] = { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
117 204, 192, 179, 166, 153, 140, 128, 115, |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
118 102, 89, 76, 64, 51, 38, 25, 12, |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
119 0, -12, -25, -38, -51, -64, -76, -89, |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
120 -102, -115, -128, -140, -153, -166, -179, -192 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
121 }; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
122 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
123 |
11148 | 124 /** Tail codes used in arithmetic coding using block Gilbert-Moore codes. |
125 */ | |
126 static const uint8_t tail_code[16][6] = { | |
127 { 74, 44, 25, 13, 7, 3}, | |
128 { 68, 42, 24, 13, 7, 3}, | |
129 { 58, 39, 23, 13, 7, 3}, | |
130 {126, 70, 37, 19, 10, 5}, | |
131 {132, 70, 37, 20, 10, 5}, | |
132 {124, 70, 38, 20, 10, 5}, | |
133 {120, 69, 37, 20, 11, 5}, | |
134 {116, 67, 37, 20, 11, 5}, | |
135 {108, 66, 36, 20, 10, 5}, | |
136 {102, 62, 36, 20, 10, 5}, | |
137 { 88, 58, 34, 19, 10, 5}, | |
138 {162, 89, 49, 25, 13, 7}, | |
139 {156, 87, 49, 26, 14, 7}, | |
140 {150, 86, 47, 26, 14, 7}, | |
141 {142, 84, 47, 26, 14, 7}, | |
142 {131, 79, 46, 26, 14, 7} | |
143 }; | |
144 | |
145 | |
10522 | 146 enum RA_Flag { |
147 RA_FLAG_NONE, | |
148 RA_FLAG_FRAMES, | |
149 RA_FLAG_HEADER | |
150 }; | |
151 | |
152 | |
153 typedef struct { | |
154 uint32_t samples; ///< number of samples, 0xFFFFFFFF if unknown | |
155 int resolution; ///< 000 = 8-bit; 001 = 16-bit; 010 = 24-bit; 011 = 32-bit | |
156 int floating; ///< 1 = IEEE 32-bit floating-point, 0 = integer | |
157 int frame_length; ///< frame length for each frame (last frame may differ) | |
158 int ra_distance; ///< distance between RA frames (in frames, 0...255) | |
159 enum RA_Flag ra_flag; ///< indicates where the size of ra units is stored | |
160 int adapt_order; ///< adaptive order: 1 = on, 0 = off | |
161 int coef_table; ///< table index of Rice code parameters | |
162 int long_term_prediction; ///< long term prediction (LTP): 1 = on, 0 = off | |
163 int max_order; ///< maximum prediction order (0..1023) | |
164 int block_switching; ///< number of block switching levels | |
165 int bgmc; ///< "Block Gilbert-Moore Code": 1 = on, 0 = off (Rice coding only) | |
166 int sb_part; ///< sub-block partition | |
167 int joint_stereo; ///< joint stereo: 1 = on, 0 = off | |
168 int mc_coding; ///< extended inter-channel coding (multi channel coding): 1 = on, 0 = off | |
169 int chan_config; ///< indicates that a chan_config_info field is present | |
170 int chan_sort; ///< channel rearrangement: 1 = on, 0 = off | |
171 int rlslms; ///< use "Recursive Least Square-Least Mean Square" predictor: 1 = on, 0 = off | |
172 int chan_config_info; ///< mapping of channels to loudspeaker locations. Unused until setting channel configuration is implemented. | |
173 int *chan_pos; ///< original channel positions | |
174 } ALSSpecificConfig; | |
175 | |
176 | |
177 typedef struct { | |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
178 int stop_flag; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
179 int master_channel; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
180 int time_diff_flag; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
181 int time_diff_sign; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
182 int time_diff_index; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
183 int weighting[6]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
184 } ALSChannelData; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
185 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
186 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
187 typedef struct { |
10522 | 188 AVCodecContext *avctx; |
189 ALSSpecificConfig sconf; | |
190 GetBitContext gb; | |
191 unsigned int cur_frame_length; ///< length of the current frame to decode | |
192 unsigned int frame_id; ///< the frame ID / number of the current frame | |
193 unsigned int js_switch; ///< if true, joint-stereo decoding is enforced | |
194 unsigned int num_blocks; ///< number of blocks used in the current frame | |
11189
638415aafbda
Limit the Rice parameter used for progressive decoding in ALS.
thilo.borgmann
parents:
11157
diff
changeset
|
195 unsigned int s_max; ///< maximum Rice parameter allowed in entropy coding |
11148 | 196 uint8_t *bgmc_lut; ///< pointer at lookup tables used for BGMC |
197 unsigned int *bgmc_lut_status; ///< pointer at lookup table status flags used for BGMC | |
10530
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
198 int ltp_lag_length; ///< number of bits used for ltp lag value |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
199 int *use_ltp; ///< contains use_ltp flags for all channels |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
200 int *ltp_lag; ///< contains ltp lag values for all channels |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
201 int **ltp_gain; ///< gain values for ltp 5-tap filter for a channel |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
202 int *ltp_gain_buffer; ///< contains all gain values for ltp 5-tap filter |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
203 int32_t **quant_cof; ///< quantized parcor coefficients for a channel |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
204 int32_t *quant_cof_buffer; ///< contains all quantized parcor coefficients |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
205 int32_t **lpc_cof; ///< coefficients of the direct form prediction filter for a channel |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
206 int32_t *lpc_cof_buffer; ///< contains all coefficients of the direct form prediction filter |
10860
c9fb5b89e47a
Replace variable length array with an allocated buffer
thilo.borgmann
parents:
10823
diff
changeset
|
207 int32_t *lpc_cof_reversed_buffer; ///< temporary buffer to set up a reversed versio of lpc_cof_buffer |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
208 ALSChannelData **chan_data; ///< channel data for multi-channel correlation |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
209 ALSChannelData *chan_data_buffer; ///< contains channel data for all channels |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
210 int *reverted_channels; ///< stores a flag for each reverted channel |
10522 | 211 int32_t *prev_raw_samples; ///< contains unshifted raw samples from the previous block |
212 int32_t **raw_samples; ///< decoded raw samples for each channel | |
213 int32_t *raw_buffer; ///< contains all decoded raw samples including carryover samples | |
214 } ALSDecContext; | |
215 | |
216 | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
217 typedef struct { |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
218 unsigned int block_length; ///< number of samples within the block |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
219 unsigned int ra_block; ///< if true, this is a random access block |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
220 int const_block; ///< if true, this is a constant value block |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
221 int32_t const_val; ///< the sample value of a constant block |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
222 int js_blocks; ///< true if this block contains a difference signal |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
223 unsigned int shift_lsbs; ///< shift of values for this block |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
224 unsigned int opt_order; ///< prediction order of this block |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
225 int store_prev_samples;///< if true, carryover samples have to be stored |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
226 int *use_ltp; ///< if true, long-term prediction is used |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
227 int *ltp_lag; ///< lag value for long-term prediction |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
228 int *ltp_gain; ///< gain values for ltp 5-tap filter |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
229 int32_t *quant_cof; ///< quantized parcor coefficients |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
230 int32_t *lpc_cof; ///< coefficients of the direct form prediction |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
231 int32_t *raw_samples; ///< decoded raw samples / residuals for this block |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
232 int32_t *prev_raw_samples; ///< contains unshifted raw samples from the previous block |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
233 int32_t *raw_other; ///< decoded raw samples of the other channel of a channel pair |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
234 } ALSBlockData; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
235 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
236 |
10522 | 237 static av_cold void dprint_specific_config(ALSDecContext *ctx) |
238 { | |
239 #ifdef DEBUG | |
240 AVCodecContext *avctx = ctx->avctx; | |
241 ALSSpecificConfig *sconf = &ctx->sconf; | |
242 | |
243 dprintf(avctx, "resolution = %i\n", sconf->resolution); | |
244 dprintf(avctx, "floating = %i\n", sconf->floating); | |
245 dprintf(avctx, "frame_length = %i\n", sconf->frame_length); | |
246 dprintf(avctx, "ra_distance = %i\n", sconf->ra_distance); | |
247 dprintf(avctx, "ra_flag = %i\n", sconf->ra_flag); | |
248 dprintf(avctx, "adapt_order = %i\n", sconf->adapt_order); | |
249 dprintf(avctx, "coef_table = %i\n", sconf->coef_table); | |
250 dprintf(avctx, "long_term_prediction = %i\n", sconf->long_term_prediction); | |
251 dprintf(avctx, "max_order = %i\n", sconf->max_order); | |
252 dprintf(avctx, "block_switching = %i\n", sconf->block_switching); | |
253 dprintf(avctx, "bgmc = %i\n", sconf->bgmc); | |
254 dprintf(avctx, "sb_part = %i\n", sconf->sb_part); | |
255 dprintf(avctx, "joint_stereo = %i\n", sconf->joint_stereo); | |
256 dprintf(avctx, "mc_coding = %i\n", sconf->mc_coding); | |
257 dprintf(avctx, "chan_config = %i\n", sconf->chan_config); | |
258 dprintf(avctx, "chan_sort = %i\n", sconf->chan_sort); | |
259 dprintf(avctx, "RLSLMS = %i\n", sconf->rlslms); | |
260 dprintf(avctx, "chan_config_info = %i\n", sconf->chan_config_info); | |
261 #endif | |
262 } | |
263 | |
264 | |
265 /** Reads an ALSSpecificConfig from a buffer into the output struct. | |
266 */ | |
267 static av_cold int read_specific_config(ALSDecContext *ctx) | |
268 { | |
269 GetBitContext gb; | |
270 uint64_t ht_size; | |
271 int i, config_offset, crc_enabled; | |
272 MPEG4AudioConfig m4ac; | |
273 ALSSpecificConfig *sconf = &ctx->sconf; | |
274 AVCodecContext *avctx = ctx->avctx; | |
11071
327019a2d156
Remove unnecessary fields in ALSSpecificConfig.
thilo.borgmann
parents:
10861
diff
changeset
|
275 uint32_t als_id, header_size, trailer_size; |
10522 | 276 |
277 init_get_bits(&gb, avctx->extradata, avctx->extradata_size * 8); | |
278 | |
279 config_offset = ff_mpeg4audio_get_config(&m4ac, avctx->extradata, | |
280 avctx->extradata_size); | |
281 | |
282 if (config_offset < 0) | |
283 return -1; | |
284 | |
285 skip_bits_long(&gb, config_offset); | |
286 | |
287 if (get_bits_left(&gb) < (30 << 3)) | |
288 return -1; | |
289 | |
290 // read the fixed items | |
291 als_id = get_bits_long(&gb, 32); | |
292 avctx->sample_rate = m4ac.sample_rate; | |
293 skip_bits_long(&gb, 32); // sample rate already known | |
294 sconf->samples = get_bits_long(&gb, 32); | |
295 avctx->channels = m4ac.channels; | |
296 skip_bits(&gb, 16); // number of channels already knwon | |
297 skip_bits(&gb, 3); // skip file_type | |
298 sconf->resolution = get_bits(&gb, 3); | |
299 sconf->floating = get_bits1(&gb); | |
300 skip_bits1(&gb); // skip msb_first | |
301 sconf->frame_length = get_bits(&gb, 16) + 1; | |
302 sconf->ra_distance = get_bits(&gb, 8); | |
303 sconf->ra_flag = get_bits(&gb, 2); | |
304 sconf->adapt_order = get_bits1(&gb); | |
305 sconf->coef_table = get_bits(&gb, 2); | |
306 sconf->long_term_prediction = get_bits1(&gb); | |
307 sconf->max_order = get_bits(&gb, 10); | |
308 sconf->block_switching = get_bits(&gb, 2); | |
309 sconf->bgmc = get_bits1(&gb); | |
310 sconf->sb_part = get_bits1(&gb); | |
311 sconf->joint_stereo = get_bits1(&gb); | |
312 sconf->mc_coding = get_bits1(&gb); | |
313 sconf->chan_config = get_bits1(&gb); | |
314 sconf->chan_sort = get_bits1(&gb); | |
315 crc_enabled = get_bits1(&gb); | |
316 sconf->rlslms = get_bits1(&gb); | |
317 skip_bits(&gb, 5); // skip 5 reserved bits | |
318 skip_bits1(&gb); // skip aux_data_enabled | |
319 | |
320 | |
321 // check for ALSSpecificConfig struct | |
322 if (als_id != MKBETAG('A','L','S','\0')) | |
323 return -1; | |
324 | |
325 ctx->cur_frame_length = sconf->frame_length; | |
326 | |
327 // read channel config | |
328 if (sconf->chan_config) | |
329 sconf->chan_config_info = get_bits(&gb, 16); | |
330 // TODO: use this to set avctx->channel_layout | |
331 | |
332 | |
333 // read channel sorting | |
334 if (sconf->chan_sort && avctx->channels > 1) { | |
335 int chan_pos_bits = av_ceil_log2(avctx->channels); | |
336 int bits_needed = avctx->channels * chan_pos_bits + 7; | |
337 if (get_bits_left(&gb) < bits_needed) | |
338 return -1; | |
339 | |
340 if (!(sconf->chan_pos = av_malloc(avctx->channels * sizeof(*sconf->chan_pos)))) | |
341 return AVERROR(ENOMEM); | |
342 | |
343 for (i = 0; i < avctx->channels; i++) | |
344 sconf->chan_pos[i] = get_bits(&gb, chan_pos_bits); | |
345 | |
346 align_get_bits(&gb); | |
347 // TODO: use this to actually do channel sorting | |
348 } else { | |
349 sconf->chan_sort = 0; | |
350 } | |
351 | |
352 | |
353 // read fixed header and trailer sizes, | |
354 // if size = 0xFFFFFFFF then there is no data field! | |
355 if (get_bits_left(&gb) < 64) | |
356 return -1; | |
357 | |
11071
327019a2d156
Remove unnecessary fields in ALSSpecificConfig.
thilo.borgmann
parents:
10861
diff
changeset
|
358 header_size = get_bits_long(&gb, 32); |
327019a2d156
Remove unnecessary fields in ALSSpecificConfig.
thilo.borgmann
parents:
10861
diff
changeset
|
359 trailer_size = get_bits_long(&gb, 32); |
327019a2d156
Remove unnecessary fields in ALSSpecificConfig.
thilo.borgmann
parents:
10861
diff
changeset
|
360 if (header_size == 0xFFFFFFFF) |
327019a2d156
Remove unnecessary fields in ALSSpecificConfig.
thilo.borgmann
parents:
10861
diff
changeset
|
361 header_size = 0; |
327019a2d156
Remove unnecessary fields in ALSSpecificConfig.
thilo.borgmann
parents:
10861
diff
changeset
|
362 if (trailer_size == 0xFFFFFFFF) |
327019a2d156
Remove unnecessary fields in ALSSpecificConfig.
thilo.borgmann
parents:
10861
diff
changeset
|
363 trailer_size = 0; |
10522 | 364 |
11071
327019a2d156
Remove unnecessary fields in ALSSpecificConfig.
thilo.borgmann
parents:
10861
diff
changeset
|
365 ht_size = ((int64_t)(header_size) + (int64_t)(trailer_size)) << 3; |
10522 | 366 |
367 | |
368 // skip the header and trailer data | |
369 if (get_bits_left(&gb) < ht_size) | |
370 return -1; | |
371 | |
372 if (ht_size > INT32_MAX) | |
373 return -1; | |
374 | |
375 skip_bits_long(&gb, ht_size); | |
376 | |
377 | |
378 // skip the crc data | |
379 if (crc_enabled) { | |
380 if (get_bits_left(&gb) < 32) | |
381 return -1; | |
382 | |
383 skip_bits_long(&gb, 32); | |
384 } | |
385 | |
386 | |
387 // no need to read the rest of ALSSpecificConfig (ra_unit_size & aux data) | |
388 | |
389 dprint_specific_config(ctx); | |
390 | |
391 return 0; | |
392 } | |
393 | |
394 | |
395 /** Checks the ALSSpecificConfig for unsupported features. | |
396 */ | |
397 static int check_specific_config(ALSDecContext *ctx) | |
398 { | |
399 ALSSpecificConfig *sconf = &ctx->sconf; | |
400 int error = 0; | |
401 | |
402 // report unsupported feature and set error value | |
403 #define MISSING_ERR(cond, str, errval) \ | |
404 { \ | |
405 if (cond) { \ | |
406 av_log_missing_feature(ctx->avctx, str, 0); \ | |
407 error = errval; \ | |
408 } \ | |
409 } | |
410 | |
411 MISSING_ERR(sconf->floating, "Floating point decoding", -1); | |
412 MISSING_ERR(sconf->rlslms, "Adaptive RLS-LMS prediction", -1); | |
413 MISSING_ERR(sconf->chan_sort, "Channel sorting", 0); | |
414 | |
415 return error; | |
416 } | |
417 | |
418 | |
419 /** Parses the bs_info field to extract the block partitioning used in | |
420 * block switching mode, refer to ISO/IEC 14496-3, section 11.6.2. | |
421 */ | |
422 static void parse_bs_info(const uint32_t bs_info, unsigned int n, | |
423 unsigned int div, unsigned int **div_blocks, | |
424 unsigned int *num_blocks) | |
425 { | |
426 if (n < 31 && ((bs_info << n) & 0x40000000)) { | |
427 // if the level is valid and the investigated bit n is set | |
428 // then recursively check both children at bits (2n+1) and (2n+2) | |
429 n *= 2; | |
430 div += 1; | |
431 parse_bs_info(bs_info, n + 1, div, div_blocks, num_blocks); | |
432 parse_bs_info(bs_info, n + 2, div, div_blocks, num_blocks); | |
433 } else { | |
434 // else the bit is not set or the last level has been reached | |
435 // (bit implicitly not set) | |
436 **div_blocks = div; | |
437 (*div_blocks)++; | |
438 (*num_blocks)++; | |
439 } | |
440 } | |
441 | |
442 | |
443 /** Reads and decodes a Rice codeword. | |
444 */ | |
445 static int32_t decode_rice(GetBitContext *gb, unsigned int k) | |
446 { | |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
10531
diff
changeset
|
447 int max = get_bits_left(gb) - k; |
10522 | 448 int q = get_unary(gb, 0, max); |
449 int r = k ? get_bits1(gb) : !(q & 1); | |
450 | |
451 if (k > 1) { | |
452 q <<= (k - 1); | |
453 q += get_bits_long(gb, k - 1); | |
454 } else if (!k) { | |
455 q >>= 1; | |
456 } | |
457 return r ? q : ~q; | |
458 } | |
459 | |
460 | |
461 /** Converts PARCOR coefficient k to direct filter coefficient. | |
462 */ | |
463 static void parcor_to_lpc(unsigned int k, const int32_t *par, int32_t *cof) | |
464 { | |
465 int i, j; | |
466 | |
467 for (i = 0, j = k - 1; i < j; i++, j--) { | |
468 int tmp1 = ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20); | |
469 cof[j] += ((MUL64(par[k], cof[i]) + (1 << 19)) >> 20); | |
470 cof[i] += tmp1; | |
471 } | |
472 if (i == j) | |
473 cof[i] += ((MUL64(par[k], cof[j]) + (1 << 19)) >> 20); | |
474 | |
475 cof[k] = par[k]; | |
476 } | |
477 | |
478 | |
479 /** Reads block switching field if necessary and sets actual block sizes. | |
480 * Also assures that the block sizes of the last frame correspond to the | |
481 * actual number of samples. | |
482 */ | |
483 static void get_block_sizes(ALSDecContext *ctx, unsigned int *div_blocks, | |
484 uint32_t *bs_info) | |
485 { | |
486 ALSSpecificConfig *sconf = &ctx->sconf; | |
487 GetBitContext *gb = &ctx->gb; | |
488 unsigned int *ptr_div_blocks = div_blocks; | |
489 unsigned int b; | |
490 | |
491 if (sconf->block_switching) { | |
492 unsigned int bs_info_len = 1 << (sconf->block_switching + 2); | |
493 *bs_info = get_bits_long(gb, bs_info_len); | |
494 *bs_info <<= (32 - bs_info_len); | |
495 } | |
496 | |
497 ctx->num_blocks = 0; | |
498 parse_bs_info(*bs_info, 0, 0, &ptr_div_blocks, &ctx->num_blocks); | |
499 | |
500 // The last frame may have an overdetermined block structure given in | |
501 // the bitstream. In that case the defined block structure would need | |
502 // more samples than available to be consistent. | |
503 // The block structure is actually used but the block sizes are adapted | |
504 // to fit the actual number of available samples. | |
505 // Example: 5 samples, 2nd level block sizes: 2 2 2 2. | |
506 // This results in the actual block sizes: 2 2 1 0. | |
507 // This is not specified in 14496-3 but actually done by the reference | |
508 // codec RM22 revision 2. | |
509 // This appears to happen in case of an odd number of samples in the last | |
510 // frame which is actually not allowed by the block length switching part | |
511 // of 14496-3. | |
512 // The ALS conformance files feature an odd number of samples in the last | |
513 // frame. | |
514 | |
515 for (b = 0; b < ctx->num_blocks; b++) | |
516 div_blocks[b] = ctx->sconf.frame_length >> div_blocks[b]; | |
517 | |
518 if (ctx->cur_frame_length != ctx->sconf.frame_length) { | |
519 unsigned int remaining = ctx->cur_frame_length; | |
520 | |
521 for (b = 0; b < ctx->num_blocks; b++) { | |
522 if (remaining < div_blocks[b]) { | |
523 div_blocks[b] = remaining; | |
524 ctx->num_blocks = b + 1; | |
525 break; | |
526 } | |
527 | |
528 remaining -= div_blocks[b]; | |
529 } | |
530 } | |
531 } | |
532 | |
533 | |
534 /** Reads the block data for a constant block | |
535 */ | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
536 static void read_const_block_data(ALSDecContext *ctx, ALSBlockData *bd) |
10522 | 537 { |
538 ALSSpecificConfig *sconf = &ctx->sconf; | |
539 AVCodecContext *avctx = ctx->avctx; | |
540 GetBitContext *gb = &ctx->gb; | |
541 | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
542 bd->const_val = 0; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
543 bd->const_block = get_bits1(gb); // 1 = constant value, 0 = zero block (silence) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
544 bd->js_blocks = get_bits1(gb); |
10522 | 545 |
546 // skip 5 reserved bits | |
547 skip_bits(gb, 5); | |
548 | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
549 if (bd->const_block) { |
10522 | 550 unsigned int const_val_bits = sconf->floating ? 24 : avctx->bits_per_raw_sample; |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
551 bd->const_val = get_sbits_long(gb, const_val_bits); |
10522 | 552 } |
553 | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
554 // ensure constant block decoding by reusing this field |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
555 bd->const_block = 1; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
556 } |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
557 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
558 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
559 /** Decodes the block data for a constant block |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
560 */ |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
561 static void decode_const_block_data(ALSDecContext *ctx, ALSBlockData *bd) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
562 { |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
563 int smp = bd->block_length; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
564 int32_t val = bd->const_val; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
565 int32_t *dst = bd->raw_samples; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
566 |
10522 | 567 // write raw samples into buffer |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
568 for (; smp; smp--) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
569 *dst++ = val; |
10522 | 570 } |
571 | |
572 | |
573 /** Reads the block data for a non-constant block | |
574 */ | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
575 static int read_var_block_data(ALSDecContext *ctx, ALSBlockData *bd) |
10522 | 576 { |
577 ALSSpecificConfig *sconf = &ctx->sconf; | |
578 AVCodecContext *avctx = ctx->avctx; | |
579 GetBitContext *gb = &ctx->gb; | |
580 unsigned int k; | |
581 unsigned int s[8]; | |
11148 | 582 unsigned int sx[8]; |
10522 | 583 unsigned int sub_blocks, log2_sub_blocks, sb_length; |
584 unsigned int start = 0; | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
585 unsigned int opt_order; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
586 int sb; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
587 int32_t *quant_cof = bd->quant_cof; |
11148 | 588 int32_t *current_res; |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
589 |
10522 | 590 |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
591 // ensure variable block decoding by reusing this field |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
592 bd->const_block = 0; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
593 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
594 bd->opt_order = 1; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
595 bd->js_blocks = get_bits1(gb); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
596 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
597 opt_order = bd->opt_order; |
10522 | 598 |
599 // determine the number of subblocks for entropy decoding | |
600 if (!sconf->bgmc && !sconf->sb_part) { | |
601 log2_sub_blocks = 0; | |
602 } else { | |
603 if (sconf->bgmc && sconf->sb_part) | |
604 log2_sub_blocks = get_bits(gb, 2); | |
605 else | |
606 log2_sub_blocks = 2 * get_bits1(gb); | |
607 } | |
608 | |
609 sub_blocks = 1 << log2_sub_blocks; | |
610 | |
611 // do not continue in case of a damaged stream since | |
612 // block_length must be evenly divisible by sub_blocks | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
613 if (bd->block_length & (sub_blocks - 1)) { |
10522 | 614 av_log(avctx, AV_LOG_WARNING, |
615 "Block length is not evenly divisible by the number of subblocks.\n"); | |
616 return -1; | |
617 } | |
618 | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
619 sb_length = bd->block_length >> log2_sub_blocks; |
10522 | 620 |
11148 | 621 if (sconf->bgmc) { |
622 s[0] = get_bits(gb, 8 + (sconf->resolution > 1)); | |
623 for (k = 1; k < sub_blocks; k++) | |
624 s[k] = s[k - 1] + decode_rice(gb, 2); | |
10522 | 625 |
11148 | 626 for (k = 0; k < sub_blocks; k++) { |
627 sx[k] = s[k] & 0x0F; | |
628 s [k] >>= 4; | |
629 } | |
10522 | 630 } else { |
631 s[0] = get_bits(gb, 4 + (sconf->resolution > 1)); | |
632 for (k = 1; k < sub_blocks; k++) | |
633 s[k] = s[k - 1] + decode_rice(gb, 0); | |
634 } | |
635 | |
636 if (get_bits1(gb)) | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
637 bd->shift_lsbs = get_bits(gb, 4) + 1; |
10522 | 638 |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
639 bd->store_prev_samples = (bd->js_blocks && bd->raw_other) || bd->shift_lsbs; |
10522 | 640 |
641 | |
642 if (!sconf->rlslms) { | |
643 if (sconf->adapt_order) { | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
644 int opt_order_length = av_ceil_log2(av_clip((bd->block_length >> 3) - 1, |
10522 | 645 2, sconf->max_order + 1)); |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
646 bd->opt_order = get_bits(gb, opt_order_length); |
10522 | 647 } else { |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
648 bd->opt_order = sconf->max_order; |
10522 | 649 } |
650 | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
651 opt_order = bd->opt_order; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
652 |
10522 | 653 if (opt_order) { |
654 int add_base; | |
655 | |
656 if (sconf->coef_table == 3) { | |
657 add_base = 0x7F; | |
658 | |
659 // read coefficient 0 | |
660 quant_cof[0] = 32 * parcor_scaled_values[get_bits(gb, 7)]; | |
661 | |
662 // read coefficient 1 | |
663 if (opt_order > 1) | |
664 quant_cof[1] = -32 * parcor_scaled_values[get_bits(gb, 7)]; | |
665 | |
666 // read coefficients 2 to opt_order | |
667 for (k = 2; k < opt_order; k++) | |
668 quant_cof[k] = get_bits(gb, 7); | |
669 } else { | |
670 int k_max; | |
671 add_base = 1; | |
672 | |
673 // read coefficient 0 to 19 | |
674 k_max = FFMIN(opt_order, 20); | |
675 for (k = 0; k < k_max; k++) { | |
676 int rice_param = parcor_rice_table[sconf->coef_table][k][1]; | |
677 int offset = parcor_rice_table[sconf->coef_table][k][0]; | |
678 quant_cof[k] = decode_rice(gb, rice_param) + offset; | |
679 } | |
680 | |
681 // read coefficients 20 to 126 | |
682 k_max = FFMIN(opt_order, 127); | |
683 for (; k < k_max; k++) | |
684 quant_cof[k] = decode_rice(gb, 2) + (k & 1); | |
685 | |
686 // read coefficients 127 to opt_order | |
687 for (; k < opt_order; k++) | |
688 quant_cof[k] = decode_rice(gb, 1); | |
689 | |
690 quant_cof[0] = 32 * parcor_scaled_values[quant_cof[0] + 64]; | |
691 | |
692 if (opt_order > 1) | |
693 quant_cof[1] = -32 * parcor_scaled_values[quant_cof[1] + 64]; | |
694 } | |
695 | |
696 for (k = 2; k < opt_order; k++) | |
697 quant_cof[k] = (quant_cof[k] << 14) + (add_base << 13); | |
698 } | |
699 } | |
700 | |
10530
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
701 // read LTP gain and lag values |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
702 if (sconf->long_term_prediction) { |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
703 *bd->use_ltp = get_bits1(gb); |
10530
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
704 |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
705 if (*bd->use_ltp) { |
11209
8173c059f769
Do sequential bit reading outside of []-operators.
thilo.borgmann
parents:
11199
diff
changeset
|
706 int r, c; |
8173c059f769
Do sequential bit reading outside of []-operators.
thilo.borgmann
parents:
11199
diff
changeset
|
707 |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
708 bd->ltp_gain[0] = decode_rice(gb, 1) << 3; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
709 bd->ltp_gain[1] = decode_rice(gb, 2) << 3; |
10530
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
710 |
11209
8173c059f769
Do sequential bit reading outside of []-operators.
thilo.borgmann
parents:
11199
diff
changeset
|
711 r = get_unary(gb, 0, 4); |
8173c059f769
Do sequential bit reading outside of []-operators.
thilo.borgmann
parents:
11199
diff
changeset
|
712 c = get_bits(gb, 2); |
8173c059f769
Do sequential bit reading outside of []-operators.
thilo.borgmann
parents:
11199
diff
changeset
|
713 bd->ltp_gain[2] = ltp_gain_values[r][c]; |
10530
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
714 |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
715 bd->ltp_gain[3] = decode_rice(gb, 2) << 3; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
716 bd->ltp_gain[4] = decode_rice(gb, 1) << 3; |
10530
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
717 |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
718 *bd->ltp_lag = get_bits(gb, ctx->ltp_lag_length); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
719 *bd->ltp_lag += FFMAX(4, opt_order + 1); |
10530
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
720 } |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
721 } |
10522 | 722 |
723 // read first value and residuals in case of a random access block | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
724 if (bd->ra_block) { |
10522 | 725 if (opt_order) |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
726 bd->raw_samples[0] = decode_rice(gb, avctx->bits_per_raw_sample - 4); |
10522 | 727 if (opt_order > 1) |
11189
638415aafbda
Limit the Rice parameter used for progressive decoding in ALS.
thilo.borgmann
parents:
11157
diff
changeset
|
728 bd->raw_samples[1] = decode_rice(gb, FFMIN(s[0] + 3, ctx->s_max)); |
10522 | 729 if (opt_order > 2) |
11189
638415aafbda
Limit the Rice parameter used for progressive decoding in ALS.
thilo.borgmann
parents:
11157
diff
changeset
|
730 bd->raw_samples[2] = decode_rice(gb, FFMIN(s[0] + 1, ctx->s_max)); |
10522 | 731 |
732 start = FFMIN(opt_order, 3); | |
733 } | |
734 | |
735 // read all residuals | |
736 if (sconf->bgmc) { | |
11148 | 737 unsigned int delta[sub_blocks]; |
738 unsigned int k [sub_blocks]; | |
739 unsigned int b = av_clip((av_ceil_log2(bd->block_length) - 3) >> 1, 0, 5); | |
740 unsigned int i = start; | |
741 | |
742 // read most significant bits | |
743 unsigned int high; | |
744 unsigned int low; | |
745 unsigned int value; | |
746 | |
747 ff_bgmc_decode_init(gb, &high, &low, &value); | |
748 | |
749 current_res = bd->raw_samples + start; | |
750 | |
751 for (sb = 0; sb < sub_blocks; sb++, i = 0) { | |
752 k [sb] = s[sb] > b ? s[sb] - b : 0; | |
753 delta[sb] = 5 - s[sb] + k[sb]; | |
754 | |
755 ff_bgmc_decode(gb, sb_length, current_res, | |
756 delta[sb], sx[sb], &high, &low, &value, ctx->bgmc_lut, ctx->bgmc_lut_status); | |
757 | |
758 current_res += sb_length; | |
759 } | |
760 | |
761 ff_bgmc_decode_end(gb); | |
762 | |
763 | |
764 // read least significant bits and tails | |
765 i = start; | |
766 current_res = bd->raw_samples + start; | |
767 | |
768 for (sb = 0; sb < sub_blocks; sb++, i = 0) { | |
769 unsigned int cur_tail_code = tail_code[sx[sb]][delta[sb]]; | |
770 unsigned int cur_k = k[sb]; | |
771 unsigned int cur_s = s[sb]; | |
772 | |
773 for (; i < sb_length; i++) { | |
774 int32_t res = *current_res; | |
775 | |
776 if (res == cur_tail_code) { | |
777 unsigned int max_msb = (2 + (sx[sb] > 2) + (sx[sb] > 10)) | |
778 << (5 - delta[sb]); | |
779 | |
780 res = decode_rice(gb, cur_s); | |
781 | |
782 if (res >= 0) { | |
783 res += (max_msb ) << cur_k; | |
784 } else { | |
785 res -= (max_msb - 1) << cur_k; | |
786 } | |
787 } else { | |
788 if (res > cur_tail_code) | |
789 res--; | |
790 | |
791 if (res & 1) | |
792 res = -res; | |
793 | |
794 res >>= 1; | |
795 | |
796 if (cur_k) { | |
797 res <<= cur_k; | |
798 res |= get_bits_long(gb, cur_k); | |
799 } | |
800 } | |
801 | |
11157 | 802 *current_res++ = res; |
11148 | 803 } |
804 } | |
10522 | 805 } else { |
11148 | 806 current_res = bd->raw_samples + start; |
10522 | 807 |
808 for (sb = 0; sb < sub_blocks; sb++, start = 0) | |
809 for (; start < sb_length; start++) | |
810 *current_res++ = decode_rice(gb, s[sb]); | |
811 } | |
812 | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
813 if (!sconf->mc_coding || ctx->js_switch) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
814 align_get_bits(gb); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
815 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
816 return 0; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
817 } |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
818 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
819 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
820 /** Decodes the block data for a non-constant block |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
821 */ |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
822 static int decode_var_block_data(ALSDecContext *ctx, ALSBlockData *bd) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
823 { |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
824 ALSSpecificConfig *sconf = &ctx->sconf; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
825 unsigned int block_length = bd->block_length; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
826 unsigned int smp = 0; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
827 unsigned int k; |
10823
d87e8f2c5c91
Change local variable type from unsigned int to int in order to
thilo.borgmann
parents:
10802
diff
changeset
|
828 int opt_order = bd->opt_order; |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
829 int sb; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
830 int64_t y; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
831 int32_t *quant_cof = bd->quant_cof; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
832 int32_t *lpc_cof = bd->lpc_cof; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
833 int32_t *raw_samples = bd->raw_samples; |
10800
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
834 int32_t *raw_samples_end = bd->raw_samples + bd->block_length; |
10860
c9fb5b89e47a
Replace variable length array with an allocated buffer
thilo.borgmann
parents:
10823
diff
changeset
|
835 int32_t *lpc_cof_reversed = ctx->lpc_cof_reversed_buffer; |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
836 |
10530
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
837 // reverse long-term prediction |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
838 if (*bd->use_ltp) { |
10530
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
839 int ltp_smp; |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
840 |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
841 for (ltp_smp = FFMAX(*bd->ltp_lag - 2, 0); ltp_smp < block_length; ltp_smp++) { |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
842 int center = ltp_smp - *bd->ltp_lag; |
10530
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
843 int begin = FFMAX(0, center - 2); |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
844 int end = center + 3; |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
845 int tab = 5 - (end - begin); |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
846 int base; |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
847 |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
848 y = 1 << 6; |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
849 |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
850 for (base = begin; base < end; base++, tab++) |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
851 y += MUL64(bd->ltp_gain[tab], raw_samples[base]); |
10530
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
852 |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
853 raw_samples[ltp_smp] += y >> 7; |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
854 } |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
855 } |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
856 |
10522 | 857 // reconstruct all samples from residuals |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
858 if (bd->ra_block) { |
10522 | 859 for (smp = 0; smp < opt_order; smp++) { |
860 y = 1 << 19; | |
861 | |
862 for (sb = 0; sb < smp; sb++) | |
10800
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
863 y += MUL64(lpc_cof[sb], raw_samples[-(sb + 1)]); |
10522 | 864 |
10800
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
865 *raw_samples++ -= y >> 20; |
10522 | 866 parcor_to_lpc(smp, quant_cof, lpc_cof); |
867 } | |
868 } else { | |
869 for (k = 0; k < opt_order; k++) | |
870 parcor_to_lpc(k, quant_cof, lpc_cof); | |
871 | |
872 // store previous samples in case that they have to be altered | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
873 if (bd->store_prev_samples) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
874 memcpy(bd->prev_raw_samples, raw_samples - sconf->max_order, |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
875 sizeof(*bd->prev_raw_samples) * sconf->max_order); |
10522 | 876 |
877 // reconstruct difference signal for prediction (joint-stereo) | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
878 if (bd->js_blocks && bd->raw_other) { |
10522 | 879 int32_t *left, *right; |
880 | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
881 if (bd->raw_other > raw_samples) { // D = R - L |
10522 | 882 left = raw_samples; |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
883 right = bd->raw_other; |
10522 | 884 } else { // D = R - L |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
885 left = bd->raw_other; |
10522 | 886 right = raw_samples; |
887 } | |
888 | |
889 for (sb = -1; sb >= -sconf->max_order; sb--) | |
890 raw_samples[sb] = right[sb] - left[sb]; | |
891 } | |
892 | |
893 // reconstruct shifted signal | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
894 if (bd->shift_lsbs) |
10522 | 895 for (sb = -1; sb >= -sconf->max_order; sb--) |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
896 raw_samples[sb] >>= bd->shift_lsbs; |
10522 | 897 } |
898 | |
10800
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
899 // reverse linear prediction coefficients for efficiency |
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
900 lpc_cof = lpc_cof + opt_order; |
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
901 |
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
902 for (sb = 0; sb < opt_order; sb++) |
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
903 lpc_cof_reversed[sb] = lpc_cof[-(sb + 1)]; |
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
904 |
10522 | 905 // reconstruct raw samples |
10800
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
906 raw_samples = bd->raw_samples + smp; |
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
907 lpc_cof = lpc_cof_reversed + opt_order; |
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
908 |
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
909 for (; raw_samples < raw_samples_end; raw_samples++) { |
10522 | 910 y = 1 << 19; |
911 | |
10800
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
912 for (sb = -opt_order; sb < 0; sb++) |
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
913 y += MUL64(lpc_cof[sb], raw_samples[sb]); |
10522 | 914 |
10800
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
915 *raw_samples -= y >> 20; |
10522 | 916 } |
917 | |
10800
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
918 raw_samples = bd->raw_samples; |
67e430033b14
Optimize short-term prediction by reducing index arithmetic.
thilo.borgmann
parents:
10774
diff
changeset
|
919 |
10522 | 920 // restore previous samples in case that they have been altered |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
921 if (bd->store_prev_samples) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
922 memcpy(raw_samples - sconf->max_order, bd->prev_raw_samples, |
10522 | 923 sizeof(*raw_samples) * sconf->max_order); |
924 | |
925 return 0; | |
926 } | |
927 | |
928 | |
929 /** Reads the block data. | |
930 */ | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
931 static int read_block(ALSDecContext *ctx, ALSBlockData *bd) |
10522 | 932 { |
933 GetBitContext *gb = &ctx->gb; | |
934 | |
935 // read block type flag and read the samples accordingly | |
936 if (get_bits1(gb)) { | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
937 if (read_var_block_data(ctx, bd)) |
10522 | 938 return -1; |
939 } else { | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
940 read_const_block_data(ctx, bd); |
10522 | 941 } |
942 | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
943 return 0; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
944 } |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
945 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
946 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
947 /** Decodes the block data. |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
948 */ |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
949 static int decode_block(ALSDecContext *ctx, ALSBlockData *bd) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
950 { |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
951 unsigned int smp; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
952 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
953 // read block type flag and read the samples accordingly |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
954 if (bd->const_block) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
955 decode_const_block_data(ctx, bd); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
956 else if (decode_var_block_data(ctx, bd)) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
957 return -1; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
958 |
10522 | 959 // TODO: read RLSLMS extension data |
960 | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
961 if (bd->shift_lsbs) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
962 for (smp = 0; smp < bd->block_length; smp++) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
963 bd->raw_samples[smp] <<= bd->shift_lsbs; |
10522 | 964 |
965 return 0; | |
966 } | |
967 | |
968 | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
969 /** Reads and decodes block data successively. |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
970 */ |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
971 static int read_decode_block(ALSDecContext *ctx, ALSBlockData *bd) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
972 { |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
973 int ret; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
974 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
975 ret = read_block(ctx, bd); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
976 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
977 if (ret) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
978 return ret; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
979 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
980 ret = decode_block(ctx, bd); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
981 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
982 return ret; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
983 } |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
984 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
985 |
10522 | 986 /** Computes the number of samples left to decode for the current frame and |
987 * sets these samples to zero. | |
988 */ | |
989 static void zero_remaining(unsigned int b, unsigned int b_max, | |
990 const unsigned int *div_blocks, int32_t *buf) | |
991 { | |
992 unsigned int count = 0; | |
993 | |
994 while (b < b_max) | |
995 count += div_blocks[b]; | |
996 | |
10523 | 997 if (count) |
10524 | 998 memset(buf, 0, sizeof(*buf) * count); |
10522 | 999 } |
1000 | |
1001 | |
1002 /** Decodes blocks independently. | |
1003 */ | |
1004 static int decode_blocks_ind(ALSDecContext *ctx, unsigned int ra_frame, | |
1005 unsigned int c, const unsigned int *div_blocks, | |
1006 unsigned int *js_blocks) | |
1007 { | |
1008 unsigned int b; | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1009 ALSBlockData bd; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1010 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1011 memset(&bd, 0, sizeof(ALSBlockData)); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1012 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1013 bd.ra_block = ra_frame; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1014 bd.use_ltp = ctx->use_ltp; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1015 bd.ltp_lag = ctx->ltp_lag; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1016 bd.ltp_gain = ctx->ltp_gain[0]; |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1017 bd.quant_cof = ctx->quant_cof[0]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1018 bd.lpc_cof = ctx->lpc_cof[0]; |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1019 bd.prev_raw_samples = ctx->prev_raw_samples; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1020 bd.raw_samples = ctx->raw_samples[c]; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1021 |
10522 | 1022 |
1023 for (b = 0; b < ctx->num_blocks; b++) { | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1024 bd.shift_lsbs = 0; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1025 bd.block_length = div_blocks[b]; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1026 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1027 if (read_decode_block(ctx, &bd)) { |
10522 | 1028 // damaged block, write zero for the rest of the frame |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1029 zero_remaining(b, ctx->num_blocks, div_blocks, bd.raw_samples); |
10522 | 1030 return -1; |
1031 } | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1032 bd.raw_samples += div_blocks[b]; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1033 bd.ra_block = 0; |
10522 | 1034 } |
1035 | |
1036 return 0; | |
1037 } | |
1038 | |
1039 | |
1040 /** Decodes blocks dependently. | |
1041 */ | |
1042 static int decode_blocks(ALSDecContext *ctx, unsigned int ra_frame, | |
1043 unsigned int c, const unsigned int *div_blocks, | |
1044 unsigned int *js_blocks) | |
1045 { | |
1046 ALSSpecificConfig *sconf = &ctx->sconf; | |
1047 unsigned int offset = 0; | |
1048 unsigned int b; | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1049 ALSBlockData bd[2]; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1050 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1051 memset(bd, 0, 2 * sizeof(ALSBlockData)); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1052 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1053 bd[0].ra_block = ra_frame; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1054 bd[0].use_ltp = ctx->use_ltp; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1055 bd[0].ltp_lag = ctx->ltp_lag; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1056 bd[0].ltp_gain = ctx->ltp_gain[0]; |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1057 bd[0].quant_cof = ctx->quant_cof[0]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1058 bd[0].lpc_cof = ctx->lpc_cof[0]; |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1059 bd[0].prev_raw_samples = ctx->prev_raw_samples; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1060 bd[0].js_blocks = *js_blocks; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1061 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1062 bd[1].ra_block = ra_frame; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1063 bd[1].use_ltp = ctx->use_ltp; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1064 bd[1].ltp_lag = ctx->ltp_lag; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1065 bd[1].ltp_gain = ctx->ltp_gain[0]; |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1066 bd[1].quant_cof = ctx->quant_cof[0]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1067 bd[1].lpc_cof = ctx->lpc_cof[0]; |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1068 bd[1].prev_raw_samples = ctx->prev_raw_samples; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1069 bd[1].js_blocks = *(js_blocks + 1); |
10522 | 1070 |
1071 // decode all blocks | |
1072 for (b = 0; b < ctx->num_blocks; b++) { | |
1073 unsigned int s; | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1074 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1075 bd[0].shift_lsbs = 0; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1076 bd[1].shift_lsbs = 0; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1077 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1078 bd[0].block_length = div_blocks[b]; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1079 bd[1].block_length = div_blocks[b]; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1080 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1081 bd[0].raw_samples = ctx->raw_samples[c ] + offset; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1082 bd[1].raw_samples = ctx->raw_samples[c + 1] + offset; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1083 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1084 bd[0].raw_other = bd[1].raw_samples; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1085 bd[1].raw_other = bd[0].raw_samples; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1086 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1087 if(read_decode_block(ctx, &bd[0]) || read_decode_block(ctx, &bd[1])) { |
10522 | 1088 // damaged block, write zero for the rest of the frame |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1089 zero_remaining(b, ctx->num_blocks, div_blocks, bd[0].raw_samples); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1090 zero_remaining(b, ctx->num_blocks, div_blocks, bd[1].raw_samples); |
10522 | 1091 return -1; |
1092 } | |
1093 | |
1094 // reconstruct joint-stereo blocks | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1095 if (bd[0].js_blocks) { |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1096 if (bd[1].js_blocks) |
10522 | 1097 av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel pair!\n"); |
1098 | |
1099 for (s = 0; s < div_blocks[b]; s++) | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1100 bd[0].raw_samples[s] = bd[1].raw_samples[s] - bd[0].raw_samples[s]; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1101 } else if (bd[1].js_blocks) { |
10522 | 1102 for (s = 0; s < div_blocks[b]; s++) |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1103 bd[1].raw_samples[s] = bd[1].raw_samples[s] + bd[0].raw_samples[s]; |
10522 | 1104 } |
1105 | |
1106 offset += div_blocks[b]; | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1107 bd[0].ra_block = 0; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1108 bd[1].ra_block = 0; |
10522 | 1109 } |
1110 | |
1111 // store carryover raw samples, | |
1112 // the others channel raw samples are stored by the calling function. | |
1113 memmove(ctx->raw_samples[c] - sconf->max_order, | |
1114 ctx->raw_samples[c] - sconf->max_order + sconf->frame_length, | |
1115 sizeof(*ctx->raw_samples[c]) * sconf->max_order); | |
1116 | |
1117 return 0; | |
1118 } | |
1119 | |
1120 | |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1121 /** Reads the channel data. |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1122 */ |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1123 static int read_channel_data(ALSDecContext *ctx, ALSChannelData *cd, int c) |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1124 { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1125 GetBitContext *gb = &ctx->gb; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1126 ALSChannelData *current = cd; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1127 unsigned int channels = ctx->avctx->channels; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1128 int entries = 0; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1129 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1130 while (entries < channels && !(current->stop_flag = get_bits1(gb))) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1131 current->master_channel = get_bits_long(gb, av_ceil_log2(channels)); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1132 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1133 if (current->master_channel >= channels) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1134 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid master channel!\n"); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1135 return -1; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1136 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1137 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1138 if (current->master_channel != c) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1139 current->time_diff_flag = get_bits1(gb); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1140 current->weighting[0] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1141 current->weighting[1] = mcc_weightings[av_clip(decode_rice(gb, 2) + 14, 0, 32)]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1142 current->weighting[2] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1143 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1144 if (current->time_diff_flag) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1145 current->weighting[3] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1146 current->weighting[4] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1147 current->weighting[5] = mcc_weightings[av_clip(decode_rice(gb, 1) + 16, 0, 32)]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1148 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1149 current->time_diff_sign = get_bits1(gb); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1150 current->time_diff_index = get_bits(gb, ctx->ltp_lag_length - 3) + 3; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1151 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1152 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1153 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1154 current++; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1155 entries++; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1156 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1157 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1158 if (entries == channels) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1159 av_log(ctx->avctx, AV_LOG_ERROR, "Damaged channel data!\n"); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1160 return -1; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1161 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1162 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1163 align_get_bits(gb); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1164 return 0; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1165 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1166 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1167 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1168 /** Recursively reverts the inter-channel correlation for a block. |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1169 */ |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1170 static int revert_channel_correlation(ALSDecContext *ctx, ALSBlockData *bd, |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1171 ALSChannelData **cd, int *reverted, |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1172 unsigned int offset, int c) |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1173 { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1174 ALSChannelData *ch = cd[c]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1175 unsigned int dep = 0; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1176 unsigned int channels = ctx->avctx->channels; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1177 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1178 if (reverted[c]) |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1179 return 0; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1180 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1181 reverted[c] = 1; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1182 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1183 while (dep < channels && !ch[dep].stop_flag) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1184 revert_channel_correlation(ctx, bd, cd, reverted, offset, |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1185 ch[dep].master_channel); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1186 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1187 dep++; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1188 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1189 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1190 if (dep == channels) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1191 av_log(ctx->avctx, AV_LOG_WARNING, "Invalid channel correlation!\n"); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1192 return -1; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1193 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1194 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1195 bd->use_ltp = ctx->use_ltp + c; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1196 bd->ltp_lag = ctx->ltp_lag + c; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1197 bd->ltp_gain = ctx->ltp_gain[c]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1198 bd->lpc_cof = ctx->lpc_cof[c]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1199 bd->quant_cof = ctx->quant_cof[c]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1200 bd->raw_samples = ctx->raw_samples[c] + offset; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1201 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1202 dep = 0; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1203 while (!ch[dep].stop_flag) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1204 unsigned int smp; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1205 unsigned int begin = 1; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1206 unsigned int end = bd->block_length - 1; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1207 int64_t y; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1208 int32_t *master = ctx->raw_samples[ch[dep].master_channel] + offset; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1209 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1210 if (ch[dep].time_diff_flag) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1211 int t = ch[dep].time_diff_index; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1212 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1213 if (ch[dep].time_diff_sign) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1214 t = -t; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1215 begin -= t; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1216 } else { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1217 end -= t; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1218 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1219 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1220 for (smp = begin; smp < end; smp++) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1221 y = (1 << 6) + |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1222 MUL64(ch[dep].weighting[0], master[smp - 1 ]) + |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1223 MUL64(ch[dep].weighting[1], master[smp ]) + |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1224 MUL64(ch[dep].weighting[2], master[smp + 1 ]) + |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1225 MUL64(ch[dep].weighting[3], master[smp - 1 + t]) + |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1226 MUL64(ch[dep].weighting[4], master[smp + t]) + |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1227 MUL64(ch[dep].weighting[5], master[smp + 1 + t]); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1228 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1229 bd->raw_samples[smp] += y >> 7; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1230 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1231 } else { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1232 for (smp = begin; smp < end; smp++) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1233 y = (1 << 6) + |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1234 MUL64(ch[dep].weighting[0], master[smp - 1]) + |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1235 MUL64(ch[dep].weighting[1], master[smp ]) + |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1236 MUL64(ch[dep].weighting[2], master[smp + 1]); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1237 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1238 bd->raw_samples[smp] += y >> 7; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1239 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1240 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1241 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1242 dep++; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1243 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1244 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1245 return 0; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1246 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1247 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1248 |
10522 | 1249 /** Reads the frame data. |
1250 */ | |
1251 static int read_frame_data(ALSDecContext *ctx, unsigned int ra_frame) | |
1252 { | |
1253 ALSSpecificConfig *sconf = &ctx->sconf; | |
1254 AVCodecContext *avctx = ctx->avctx; | |
1255 GetBitContext *gb = &ctx->gb; | |
1256 unsigned int div_blocks[32]; ///< block sizes. | |
1257 unsigned int c; | |
1258 unsigned int js_blocks[2]; | |
1259 | |
1260 uint32_t bs_info = 0; | |
1261 | |
1262 // skip the size of the ra unit if present in the frame | |
1263 if (sconf->ra_flag == RA_FLAG_FRAMES && ra_frame) | |
1264 skip_bits_long(gb, 32); | |
1265 | |
1266 if (sconf->mc_coding && sconf->joint_stereo) { | |
1267 ctx->js_switch = get_bits1(gb); | |
1268 align_get_bits(gb); | |
1269 } | |
1270 | |
1271 if (!sconf->mc_coding || ctx->js_switch) { | |
1272 int independent_bs = !sconf->joint_stereo; | |
1273 | |
1274 for (c = 0; c < avctx->channels; c++) { | |
1275 js_blocks[0] = 0; | |
1276 js_blocks[1] = 0; | |
1277 | |
1278 get_block_sizes(ctx, div_blocks, &bs_info); | |
1279 | |
1280 // if joint_stereo and block_switching is set, independent decoding | |
1281 // is signaled via the first bit of bs_info | |
1282 if (sconf->joint_stereo && sconf->block_switching) | |
1283 if (bs_info >> 31) | |
1284 independent_bs = 2; | |
1285 | |
1286 // if this is the last channel, it has to be decoded independently | |
1287 if (c == avctx->channels - 1) | |
1288 independent_bs = 1; | |
1289 | |
1290 if (independent_bs) { | |
1291 if (decode_blocks_ind(ctx, ra_frame, c, div_blocks, js_blocks)) | |
1292 return -1; | |
1293 | |
1294 independent_bs--; | |
1295 } else { | |
1296 if (decode_blocks(ctx, ra_frame, c, div_blocks, js_blocks)) | |
1297 return -1; | |
1298 | |
1299 c++; | |
1300 } | |
1301 | |
1302 // store carryover raw samples | |
1303 memmove(ctx->raw_samples[c] - sconf->max_order, | |
1304 ctx->raw_samples[c] - sconf->max_order + sconf->frame_length, | |
1305 sizeof(*ctx->raw_samples[c]) * sconf->max_order); | |
1306 } | |
1307 } else { // multi-channel coding | |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1308 ALSBlockData bd; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1309 int b; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1310 int *reverted_channels = ctx->reverted_channels; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1311 unsigned int offset = 0; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1312 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1313 for (c = 0; c < avctx->channels; c++) |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1314 if (ctx->chan_data[c] < ctx->chan_data_buffer) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1315 av_log(ctx->avctx, AV_LOG_ERROR, "Invalid channel data!\n"); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1316 return -1; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1317 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1318 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1319 memset(&bd, 0, sizeof(ALSBlockData)); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1320 memset(reverted_channels, 0, sizeof(*reverted_channels) * avctx->channels); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1321 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1322 bd.ra_block = ra_frame; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1323 bd.prev_raw_samples = ctx->prev_raw_samples; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1324 |
10522 | 1325 get_block_sizes(ctx, div_blocks, &bs_info); |
1326 | |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1327 for (b = 0; b < ctx->num_blocks; b++) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1328 bd.shift_lsbs = 0; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1329 bd.block_length = div_blocks[b]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1330 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1331 for (c = 0; c < avctx->channels; c++) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1332 bd.use_ltp = ctx->use_ltp + c; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1333 bd.ltp_lag = ctx->ltp_lag + c; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1334 bd.ltp_gain = ctx->ltp_gain[c]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1335 bd.lpc_cof = ctx->lpc_cof[c]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1336 bd.quant_cof = ctx->quant_cof[c]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1337 bd.raw_samples = ctx->raw_samples[c] + offset; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1338 bd.raw_other = NULL; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1339 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1340 read_block(ctx, &bd); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1341 if (read_channel_data(ctx, ctx->chan_data[c], c)) |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1342 return -1; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1343 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1344 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1345 for (c = 0; c < avctx->channels; c++) |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1346 if (revert_channel_correlation(ctx, &bd, ctx->chan_data, |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1347 reverted_channels, offset, c)) |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1348 return -1; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1349 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1350 for (c = 0; c < avctx->channels; c++) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1351 bd.use_ltp = ctx->use_ltp + c; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1352 bd.ltp_lag = ctx->ltp_lag + c; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1353 bd.ltp_gain = ctx->ltp_gain[c]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1354 bd.lpc_cof = ctx->lpc_cof[c]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1355 bd.quant_cof = ctx->quant_cof[c]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1356 bd.raw_samples = ctx->raw_samples[c] + offset; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1357 decode_block(ctx, &bd); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1358 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1359 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1360 memset(reverted_channels, 0, avctx->channels * sizeof(*reverted_channels)); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1361 offset += div_blocks[b]; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1362 bd.ra_block = 0; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1363 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1364 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1365 // store carryover raw samples |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1366 for (c = 0; c < avctx->channels; c++) |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1367 memmove(ctx->raw_samples[c] - sconf->max_order, |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1368 ctx->raw_samples[c] - sconf->max_order + sconf->frame_length, |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1369 sizeof(*ctx->raw_samples[c]) * sconf->max_order); |
10522 | 1370 } |
1371 | |
1372 // TODO: read_diff_float_data | |
1373 | |
1374 return 0; | |
1375 } | |
1376 | |
1377 | |
1378 /** Decodes an ALS frame. | |
1379 */ | |
1380 static int decode_frame(AVCodecContext *avctx, | |
1381 void *data, int *data_size, | |
1382 AVPacket *avpkt) | |
1383 { | |
1384 ALSDecContext *ctx = avctx->priv_data; | |
1385 ALSSpecificConfig *sconf = &ctx->sconf; | |
1386 const uint8_t *buffer = avpkt->data; | |
1387 int buffer_size = avpkt->size; | |
1388 int invalid_frame, size; | |
1389 unsigned int c, sample, ra_frame, bytes_read, shift; | |
1390 | |
1391 init_get_bits(&ctx->gb, buffer, buffer_size * 8); | |
1392 | |
1393 // In the case that the distance between random access frames is set to zero | |
1394 // (sconf->ra_distance == 0) no frame is treated as a random access frame. | |
1395 // For the first frame, if prediction is used, all samples used from the | |
1396 // previous frame are assumed to be zero. | |
1397 ra_frame = sconf->ra_distance && !(ctx->frame_id % sconf->ra_distance); | |
1398 | |
1399 // the last frame to decode might have a different length | |
1400 if (sconf->samples != 0xFFFFFFFF) | |
1401 ctx->cur_frame_length = FFMIN(sconf->samples - ctx->frame_id * (uint64_t) sconf->frame_length, | |
1402 sconf->frame_length); | |
1403 else | |
1404 ctx->cur_frame_length = sconf->frame_length; | |
1405 | |
1406 // decode the frame data | |
1407 if ((invalid_frame = read_frame_data(ctx, ra_frame) < 0)) | |
1408 av_log(ctx->avctx, AV_LOG_WARNING, | |
1409 "Reading frame data failed. Skipping RA unit.\n"); | |
1410 | |
1411 ctx->frame_id++; | |
1412 | |
1413 // check for size of decoded data | |
1414 size = ctx->cur_frame_length * avctx->channels * | |
1415 (av_get_bits_per_sample_format(avctx->sample_fmt) >> 3); | |
1416 | |
1417 if (size > *data_size) { | |
1418 av_log(avctx, AV_LOG_ERROR, "Decoded data exceeds buffer size.\n"); | |
1419 return -1; | |
1420 } | |
1421 | |
1422 *data_size = size; | |
1423 | |
1424 // transform decoded frame into output format | |
1425 #define INTERLEAVE_OUTPUT(bps) \ | |
1426 { \ | |
1427 int##bps##_t *dest = (int##bps##_t*) data; \ | |
1428 shift = bps - ctx->avctx->bits_per_raw_sample; \ | |
1429 for (sample = 0; sample < ctx->cur_frame_length; sample++) \ | |
1430 for (c = 0; c < avctx->channels; c++) \ | |
1431 *dest++ = ctx->raw_samples[c][sample] << shift; \ | |
1432 } | |
1433 | |
1434 if (ctx->avctx->bits_per_raw_sample <= 16) { | |
1435 INTERLEAVE_OUTPUT(16) | |
1436 } else { | |
1437 INTERLEAVE_OUTPUT(32) | |
1438 } | |
1439 | |
1440 bytes_read = invalid_frame ? buffer_size : | |
1441 (get_bits_count(&ctx->gb) + 7) >> 3; | |
1442 | |
1443 return bytes_read; | |
1444 } | |
1445 | |
1446 | |
1447 /** Uninitializes the ALS decoder. | |
1448 */ | |
1449 static av_cold int decode_end(AVCodecContext *avctx) | |
1450 { | |
1451 ALSDecContext *ctx = avctx->priv_data; | |
1452 | |
1453 av_freep(&ctx->sconf.chan_pos); | |
1454 | |
11148 | 1455 ff_bgmc_end(&ctx->bgmc_lut, &ctx->bgmc_lut_status); |
1456 | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1457 av_freep(&ctx->use_ltp); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1458 av_freep(&ctx->ltp_lag); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1459 av_freep(&ctx->ltp_gain); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1460 av_freep(&ctx->ltp_gain_buffer); |
10522 | 1461 av_freep(&ctx->quant_cof); |
1462 av_freep(&ctx->lpc_cof); | |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1463 av_freep(&ctx->quant_cof_buffer); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1464 av_freep(&ctx->lpc_cof_buffer); |
10860
c9fb5b89e47a
Replace variable length array with an allocated buffer
thilo.borgmann
parents:
10823
diff
changeset
|
1465 av_freep(&ctx->lpc_cof_reversed_buffer); |
10522 | 1466 av_freep(&ctx->prev_raw_samples); |
1467 av_freep(&ctx->raw_samples); | |
1468 av_freep(&ctx->raw_buffer); | |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1469 av_freep(&ctx->chan_data); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1470 av_freep(&ctx->chan_data_buffer); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1471 av_freep(&ctx->reverted_channels); |
10522 | 1472 |
1473 return 0; | |
1474 } | |
1475 | |
1476 | |
1477 /** Initializes the ALS decoder. | |
1478 */ | |
1479 static av_cold int decode_init(AVCodecContext *avctx) | |
1480 { | |
1481 unsigned int c; | |
1482 unsigned int channel_size; | |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1483 int num_buffers; |
10522 | 1484 ALSDecContext *ctx = avctx->priv_data; |
1485 ALSSpecificConfig *sconf = &ctx->sconf; | |
1486 ctx->avctx = avctx; | |
1487 | |
1488 if (!avctx->extradata) { | |
1489 av_log(avctx, AV_LOG_ERROR, "Missing required ALS extradata.\n"); | |
1490 return -1; | |
1491 } | |
1492 | |
1493 if (read_specific_config(ctx)) { | |
1494 av_log(avctx, AV_LOG_ERROR, "Reading ALSSpecificConfig failed.\n"); | |
1495 decode_end(avctx); | |
1496 return -1; | |
1497 } | |
1498 | |
1499 if (check_specific_config(ctx)) { | |
1500 decode_end(avctx); | |
1501 return -1; | |
1502 } | |
1503 | |
11148 | 1504 if (sconf->bgmc) |
1505 ff_bgmc_init(avctx, &ctx->bgmc_lut, &ctx->bgmc_lut_status); | |
1506 | |
10522 | 1507 if (sconf->floating) { |
1508 avctx->sample_fmt = SAMPLE_FMT_FLT; | |
1509 avctx->bits_per_raw_sample = 32; | |
1510 } else { | |
1511 avctx->sample_fmt = sconf->resolution > 1 | |
1512 ? SAMPLE_FMT_S32 : SAMPLE_FMT_S16; | |
1513 avctx->bits_per_raw_sample = (sconf->resolution + 1) * 8; | |
1514 } | |
1515 | |
11189
638415aafbda
Limit the Rice parameter used for progressive decoding in ALS.
thilo.borgmann
parents:
11157
diff
changeset
|
1516 // set maximum Rice parameter for progressive decoding based on resolution |
638415aafbda
Limit the Rice parameter used for progressive decoding in ALS.
thilo.borgmann
parents:
11157
diff
changeset
|
1517 // This is not specified in 14496-3 but actually done by the reference |
638415aafbda
Limit the Rice parameter used for progressive decoding in ALS.
thilo.borgmann
parents:
11157
diff
changeset
|
1518 // codec RM22 revision 2. |
638415aafbda
Limit the Rice parameter used for progressive decoding in ALS.
thilo.borgmann
parents:
11157
diff
changeset
|
1519 ctx->s_max = sconf->resolution > 1 ? 31 : 15; |
638415aafbda
Limit the Rice parameter used for progressive decoding in ALS.
thilo.borgmann
parents:
11157
diff
changeset
|
1520 |
10530
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
1521 // set lag value for long-term prediction |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
1522 ctx->ltp_lag_length = 8 + (avctx->sample_rate >= 96000) + |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
1523 (avctx->sample_rate >= 192000); |
d428e57f14c6
Add long-term prediction to the ALS decoder.
thilo.borgmann
parents:
10524
diff
changeset
|
1524 |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1525 // allocate quantized parcor coefficient buffer |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1526 num_buffers = sconf->mc_coding ? avctx->channels : 1; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1527 |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1528 ctx->quant_cof = av_malloc(sizeof(*ctx->quant_cof) * num_buffers); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1529 ctx->lpc_cof = av_malloc(sizeof(*ctx->lpc_cof) * num_buffers); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1530 ctx->quant_cof_buffer = av_malloc(sizeof(*ctx->quant_cof_buffer) * |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1531 num_buffers * sconf->max_order); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1532 ctx->lpc_cof_buffer = av_malloc(sizeof(*ctx->lpc_cof_buffer) * |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1533 num_buffers * sconf->max_order); |
10860
c9fb5b89e47a
Replace variable length array with an allocated buffer
thilo.borgmann
parents:
10823
diff
changeset
|
1534 ctx->lpc_cof_reversed_buffer = av_malloc(sizeof(*ctx->lpc_cof_buffer) * |
c9fb5b89e47a
Replace variable length array with an allocated buffer
thilo.borgmann
parents:
10823
diff
changeset
|
1535 sconf->max_order); |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1536 |
10861 | 1537 if (!ctx->quant_cof || !ctx->lpc_cof || |
1538 !ctx->quant_cof_buffer || !ctx->lpc_cof_buffer || | |
10860
c9fb5b89e47a
Replace variable length array with an allocated buffer
thilo.borgmann
parents:
10823
diff
changeset
|
1539 !ctx->lpc_cof_reversed_buffer) { |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1540 av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n"); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1541 return AVERROR(ENOMEM); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1542 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1543 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1544 // assign quantized parcor coefficient buffers |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1545 for (c = 0; c < num_buffers; c++) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1546 ctx->quant_cof[c] = ctx->quant_cof_buffer + c * sconf->max_order; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1547 ctx->lpc_cof[c] = ctx->lpc_cof_buffer + c * sconf->max_order; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1548 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1549 |
10681
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1550 // allocate and assign lag and gain data buffer for ltp mode |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1551 ctx->use_ltp = av_mallocz(sizeof(*ctx->use_ltp) * num_buffers); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1552 ctx->ltp_lag = av_malloc (sizeof(*ctx->ltp_lag) * num_buffers); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1553 ctx->ltp_gain = av_malloc (sizeof(*ctx->ltp_gain) * num_buffers); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1554 ctx->ltp_gain_buffer = av_malloc (sizeof(*ctx->ltp_gain_buffer) * |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1555 num_buffers * 5); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1556 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1557 if (!ctx->use_ltp || !ctx->ltp_lag || |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1558 !ctx->ltp_gain || !ctx->ltp_gain_buffer) { |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1559 av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n"); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1560 decode_end(avctx); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1561 return AVERROR(ENOMEM); |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1562 } |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1563 |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1564 for (c = 0; c < num_buffers; c++) |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1565 ctx->ltp_gain[c] = ctx->ltp_gain_buffer + c * 5; |
997692df50c1
Read and decode block data in separate functions to prepare support for
thilo.borgmann
parents:
10535
diff
changeset
|
1566 |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1567 // allocate and assign channel data buffer for mcc mode |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1568 if (sconf->mc_coding) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1569 ctx->chan_data_buffer = av_malloc(sizeof(*ctx->chan_data_buffer) * |
11198
00854e4457f2
Fix wrong buffer allocation for MCC in ALS.
thilo.borgmann
parents:
11189
diff
changeset
|
1570 num_buffers * num_buffers); |
11199
f1b38a8588b2
Fix sizeof()-statement to use the actual pointer type.
thilo.borgmann
parents:
11198
diff
changeset
|
1571 ctx->chan_data = av_malloc(sizeof(*ctx->chan_data) * |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1572 num_buffers); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1573 ctx->reverted_channels = av_malloc(sizeof(*ctx->reverted_channels) * |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1574 num_buffers); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1575 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1576 if (!ctx->chan_data_buffer || !ctx->chan_data || !ctx->reverted_channels) { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1577 av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n"); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1578 decode_end(avctx); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1579 return AVERROR(ENOMEM); |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1580 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1581 |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1582 for (c = 0; c < num_buffers; c++) |
11198
00854e4457f2
Fix wrong buffer allocation for MCC in ALS.
thilo.borgmann
parents:
11189
diff
changeset
|
1583 ctx->chan_data[c] = ctx->chan_data_buffer + c * num_buffers; |
10802
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1584 } else { |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1585 ctx->chan_data = NULL; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1586 ctx->chan_data_buffer = NULL; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1587 ctx->reverted_channels = NULL; |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1588 } |
4f614b69b4e5
Add multi-channel correlation support for ALS.
thilo.borgmann
parents:
10800
diff
changeset
|
1589 |
10522 | 1590 avctx->frame_size = sconf->frame_length; |
1591 channel_size = sconf->frame_length + sconf->max_order; | |
1592 | |
1593 ctx->prev_raw_samples = av_malloc (sizeof(*ctx->prev_raw_samples) * sconf->max_order); | |
1594 ctx->raw_buffer = av_mallocz(sizeof(*ctx-> raw_buffer) * avctx->channels * channel_size); | |
1595 ctx->raw_samples = av_malloc (sizeof(*ctx-> raw_samples) * avctx->channels); | |
1596 | |
1597 // allocate previous raw sample buffer | |
1598 if (!ctx->prev_raw_samples || !ctx->raw_buffer|| !ctx->raw_samples) { | |
1599 av_log(avctx, AV_LOG_ERROR, "Allocating buffer memory failed.\n"); | |
1600 decode_end(avctx); | |
1601 return AVERROR(ENOMEM); | |
1602 } | |
1603 | |
1604 // assign raw samples buffers | |
1605 ctx->raw_samples[0] = ctx->raw_buffer + sconf->max_order; | |
1606 for (c = 1; c < avctx->channels; c++) | |
1607 ctx->raw_samples[c] = ctx->raw_samples[c - 1] + channel_size; | |
1608 | |
1609 return 0; | |
1610 } | |
1611 | |
1612 | |
1613 /** Flushes (resets) the frame ID after seeking. | |
1614 */ | |
1615 static av_cold void flush(AVCodecContext *avctx) | |
1616 { | |
1617 ALSDecContext *ctx = avctx->priv_data; | |
1618 | |
1619 ctx->frame_id = 0; | |
1620 } | |
1621 | |
1622 | |
1623 AVCodec als_decoder = { | |
1624 "als", | |
1625 CODEC_TYPE_AUDIO, | |
1626 CODEC_ID_MP4ALS, | |
1627 sizeof(ALSDecContext), | |
1628 decode_init, | |
1629 NULL, | |
1630 decode_end, | |
1631 decode_frame, | |
1632 .flush = flush, | |
1633 .capabilities = CODEC_CAP_SUBFRAMES, | |
1634 .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 Audio Lossless Coding (ALS)"), | |
1635 }; | |
1636 |