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