Mercurial > libavcodec.hg
annotate rv34.c @ 11352:6e0af2cfdcfe libavcodec
Do MC and IDCT in coding (hilbert) order
This increases the slice size to 64 pixels, due to having to decode an
entire chroma superblock row per slice.
This can be up to 6% slower depending on clip and CPU, but is necessary
for future optimizations that gain significantly more than was lost.
author | conrad |
---|---|
date | Wed, 03 Mar 2010 23:27:40 +0000 |
parents | 93f1f9d9d847 |
children | da870c6f71ce |
rev | line source |
---|---|
6026 | 1 /* |
2 * RV30/40 decoder common data | |
3 * Copyright (c) 2007 Mike Melanson, Konstantin Shishkov | |
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 /** | |
8718
e9d9d946f213
Use full internal pathname in doxygen @file directives.
diego
parents:
8693
diff
changeset
|
23 * @file libavcodec/rv34.c |
6026 | 24 * RV30/40 decoder common data |
25 */ | |
26 | |
27 #include "avcodec.h" | |
28 #include "dsputil.h" | |
29 #include "mpegvideo.h" | |
30 #include "golomb.h" | |
8627
d6bab465b82c
moves mid_pred() into mathops.h (with arch specific code split by directory)
aurel
parents:
8504
diff
changeset
|
31 #include "mathops.h" |
6026 | 32 #include "rectangle.h" |
33 | |
34 #include "rv34vlc.h" | |
35 #include "rv34data.h" | |
36 #include "rv34.h" | |
37 | |
38 //#define DEBUG | |
39 | |
10120 | 40 static inline void ZERO8x2(void* dst, int stride) |
41 { | |
42 fill_rectangle(dst, 1, 2, stride, 0, 4); | |
43 fill_rectangle(((uint8_t*)(dst))+4, 1, 2, stride, 0, 4); | |
44 } | |
10118
4dafbd9c8918
Zeroing pic->motion_val in RV3/4 causes alignment problems on some 64-bit
kostya
parents:
10117
diff
changeset
|
45 |
6026 | 46 /** translation of RV30/40 macroblock types to lavc ones */ |
47 static const int rv34_mb_type_to_lavc[12] = { | |
48 MB_TYPE_INTRA, | |
8036
9b98b2261938
Mark some of RV3/4 block types as having separate DC subblock
kostya
parents:
6750
diff
changeset
|
49 MB_TYPE_INTRA16x16 | MB_TYPE_SEPARATE_DC, |
6026 | 50 MB_TYPE_16x16 | MB_TYPE_L0, |
51 MB_TYPE_8x8 | MB_TYPE_L0, | |
52 MB_TYPE_16x16 | MB_TYPE_L0, | |
53 MB_TYPE_16x16 | MB_TYPE_L1, | |
54 MB_TYPE_SKIP, | |
55 MB_TYPE_DIRECT2 | MB_TYPE_16x16, | |
56 MB_TYPE_16x8 | MB_TYPE_L0, | |
57 MB_TYPE_8x16 | MB_TYPE_L0, | |
58 MB_TYPE_16x16 | MB_TYPE_L0L1, | |
8036
9b98b2261938
Mark some of RV3/4 block types as having separate DC subblock
kostya
parents:
6750
diff
changeset
|
59 MB_TYPE_16x16 | MB_TYPE_L0 | MB_TYPE_SEPARATE_DC |
6026 | 60 }; |
61 | |
62 | |
63 static RV34VLC intra_vlcs[NUM_INTRA_TABLES], inter_vlcs[NUM_INTER_TABLES]; | |
64 | |
65 /** | |
66 * @defgroup vlc RV30/40 VLC generating functions | |
67 * @{ | |
68 */ | |
69 | |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
70 static const int table_offs[] = { |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
71 0, 1818, 3622, 4144, 4698, 5234, 5804, 5868, 5900, 5932, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
72 5996, 6252, 6316, 6348, 6380, 7674, 8944, 10274, 11668, 12250, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
73 14060, 15846, 16372, 16962, 17512, 18148, 18180, 18212, 18244, 18308, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
74 18564, 18628, 18660, 18692, 20036, 21314, 22648, 23968, 24614, 26384, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
75 28190, 28736, 29366, 29938, 30608, 30640, 30672, 30704, 30768, 31024, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
76 31088, 31120, 31184, 32570, 33898, 35236, 36644, 37286, 39020, 40802, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
77 41368, 42052, 42692, 43348, 43380, 43412, 43444, 43476, 43604, 43668, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
78 43700, 43732, 45100, 46430, 47778, 49160, 49802, 51550, 53340, 53972, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
79 54648, 55348, 55994, 56122, 56154, 56186, 56218, 56346, 56410, 56442, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
80 56474, 57878, 59290, 60636, 62036, 62682, 64460, 64524, 64588, 64716, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
81 64844, 66076, 67466, 67978, 68542, 69064, 69648, 70296, 72010, 72074, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
82 72138, 72202, 72330, 73572, 74936, 75454, 76030, 76566, 77176, 77822, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
83 79582, 79646, 79678, 79742, 79870, 81180, 82536, 83064, 83672, 84242, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
84 84934, 85576, 87384, 87448, 87480, 87544, 87672, 88982, 90340, 90902, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
85 91598, 92182, 92846, 93488, 95246, 95278, 95310, 95374, 95502, 96878, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
86 98266, 98848, 99542, 100234, 100884, 101524, 103320, 103352, 103384, 103416, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
87 103480, 104874, 106222, 106910, 107584, 108258, 108902, 109544, 111366, 111398, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
88 111430, 111462, 111494, 112878, 114320, 114988, 115660, 116310, 116950, 117592 |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
89 }; |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
90 |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
91 static VLC_TYPE table_data[117592][2]; |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
92 |
6026 | 93 /** |
94 * Generate VLC from codeword lengths. | |
95 * @param bits codeword lengths (zeroes are accepted) | |
96 * @param size length of input data | |
8684 | 97 * @param vlc output VLC |
6026 | 98 * @param insyms symbols for input codes (NULL for default ones) |
9520
c9c23894f4ae
Make RV3/4 VLC tables use new static initialization method
kostya
parents:
9355
diff
changeset
|
99 * @param num VLC table number (for static initialization) |
6026 | 100 */ |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
101 static void rv34_gen_vlc(const uint8_t *bits, int size, VLC *vlc, const uint8_t *insyms, |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
102 const int num) |
6026 | 103 { |
104 int i; | |
105 int counts[17] = {0}, codes[17]; | |
106 uint16_t cw[size], syms[size]; | |
107 uint8_t bits2[size]; | |
108 int maxbits = 0, realsize = 0; | |
109 | |
110 for(i = 0; i < size; i++){ | |
111 if(bits[i]){ | |
112 bits2[realsize] = bits[i]; | |
113 syms[realsize] = insyms ? insyms[i] : i; | |
114 realsize++; | |
115 maxbits = FFMAX(maxbits, bits[i]); | |
116 counts[bits[i]]++; | |
117 } | |
118 } | |
119 | |
120 codes[0] = 0; | |
121 for(i = 0; i < 16; i++) | |
122 codes[i+1] = (codes[i] + counts[i]) << 1; | |
123 for(i = 0; i < realsize; i++) | |
124 cw[i] = codes[bits2[i]]++; | |
125 | |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
126 vlc->table = &table_data[table_offs[num]]; |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
127 vlc->table_allocated = table_offs[num + 1] - table_offs[num]; |
6026 | 128 init_vlc_sparse(vlc, FFMIN(maxbits, 9), realsize, |
129 bits2, 1, 1, | |
130 cw, 2, 2, | |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
131 syms, 2, 2, INIT_VLC_USE_NEW_STATIC); |
6026 | 132 } |
133 | |
134 /** | |
135 * Initialize all tables. | |
136 */ | |
8693
18737839ed27
Add missing void keyword to parameterless function declarations.
diego
parents:
8684
diff
changeset
|
137 static av_cold void rv34_init_tables(void) |
6026 | 138 { |
139 int i, j, k; | |
140 | |
141 for(i = 0; i < NUM_INTRA_TABLES; i++){ | |
142 for(j = 0; j < 2; j++){ | |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
143 rv34_gen_vlc(rv34_table_intra_cbppat [i][j], CBPPAT_VLC_SIZE, &intra_vlcs[i].cbppattern[j], NULL, 19*i + 0 + j); |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
144 rv34_gen_vlc(rv34_table_intra_secondpat[i][j], OTHERBLK_VLC_SIZE, &intra_vlcs[i].second_pattern[j], NULL, 19*i + 2 + j); |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
145 rv34_gen_vlc(rv34_table_intra_thirdpat [i][j], OTHERBLK_VLC_SIZE, &intra_vlcs[i].third_pattern[j], NULL, 19*i + 4 + j); |
9520
c9c23894f4ae
Make RV3/4 VLC tables use new static initialization method
kostya
parents:
9355
diff
changeset
|
146 for(k = 0; k < 4; k++){ |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
147 rv34_gen_vlc(rv34_table_intra_cbp[i][j+k*2], CBP_VLC_SIZE, &intra_vlcs[i].cbp[j][k], rv34_cbp_code, 19*i + 6 + j*4 + k); |
9520
c9c23894f4ae
Make RV3/4 VLC tables use new static initialization method
kostya
parents:
9355
diff
changeset
|
148 } |
6026 | 149 } |
9520
c9c23894f4ae
Make RV3/4 VLC tables use new static initialization method
kostya
parents:
9355
diff
changeset
|
150 for(j = 0; j < 4; j++){ |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
151 rv34_gen_vlc(rv34_table_intra_firstpat[i][j], FIRSTBLK_VLC_SIZE, &intra_vlcs[i].first_pattern[j], NULL, 19*i + 14 + j); |
9520
c9c23894f4ae
Make RV3/4 VLC tables use new static initialization method
kostya
parents:
9355
diff
changeset
|
152 } |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
153 rv34_gen_vlc(rv34_intra_coeff[i], COEFF_VLC_SIZE, &intra_vlcs[i].coefficient, NULL, 19*i + 18); |
6026 | 154 } |
155 | |
156 for(i = 0; i < NUM_INTER_TABLES; i++){ | |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
157 rv34_gen_vlc(rv34_inter_cbppat[i], CBPPAT_VLC_SIZE, &inter_vlcs[i].cbppattern[0], NULL, i*12 + 95); |
9520
c9c23894f4ae
Make RV3/4 VLC tables use new static initialization method
kostya
parents:
9355
diff
changeset
|
158 for(j = 0; j < 4; j++){ |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
159 rv34_gen_vlc(rv34_inter_cbp[i][j], CBP_VLC_SIZE, &inter_vlcs[i].cbp[0][j], rv34_cbp_code, i*12 + 96 + j); |
9520
c9c23894f4ae
Make RV3/4 VLC tables use new static initialization method
kostya
parents:
9355
diff
changeset
|
160 } |
6026 | 161 for(j = 0; j < 2; j++){ |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
162 rv34_gen_vlc(rv34_table_inter_firstpat [i][j], FIRSTBLK_VLC_SIZE, &inter_vlcs[i].first_pattern[j], NULL, i*12 + 100 + j); |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
163 rv34_gen_vlc(rv34_table_inter_secondpat[i][j], OTHERBLK_VLC_SIZE, &inter_vlcs[i].second_pattern[j], NULL, i*12 + 102 + j); |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
164 rv34_gen_vlc(rv34_table_inter_thirdpat [i][j], OTHERBLK_VLC_SIZE, &inter_vlcs[i].third_pattern[j], NULL, i*12 + 104 + j); |
6026 | 165 } |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
166 rv34_gen_vlc(rv34_inter_coeff[i], COEFF_VLC_SIZE, &inter_vlcs[i].coefficient, NULL, i*12 + 106); |
6026 | 167 } |
168 } | |
169 | |
170 /** @} */ // vlc group | |
171 | |
172 | |
173 /** | |
174 * @defgroup transform RV30/40 inverse transform functions | |
175 * @{ | |
176 */ | |
177 | |
178 static av_always_inline void rv34_row_transform(int temp[16], DCTELEM *block) | |
179 { | |
180 int i; | |
181 | |
182 for(i=0; i<4; i++){ | |
183 const int z0= 13*(block[i+8*0] + block[i+8*2]); | |
184 const int z1= 13*(block[i+8*0] - block[i+8*2]); | |
185 const int z2= 7* block[i+8*1] - 17*block[i+8*3]; | |
186 const int z3= 17* block[i+8*1] + 7*block[i+8*3]; | |
187 | |
188 temp[4*i+0]= z0+z3; | |
189 temp[4*i+1]= z1+z2; | |
190 temp[4*i+2]= z1-z2; | |
191 temp[4*i+3]= z0-z3; | |
192 } | |
193 } | |
194 | |
195 /** | |
196 * Real Video 3.0/4.0 inverse transform | |
197 * Code is almost the same as in SVQ3, only scaling is different. | |
198 */ | |
199 static void rv34_inv_transform(DCTELEM *block){ | |
200 int temp[16]; | |
201 int i; | |
202 | |
203 rv34_row_transform(temp, block); | |
204 | |
205 for(i=0; i<4; i++){ | |
206 const int z0= 13*(temp[4*0+i] + temp[4*2+i]) + 0x200; | |
207 const int z1= 13*(temp[4*0+i] - temp[4*2+i]) + 0x200; | |
208 const int z2= 7* temp[4*1+i] - 17*temp[4*3+i]; | |
209 const int z3= 17* temp[4*1+i] + 7*temp[4*3+i]; | |
210 | |
211 block[i*8+0]= (z0 + z3)>>10; | |
212 block[i*8+1]= (z1 + z2)>>10; | |
213 block[i*8+2]= (z1 - z2)>>10; | |
214 block[i*8+3]= (z0 - z3)>>10; | |
215 } | |
216 | |
217 } | |
218 | |
219 /** | |
220 * RealVideo 3.0/4.0 inverse transform for DC block | |
221 * | |
222 * Code is almost the same as rv34_inv_transform() | |
223 * but final coefficients are multiplied by 1.5 and have no rounding. | |
224 */ | |
225 static void rv34_inv_transform_noround(DCTELEM *block){ | |
226 int temp[16]; | |
227 int i; | |
228 | |
229 rv34_row_transform(temp, block); | |
230 | |
231 for(i=0; i<4; i++){ | |
232 const int z0= 13*(temp[4*0+i] + temp[4*2+i]); | |
233 const int z1= 13*(temp[4*0+i] - temp[4*2+i]); | |
234 const int z2= 7* temp[4*1+i] - 17*temp[4*3+i]; | |
235 const int z3= 17* temp[4*1+i] + 7*temp[4*3+i]; | |
236 | |
237 block[i*8+0]= ((z0 + z3)*3)>>11; | |
238 block[i*8+1]= ((z1 + z2)*3)>>11; | |
239 block[i*8+2]= ((z1 - z2)*3)>>11; | |
240 block[i*8+3]= ((z0 - z3)*3)>>11; | |
241 } | |
242 | |
243 } | |
244 | |
245 /** @} */ // transform | |
246 | |
247 | |
248 /** | |
249 * @defgroup block RV30/40 4x4 block decoding functions | |
250 * @{ | |
251 */ | |
252 | |
253 /** | |
254 * Decode coded block pattern. | |
255 */ | |
256 static int rv34_decode_cbp(GetBitContext *gb, RV34VLC *vlc, int table) | |
257 { | |
258 int pattern, code, cbp=0; | |
259 int ones; | |
260 static const int cbp_masks[3] = {0x100000, 0x010000, 0x110000}; | |
261 static const int shifts[4] = { 0, 2, 8, 10 }; | |
8721
42e258f2b931
Silence two pointer assignment compiler warnings in rv34.c
kostya
parents:
8718
diff
changeset
|
262 const int *curshift = shifts; |
6026 | 263 int i, t, mask; |
264 | |
265 code = get_vlc2(gb, vlc->cbppattern[table].table, 9, 2); | |
266 pattern = code & 0xF; | |
267 code >>= 4; | |
268 | |
269 ones = rv34_count_ones[pattern]; | |
270 | |
271 for(mask = 8; mask; mask >>= 1, curshift++){ | |
272 if(pattern & mask) | |
273 cbp |= get_vlc2(gb, vlc->cbp[table][ones].table, vlc->cbp[table][ones].bits, 1) << curshift[0]; | |
274 } | |
275 | |
276 for(i = 0; i < 4; i++){ | |
277 t = modulo_three_table[code][i]; | |
278 if(t == 1) | |
279 cbp |= cbp_masks[get_bits1(gb)] << i; | |
280 if(t == 2) | |
281 cbp |= cbp_masks[2] << i; | |
282 } | |
283 return cbp; | |
284 } | |
285 | |
286 /** | |
287 * Get one coefficient value from the bistream and store it. | |
288 */ | |
289 static inline void decode_coeff(DCTELEM *dst, int coef, int esc, GetBitContext *gb, VLC* vlc) | |
290 { | |
291 if(coef){ | |
292 if(coef == esc){ | |
293 coef = get_vlc2(gb, vlc->table, 9, 2); | |
294 if(coef > 23){ | |
295 coef -= 23; | |
296 coef = 22 + ((1 << coef) | get_bits(gb, coef)); | |
297 } | |
298 coef += esc; | |
299 } | |
300 if(get_bits1(gb)) | |
301 coef = -coef; | |
302 *dst = coef; | |
303 } | |
304 } | |
305 | |
306 /** | |
307 * Decode 2x2 subblock of coefficients. | |
308 */ | |
309 static inline void decode_subblock(DCTELEM *dst, int code, const int is_block2, GetBitContext *gb, VLC *vlc) | |
310 { | |
311 int coeffs[4]; | |
312 | |
313 coeffs[0] = modulo_three_table[code][0]; | |
314 coeffs[1] = modulo_three_table[code][1]; | |
315 coeffs[2] = modulo_three_table[code][2]; | |
316 coeffs[3] = modulo_three_table[code][3]; | |
317 decode_coeff(dst , coeffs[0], 3, gb, vlc); | |
318 if(is_block2){ | |
319 decode_coeff(dst+8, coeffs[1], 2, gb, vlc); | |
320 decode_coeff(dst+1, coeffs[2], 2, gb, vlc); | |
321 }else{ | |
322 decode_coeff(dst+1, coeffs[1], 2, gb, vlc); | |
323 decode_coeff(dst+8, coeffs[2], 2, gb, vlc); | |
324 } | |
325 decode_coeff(dst+9, coeffs[3], 2, gb, vlc); | |
326 } | |
327 | |
328 /** | |
329 * Decode coefficients for 4x4 block. | |
330 * | |
331 * This is done by filling 2x2 subblocks with decoded coefficients | |
332 * in this order (the same for subblocks and subblock coefficients): | |
333 * o--o | |
334 * / | |
335 * / | |
336 * o--o | |
337 */ | |
338 | |
339 static inline void rv34_decode_block(DCTELEM *dst, GetBitContext *gb, RV34VLC *rvlc, int fc, int sc) | |
340 { | |
341 int code, pattern; | |
342 | |
343 code = get_vlc2(gb, rvlc->first_pattern[fc].table, 9, 2); | |
344 | |
345 pattern = code & 0x7; | |
346 | |
347 code >>= 3; | |
348 decode_subblock(dst, code, 0, gb, &rvlc->coefficient); | |
349 | |
350 if(pattern & 4){ | |
351 code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2); | |
352 decode_subblock(dst + 2, code, 0, gb, &rvlc->coefficient); | |
353 } | |
354 if(pattern & 2){ // Looks like coefficients 1 and 2 are swapped for this block | |
355 code = get_vlc2(gb, rvlc->second_pattern[sc].table, 9, 2); | |
356 decode_subblock(dst + 8*2, code, 1, gb, &rvlc->coefficient); | |
357 } | |
358 if(pattern & 1){ | |
359 code = get_vlc2(gb, rvlc->third_pattern[sc].table, 9, 2); | |
360 decode_subblock(dst + 8*2+2, code, 0, gb, &rvlc->coefficient); | |
361 } | |
362 | |
363 } | |
364 | |
365 /** | |
366 * Dequantize ordinary 4x4 block. | |
367 * @todo optimize | |
368 */ | |
369 static inline void rv34_dequant4x4(DCTELEM *block, int Qdc, int Q) | |
370 { | |
371 int i, j; | |
372 | |
373 block[0] = (block[0] * Qdc + 8) >> 4; | |
374 for(i = 0; i < 4; i++) | |
375 for(j = !i; j < 4; j++) | |
376 block[j + i*8] = (block[j + i*8] * Q + 8) >> 4; | |
377 } | |
378 | |
379 /** | |
380 * Dequantize 4x4 block of DC values for 16x16 macroblock. | |
381 * @todo optimize | |
382 */ | |
383 static inline void rv34_dequant4x4_16x16(DCTELEM *block, int Qdc, int Q) | |
384 { | |
385 int i; | |
386 | |
387 for(i = 0; i < 3; i++) | |
388 block[rv34_dezigzag[i]] = (block[rv34_dezigzag[i]] * Qdc + 8) >> 4; | |
389 for(; i < 16; i++) | |
390 block[rv34_dezigzag[i]] = (block[rv34_dezigzag[i]] * Q + 8) >> 4; | |
391 } | |
392 /** @} */ //block functions | |
393 | |
394 | |
395 /** | |
396 * @defgroup bitstream RV30/40 bitstream parsing | |
397 * @{ | |
398 */ | |
399 | |
400 /** | |
401 * Decode starting slice position. | |
402 * @todo Maybe replace with ff_h263_decode_mba() ? | |
403 */ | |
404 int ff_rv34_get_start_offset(GetBitContext *gb, int mb_size) | |
405 { | |
406 int i; | |
407 for(i = 0; i < 5; i++) | |
8445
8621deaff8dc
352l: correct calculating number of bits for storing macroblock offset in RV3/4
kostya
parents:
8371
diff
changeset
|
408 if(rv34_mb_max_sizes[i] >= mb_size - 1) |
6026 | 409 break; |
410 return rv34_mb_bits_sizes[i]; | |
411 } | |
412 | |
413 /** | |
414 * Select VLC set for decoding from current quantizer, modifier and frame type. | |
415 */ | |
416 static inline RV34VLC* choose_vlc_set(int quant, int mod, int type) | |
417 { | |
418 if(mod == 2 && quant < 19) quant += 10; | |
419 else if(mod && quant < 26) quant += 5; | |
420 return type ? &inter_vlcs[rv34_quant_to_vlc_set[1][av_clip(quant, 0, 30)]] | |
421 : &intra_vlcs[rv34_quant_to_vlc_set[0][av_clip(quant, 0, 30)]]; | |
422 } | |
423 | |
424 /** | |
425 * Decode quantizer difference and return modified quantizer. | |
426 */ | |
427 static inline int rv34_decode_dquant(GetBitContext *gb, int quant) | |
428 { | |
429 if(get_bits1(gb)) | |
430 return rv34_dquant_tab[get_bits1(gb)][quant]; | |
431 else | |
432 return get_bits(gb, 5); | |
433 } | |
434 | |
435 /** @} */ //bitstream functions | |
436 | |
437 /** | |
438 * @defgroup mv motion vector related code (prediction, reconstruction, motion compensation) | |
439 * @{ | |
440 */ | |
441 | |
442 /** macroblock partition width in 8x8 blocks */ | |
443 static const uint8_t part_sizes_w[RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2 }; | |
444 | |
445 /** macroblock partition height in 8x8 blocks */ | |
446 static const uint8_t part_sizes_h[RV34_MB_TYPES] = { 2, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2 }; | |
447 | |
448 /** availability index for subblocks */ | |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
449 static const uint8_t avail_indexes[4] = { 6, 7, 10, 11 }; |
6026 | 450 |
451 /** | |
452 * motion vector prediction | |
453 * | |
454 * Motion prediction performed for the block by using median prediction of | |
455 * motion vectors from the left, top and right top blocks but in corner cases | |
456 * some other vectors may be used instead. | |
457 */ | |
458 static void rv34_pred_mv(RV34DecContext *r, int block_type, int subblock_no, int dmv_no) | |
459 { | |
460 MpegEncContext *s = &r->s; | |
461 int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride; | |
462 int A[2] = {0}, B[2], C[2]; | |
463 int i, j; | |
464 int mx, my; | |
465 int avail_index = avail_indexes[subblock_no]; | |
466 int c_off = part_sizes_w[block_type]; | |
467 | |
468 mv_pos += (subblock_no & 1) + (subblock_no >> 1)*s->b8_stride; | |
469 if(subblock_no == 3) | |
470 c_off = -1; | |
471 | |
472 if(r->avail_cache[avail_index - 1]){ | |
473 A[0] = s->current_picture_ptr->motion_val[0][mv_pos-1][0]; | |
474 A[1] = s->current_picture_ptr->motion_val[0][mv_pos-1][1]; | |
475 } | |
476 if(r->avail_cache[avail_index - 4]){ | |
477 B[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride][0]; | |
478 B[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride][1]; | |
479 }else{ | |
480 B[0] = A[0]; | |
481 B[1] = A[1]; | |
482 } | |
483 if(!r->avail_cache[avail_index - 4 + c_off]){ | |
484 if(r->avail_cache[avail_index - 4] && (r->avail_cache[avail_index - 1] || r->rv30)){ | |
485 C[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride-1][0]; | |
486 C[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride-1][1]; | |
487 }else{ | |
488 C[0] = A[0]; | |
489 C[1] = A[1]; | |
490 } | |
491 }else{ | |
492 C[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride+c_off][0]; | |
493 C[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride+c_off][1]; | |
494 } | |
495 mx = mid_pred(A[0], B[0], C[0]); | |
496 my = mid_pred(A[1], B[1], C[1]); | |
497 mx += r->dmv[dmv_no][0]; | |
498 my += r->dmv[dmv_no][1]; | |
499 for(j = 0; j < part_sizes_h[block_type]; j++){ | |
500 for(i = 0; i < part_sizes_w[block_type]; i++){ | |
501 s->current_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][0] = mx; | |
502 s->current_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][1] = my; | |
503 } | |
504 } | |
505 } | |
506 | |
6714
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
507 #define GET_PTS_DIFF(a, b) ((a - b + 8192) & 0x1FFF) |
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
508 |
6026 | 509 /** |
6096
89140b93ae09
Direct blocks should use motion vectors from the second reference frame
kostya
parents:
6036
diff
changeset
|
510 * Calculate motion vector component that should be added for direct blocks. |
89140b93ae09
Direct blocks should use motion vectors from the second reference frame
kostya
parents:
6036
diff
changeset
|
511 */ |
6714
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
512 static int calc_add_mv(RV34DecContext *r, int dir, int val) |
6096
89140b93ae09
Direct blocks should use motion vectors from the second reference frame
kostya
parents:
6036
diff
changeset
|
513 { |
6714
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
514 int refdist = GET_PTS_DIFF(r->next_pts, r->last_pts); |
8086
ae146e429003
Correct motion vector scaling in B-frames for RV3/4
kostya
parents:
8074
diff
changeset
|
515 int dist = dir ? -GET_PTS_DIFF(r->next_pts, r->cur_pts) : GET_PTS_DIFF(r->cur_pts, r->last_pts); |
ae146e429003
Correct motion vector scaling in B-frames for RV3/4
kostya
parents:
8074
diff
changeset
|
516 int mul; |
6096
89140b93ae09
Direct blocks should use motion vectors from the second reference frame
kostya
parents:
6036
diff
changeset
|
517 |
6714
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
518 if(!refdist) return 0; |
8086
ae146e429003
Correct motion vector scaling in B-frames for RV3/4
kostya
parents:
8074
diff
changeset
|
519 mul = (dist << 14) / refdist; |
ae146e429003
Correct motion vector scaling in B-frames for RV3/4
kostya
parents:
8074
diff
changeset
|
520 return (val * mul + 0x2000) >> 14; |
6096
89140b93ae09
Direct blocks should use motion vectors from the second reference frame
kostya
parents:
6036
diff
changeset
|
521 } |
89140b93ae09
Direct blocks should use motion vectors from the second reference frame
kostya
parents:
6036
diff
changeset
|
522 |
89140b93ae09
Direct blocks should use motion vectors from the second reference frame
kostya
parents:
6036
diff
changeset
|
523 /** |
6026 | 524 * Predict motion vector for B-frame macroblock. |
525 */ | |
526 static inline void rv34_pred_b_vector(int A[2], int B[2], int C[2], | |
527 int A_avail, int B_avail, int C_avail, | |
528 int *mx, int *my) | |
529 { | |
530 if(A_avail + B_avail + C_avail != 3){ | |
531 *mx = A[0] + B[0] + C[0]; | |
532 *my = A[1] + B[1] + C[1]; | |
533 if(A_avail + B_avail + C_avail == 2){ | |
534 *mx /= 2; | |
535 *my /= 2; | |
536 } | |
537 }else{ | |
538 *mx = mid_pred(A[0], B[0], C[0]); | |
539 *my = mid_pred(A[1], B[1], C[1]); | |
540 } | |
541 } | |
542 | |
543 /** | |
544 * motion vector prediction for B-frames | |
545 */ | |
546 static void rv34_pred_mv_b(RV34DecContext *r, int block_type, int dir) | |
547 { | |
548 MpegEncContext *s = &r->s; | |
549 int mb_pos = s->mb_x + s->mb_y * s->mb_stride; | |
550 int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride; | |
551 int A[2], B[2], C[2]; | |
552 int has_A = 0, has_B = 0, has_C = 0; | |
553 int mx, my; | |
554 int i, j; | |
555 Picture *cur_pic = s->current_picture_ptr; | |
556 const int mask = dir ? MB_TYPE_L1 : MB_TYPE_L0; | |
557 int type = cur_pic->mb_type[mb_pos]; | |
558 | |
559 memset(A, 0, sizeof(A)); | |
560 memset(B, 0, sizeof(B)); | |
561 memset(C, 0, sizeof(C)); | |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
562 if((r->avail_cache[6-1] & type) & mask){ |
6026 | 563 A[0] = cur_pic->motion_val[dir][mv_pos - 1][0]; |
564 A[1] = cur_pic->motion_val[dir][mv_pos - 1][1]; | |
565 has_A = 1; | |
566 } | |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
567 if((r->avail_cache[6-4] & type) & mask){ |
6026 | 568 B[0] = cur_pic->motion_val[dir][mv_pos - s->b8_stride][0]; |
569 B[1] = cur_pic->motion_val[dir][mv_pos - s->b8_stride][1]; | |
570 has_B = 1; | |
571 } | |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
572 if(r->avail_cache[6-4] && (r->avail_cache[6-2] & type) & mask){ |
6026 | 573 C[0] = cur_pic->motion_val[dir][mv_pos - s->b8_stride + 2][0]; |
574 C[1] = cur_pic->motion_val[dir][mv_pos - s->b8_stride + 2][1]; | |
575 has_C = 1; | |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
576 }else if((s->mb_x+1) == s->mb_width && (r->avail_cache[6-5] & type) & mask){ |
6026 | 577 C[0] = cur_pic->motion_val[dir][mv_pos - s->b8_stride - 1][0]; |
578 C[1] = cur_pic->motion_val[dir][mv_pos - s->b8_stride - 1][1]; | |
579 has_C = 1; | |
580 } | |
581 | |
582 rv34_pred_b_vector(A, B, C, has_A, has_B, has_C, &mx, &my); | |
583 | |
584 mx += r->dmv[dir][0]; | |
585 my += r->dmv[dir][1]; | |
6096
89140b93ae09
Direct blocks should use motion vectors from the second reference frame
kostya
parents:
6036
diff
changeset
|
586 |
6026 | 587 for(j = 0; j < 2; j++){ |
588 for(i = 0; i < 2; i++){ | |
589 cur_pic->motion_val[dir][mv_pos + i + j*s->b8_stride][0] = mx; | |
590 cur_pic->motion_val[dir][mv_pos + i + j*s->b8_stride][1] = my; | |
591 } | |
592 } | |
10118
4dafbd9c8918
Zeroing pic->motion_val in RV3/4 causes alignment problems on some 64-bit
kostya
parents:
10117
diff
changeset
|
593 if(block_type == RV34_MB_B_BACKWARD || block_type == RV34_MB_B_FORWARD){ |
4dafbd9c8918
Zeroing pic->motion_val in RV3/4 causes alignment problems on some 64-bit
kostya
parents:
10117
diff
changeset
|
594 ZERO8x2(cur_pic->motion_val[!dir][mv_pos], s->b8_stride); |
4dafbd9c8918
Zeroing pic->motion_val in RV3/4 causes alignment problems on some 64-bit
kostya
parents:
10117
diff
changeset
|
595 } |
6026 | 596 } |
597 | |
8099 | 598 /** |
599 * motion vector prediction - RV3 version | |
600 */ | |
601 static void rv34_pred_mv_rv3(RV34DecContext *r, int block_type, int dir) | |
602 { | |
603 MpegEncContext *s = &r->s; | |
604 int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride; | |
605 int A[2] = {0}, B[2], C[2]; | |
8504
3bfb7a2ea222
It turned out that RV30 uses motion vectors for forward motion B-frame
kostya
parents:
8445
diff
changeset
|
606 int i, j, k; |
8099 | 607 int mx, my; |
608 int avail_index = avail_indexes[0]; | |
609 | |
610 if(r->avail_cache[avail_index - 1]){ | |
611 A[0] = s->current_picture_ptr->motion_val[0][mv_pos-1][0]; | |
612 A[1] = s->current_picture_ptr->motion_val[0][mv_pos-1][1]; | |
613 } | |
614 if(r->avail_cache[avail_index - 4]){ | |
615 B[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride][0]; | |
616 B[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride][1]; | |
617 }else{ | |
618 B[0] = A[0]; | |
619 B[1] = A[1]; | |
620 } | |
621 if(!r->avail_cache[avail_index - 4 + 2]){ | |
622 if(r->avail_cache[avail_index - 4] && (r->avail_cache[avail_index - 1])){ | |
623 C[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride-1][0]; | |
624 C[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride-1][1]; | |
625 }else{ | |
626 C[0] = A[0]; | |
627 C[1] = A[1]; | |
628 } | |
629 }else{ | |
630 C[0] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride+2][0]; | |
631 C[1] = s->current_picture_ptr->motion_val[0][mv_pos-s->b8_stride+2][1]; | |
632 } | |
633 mx = mid_pred(A[0], B[0], C[0]); | |
634 my = mid_pred(A[1], B[1], C[1]); | |
635 mx += r->dmv[0][0]; | |
636 my += r->dmv[0][1]; | |
637 for(j = 0; j < 2; j++){ | |
638 for(i = 0; i < 2; i++){ | |
8504
3bfb7a2ea222
It turned out that RV30 uses motion vectors for forward motion B-frame
kostya
parents:
8445
diff
changeset
|
639 for(k = 0; k < 2; k++){ |
3bfb7a2ea222
It turned out that RV30 uses motion vectors for forward motion B-frame
kostya
parents:
8445
diff
changeset
|
640 s->current_picture_ptr->motion_val[k][mv_pos + i + j*s->b8_stride][0] = mx; |
3bfb7a2ea222
It turned out that RV30 uses motion vectors for forward motion B-frame
kostya
parents:
8445
diff
changeset
|
641 s->current_picture_ptr->motion_val[k][mv_pos + i + j*s->b8_stride][1] = my; |
3bfb7a2ea222
It turned out that RV30 uses motion vectors for forward motion B-frame
kostya
parents:
8445
diff
changeset
|
642 } |
8099 | 643 } |
644 } | |
645 } | |
646 | |
8074 | 647 static const int chroma_coeffs[3] = { 0, 3, 5 }; |
6106 | 648 |
6026 | 649 /** |
650 * generic motion compensation function | |
651 * | |
652 * @param r decoder context | |
653 * @param block_type type of the current block | |
654 * @param xoff horizontal offset from the start of the current block | |
655 * @param yoff vertical offset from the start of the current block | |
656 * @param mv_off offset to the motion vector information | |
657 * @param width width of the current partition in 8x8 blocks | |
658 * @param height height of the current partition in 8x8 blocks | |
8684 | 659 * @param dir motion compensation direction (i.e. from the last or the next reference frame) |
660 * @param thirdpel motion vectors are specified in 1/3 of pixel | |
661 * @param qpel_mc a set of functions used to perform luma motion compensation | |
662 * @param chroma_mc a set of functions used to perform chroma motion compensation | |
6026 | 663 */ |
664 static inline void rv34_mc(RV34DecContext *r, const int block_type, | |
665 const int xoff, const int yoff, int mv_off, | |
666 const int width, const int height, int dir, | |
667 const int thirdpel, | |
668 qpel_mc_func (*qpel_mc)[16], | |
669 h264_chroma_mc_func (*chroma_mc)) | |
670 { | |
671 MpegEncContext *s = &r->s; | |
672 uint8_t *Y, *U, *V, *srcY, *srcU, *srcV; | |
8074 | 673 int dxy, mx, my, umx, umy, lx, ly, uvmx, uvmy, src_x, src_y, uvsrc_x, uvsrc_y; |
6026 | 674 int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride + mv_off; |
675 int is16x16 = 1; | |
676 | |
677 if(thirdpel){ | |
8074 | 678 int chroma_mx, chroma_my; |
6106 | 679 mx = (s->current_picture_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) / 3 - (1 << 24); |
680 my = (s->current_picture_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) / 3 - (1 << 24); | |
681 lx = (s->current_picture_ptr->motion_val[dir][mv_pos][0] + (3 << 24)) % 3; | |
682 ly = (s->current_picture_ptr->motion_val[dir][mv_pos][1] + (3 << 24)) % 3; | |
8074 | 683 chroma_mx = (s->current_picture_ptr->motion_val[dir][mv_pos][0] + 1) >> 1; |
684 chroma_my = (s->current_picture_ptr->motion_val[dir][mv_pos][1] + 1) >> 1; | |
685 umx = (chroma_mx + (3 << 24)) / 3 - (1 << 24); | |
686 umy = (chroma_my + (3 << 24)) / 3 - (1 << 24); | |
687 uvmx = chroma_coeffs[(chroma_mx + (3 << 24)) % 3]; | |
688 uvmy = chroma_coeffs[(chroma_my + (3 << 24)) % 3]; | |
6026 | 689 }else{ |
8221 | 690 int cx, cy; |
6026 | 691 mx = s->current_picture_ptr->motion_val[dir][mv_pos][0] >> 2; |
692 my = s->current_picture_ptr->motion_val[dir][mv_pos][1] >> 2; | |
6121
bc59962f70b9
Fractional parts of motion vectors should be accounted separately too
kostya
parents:
6106
diff
changeset
|
693 lx = s->current_picture_ptr->motion_val[dir][mv_pos][0] & 3; |
bc59962f70b9
Fractional parts of motion vectors should be accounted separately too
kostya
parents:
6106
diff
changeset
|
694 ly = s->current_picture_ptr->motion_val[dir][mv_pos][1] & 3; |
8221 | 695 cx = s->current_picture_ptr->motion_val[dir][mv_pos][0] / 2; |
696 cy = s->current_picture_ptr->motion_val[dir][mv_pos][1] / 2; | |
697 umx = cx >> 2; | |
698 umy = cy >> 2; | |
699 uvmx = (cx & 3) << 1; | |
700 uvmy = (cy & 3) << 1; | |
701 //due to some flaw RV40 uses the same MC compensation routine for H2V2 and H3V3 | |
702 if(uvmx == 6 && uvmy == 6) | |
703 uvmx = uvmy = 4; | |
6026 | 704 } |
6121
bc59962f70b9
Fractional parts of motion vectors should be accounted separately too
kostya
parents:
6106
diff
changeset
|
705 dxy = ly*4 + lx; |
6026 | 706 srcY = dir ? s->next_picture_ptr->data[0] : s->last_picture_ptr->data[0]; |
707 srcU = dir ? s->next_picture_ptr->data[1] : s->last_picture_ptr->data[1]; | |
708 srcV = dir ? s->next_picture_ptr->data[2] : s->last_picture_ptr->data[2]; | |
709 src_x = s->mb_x * 16 + xoff + mx; | |
710 src_y = s->mb_y * 16 + yoff + my; | |
8074 | 711 uvsrc_x = s->mb_x * 8 + (xoff >> 1) + umx; |
712 uvsrc_y = s->mb_y * 8 + (yoff >> 1) + umy; | |
6026 | 713 srcY += src_y * s->linesize + src_x; |
714 srcU += uvsrc_y * s->uvlinesize + uvsrc_x; | |
715 srcV += uvsrc_y * s->uvlinesize + uvsrc_x; | |
8179 | 716 if( (unsigned)(src_x - !!lx*2) > s->h_edge_pos - !!lx*2 - (width <<3) - 4 |
717 || (unsigned)(src_y - !!ly*2) > s->v_edge_pos - !!ly*2 - (height<<3) - 4){ | |
718 uint8_t *uvbuf= s->edge_emu_buffer + 22 * s->linesize; | |
6026 | 719 |
720 srcY -= 2 + 2*s->linesize; | |
8179 | 721 ff_emulated_edge_mc(s->edge_emu_buffer, srcY, s->linesize, (width<<3)+6, (height<<3)+6, |
6026 | 722 src_x - 2, src_y - 2, s->h_edge_pos, s->v_edge_pos); |
723 srcY = s->edge_emu_buffer + 2 + 2*s->linesize; | |
724 ff_emulated_edge_mc(uvbuf , srcU, s->uvlinesize, (width<<2)+1, (height<<2)+1, | |
725 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1); | |
726 ff_emulated_edge_mc(uvbuf + 16, srcV, s->uvlinesize, (width<<2)+1, (height<<2)+1, | |
727 uvsrc_x, uvsrc_y, s->h_edge_pos >> 1, s->v_edge_pos >> 1); | |
728 srcU = uvbuf; | |
729 srcV = uvbuf + 16; | |
730 } | |
731 Y = s->dest[0] + xoff + yoff *s->linesize; | |
732 U = s->dest[1] + (xoff>>1) + (yoff>>1)*s->uvlinesize; | |
733 V = s->dest[2] + (xoff>>1) + (yoff>>1)*s->uvlinesize; | |
734 | |
735 if(block_type == RV34_MB_P_16x8){ | |
736 qpel_mc[1][dxy](Y, srcY, s->linesize); | |
737 Y += 8; | |
738 srcY += 8; | |
739 }else if(block_type == RV34_MB_P_8x16){ | |
740 qpel_mc[1][dxy](Y, srcY, s->linesize); | |
741 Y += 8 * s->linesize; | |
742 srcY += 8 * s->linesize; | |
743 } | |
744 is16x16 = (block_type != RV34_MB_P_8x8) && (block_type != RV34_MB_P_16x8) && (block_type != RV34_MB_P_8x16); | |
745 qpel_mc[!is16x16][dxy](Y, srcY, s->linesize); | |
746 chroma_mc[2-width] (U, srcU, s->uvlinesize, height*4, uvmx, uvmy); | |
747 chroma_mc[2-width] (V, srcV, s->uvlinesize, height*4, uvmx, uvmy); | |
748 } | |
749 | |
750 static void rv34_mc_1mv(RV34DecContext *r, const int block_type, | |
751 const int xoff, const int yoff, int mv_off, | |
752 const int width, const int height, int dir) | |
753 { | |
754 rv34_mc(r, block_type, xoff, yoff, mv_off, width, height, dir, r->rv30, | |
6106 | 755 r->rv30 ? r->s.dsp.put_rv30_tpel_pixels_tab |
8221 | 756 : r->s.dsp.put_rv40_qpel_pixels_tab, |
757 r->rv30 ? r->s.dsp.put_h264_chroma_pixels_tab | |
758 : r->s.dsp.put_rv40_chroma_pixels_tab); | |
6026 | 759 } |
760 | |
761 static void rv34_mc_2mv(RV34DecContext *r, const int block_type) | |
762 { | |
763 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 0, r->rv30, | |
6106 | 764 r->rv30 ? r->s.dsp.put_rv30_tpel_pixels_tab |
8221 | 765 : r->s.dsp.put_rv40_qpel_pixels_tab, |
8244
3f3d653fb46d
34l: forgot to change one case of chroma MC for RV40
kostya
parents:
8243
diff
changeset
|
766 r->rv30 ? r->s.dsp.put_h264_chroma_pixels_tab |
3f3d653fb46d
34l: forgot to change one case of chroma MC for RV40
kostya
parents:
8243
diff
changeset
|
767 : r->s.dsp.put_rv40_chroma_pixels_tab); |
6026 | 768 rv34_mc(r, block_type, 0, 0, 0, 2, 2, 1, r->rv30, |
6106 | 769 r->rv30 ? r->s.dsp.avg_rv30_tpel_pixels_tab |
8221 | 770 : r->s.dsp.avg_rv40_qpel_pixels_tab, |
771 r->rv30 ? r->s.dsp.avg_h264_chroma_pixels_tab | |
772 : r->s.dsp.avg_rv40_chroma_pixels_tab); | |
6026 | 773 } |
774 | |
6693
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
775 static void rv34_mc_2mv_skip(RV34DecContext *r) |
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
776 { |
8128 | 777 int i, j; |
6693
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
778 for(j = 0; j < 2; j++) |
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
779 for(i = 0; i < 2; i++){ |
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
780 rv34_mc(r, RV34_MB_P_8x8, i*8, j*8, i+j*r->s.b8_stride, 1, 1, 0, r->rv30, |
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
781 r->rv30 ? r->s.dsp.put_rv30_tpel_pixels_tab |
8221 | 782 : r->s.dsp.put_rv40_qpel_pixels_tab, |
783 r->rv30 ? r->s.dsp.put_h264_chroma_pixels_tab | |
784 : r->s.dsp.put_rv40_chroma_pixels_tab); | |
6693
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
785 rv34_mc(r, RV34_MB_P_8x8, i*8, j*8, i+j*r->s.b8_stride, 1, 1, 1, r->rv30, |
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
786 r->rv30 ? r->s.dsp.avg_rv30_tpel_pixels_tab |
8221 | 787 : r->s.dsp.avg_rv40_qpel_pixels_tab, |
788 r->rv30 ? r->s.dsp.avg_h264_chroma_pixels_tab | |
789 : r->s.dsp.avg_rv40_chroma_pixels_tab); | |
6693
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
790 } |
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
791 } |
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
792 |
6026 | 793 /** number of motion vectors in each macroblock type */ |
794 static const int num_mvs[RV34_MB_TYPES] = { 0, 0, 1, 4, 1, 1, 0, 0, 2, 2, 2, 1 }; | |
795 | |
796 /** | |
797 * Decode motion vector differences | |
798 * and perform motion vector reconstruction and motion compensation. | |
799 */ | |
800 static int rv34_decode_mv(RV34DecContext *r, int block_type) | |
801 { | |
802 MpegEncContext *s = &r->s; | |
803 GetBitContext *gb = &s->gb; | |
6714
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
804 int i, j, k, l; |
6693
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
805 int mv_pos = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride; |
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
806 int next_bt; |
6026 | 807 |
808 memset(r->dmv, 0, sizeof(r->dmv)); | |
809 for(i = 0; i < num_mvs[block_type]; i++){ | |
810 r->dmv[i][0] = svq3_get_se_golomb(gb); | |
811 r->dmv[i][1] = svq3_get_se_golomb(gb); | |
812 } | |
813 switch(block_type){ | |
814 case RV34_MB_TYPE_INTRA: | |
815 case RV34_MB_TYPE_INTRA16x16: | |
10118
4dafbd9c8918
Zeroing pic->motion_val in RV3/4 causes alignment problems on some 64-bit
kostya
parents:
10117
diff
changeset
|
816 ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride); |
6026 | 817 return 0; |
818 case RV34_MB_SKIP: | |
6481 | 819 if(s->pict_type == FF_P_TYPE){ |
10118
4dafbd9c8918
Zeroing pic->motion_val in RV3/4 causes alignment problems on some 64-bit
kostya
parents:
10117
diff
changeset
|
820 ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride); |
6026 | 821 rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, 0); |
822 break; | |
823 } | |
824 case RV34_MB_B_DIRECT: | |
6693
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
825 //surprisingly, it uses motion scheme from next reference frame |
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
826 next_bt = s->next_picture_ptr->mb_type[s->mb_x + s->mb_y * s->mb_stride]; |
9162 | 827 if(IS_INTRA(next_bt) || IS_SKIP(next_bt)){ |
10118
4dafbd9c8918
Zeroing pic->motion_val in RV3/4 causes alignment problems on some 64-bit
kostya
parents:
10117
diff
changeset
|
828 ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride); |
4dafbd9c8918
Zeroing pic->motion_val in RV3/4 causes alignment problems on some 64-bit
kostya
parents:
10117
diff
changeset
|
829 ZERO8x2(s->current_picture_ptr->motion_val[1][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride); |
9162 | 830 }else |
9041 | 831 for(j = 0; j < 2; j++) |
832 for(i = 0; i < 2; i++) | |
833 for(k = 0; k < 2; k++) | |
834 for(l = 0; l < 2; l++) | |
835 s->current_picture_ptr->motion_val[l][mv_pos + i + j*s->b8_stride][k] = calc_add_mv(r, l, s->next_picture_ptr->motion_val[0][mv_pos + i + j*s->b8_stride][k]); | |
9162 | 836 if(!(IS_16X8(next_bt) || IS_8X16(next_bt) || IS_8X8(next_bt))) //we can use whole macroblock MC |
6693
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
837 rv34_mc_2mv(r, block_type); |
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
838 else |
6f13852a9161
Skip blocks in B-frames reuse motion vectors from next reference frame.
kostya
parents:
6517
diff
changeset
|
839 rv34_mc_2mv_skip(r); |
10118
4dafbd9c8918
Zeroing pic->motion_val in RV3/4 causes alignment problems on some 64-bit
kostya
parents:
10117
diff
changeset
|
840 ZERO8x2(s->current_picture_ptr->motion_val[0][s->mb_x * 2 + s->mb_y * 2 * s->b8_stride], s->b8_stride); |
6026 | 841 break; |
842 case RV34_MB_P_16x16: | |
843 case RV34_MB_P_MIX16x16: | |
844 rv34_pred_mv(r, block_type, 0, 0); | |
845 rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, 0); | |
846 break; | |
847 case RV34_MB_B_FORWARD: | |
848 case RV34_MB_B_BACKWARD: | |
849 r->dmv[1][0] = r->dmv[0][0]; | |
850 r->dmv[1][1] = r->dmv[0][1]; | |
8099 | 851 if(r->rv30) |
852 rv34_pred_mv_rv3(r, block_type, block_type == RV34_MB_B_BACKWARD); | |
853 else | |
854 rv34_pred_mv_b (r, block_type, block_type == RV34_MB_B_BACKWARD); | |
6026 | 855 rv34_mc_1mv (r, block_type, 0, 0, 0, 2, 2, block_type == RV34_MB_B_BACKWARD); |
856 break; | |
857 case RV34_MB_P_16x8: | |
858 case RV34_MB_P_8x16: | |
859 rv34_pred_mv(r, block_type, 0, 0); | |
860 rv34_pred_mv(r, block_type, 1 + (block_type == RV34_MB_P_16x8), 1); | |
861 if(block_type == RV34_MB_P_16x8){ | |
862 rv34_mc_1mv(r, block_type, 0, 0, 0, 2, 1, 0); | |
863 rv34_mc_1mv(r, block_type, 0, 8, s->b8_stride, 2, 1, 0); | |
864 } | |
865 if(block_type == RV34_MB_P_8x16){ | |
866 rv34_mc_1mv(r, block_type, 0, 0, 0, 1, 2, 0); | |
867 rv34_mc_1mv(r, block_type, 8, 0, 1, 1, 2, 0); | |
868 } | |
869 break; | |
870 case RV34_MB_B_BIDIR: | |
871 rv34_pred_mv_b (r, block_type, 0); | |
872 rv34_pred_mv_b (r, block_type, 1); | |
873 rv34_mc_2mv (r, block_type); | |
874 break; | |
875 case RV34_MB_P_8x8: | |
876 for(i=0;i< 4;i++){ | |
877 rv34_pred_mv(r, block_type, i, i); | |
878 rv34_mc_1mv (r, block_type, (i&1)<<3, (i&2)<<2, (i&1)+(i>>1)*s->b8_stride, 1, 1, 0); | |
879 } | |
880 break; | |
881 } | |
882 | |
883 return 0; | |
884 } | |
885 /** @} */ // mv group | |
886 | |
887 /** | |
888 * @defgroup recons Macroblock reconstruction functions | |
889 * @{ | |
890 */ | |
891 /** mapping of RV30/40 intra prediction types to standard H.264 types */ | |
892 static const int ittrans[9] = { | |
893 DC_PRED, VERT_PRED, HOR_PRED, DIAG_DOWN_RIGHT_PRED, DIAG_DOWN_LEFT_PRED, | |
894 VERT_RIGHT_PRED, VERT_LEFT_PRED, HOR_UP_PRED, HOR_DOWN_PRED, | |
895 }; | |
896 | |
897 /** mapping of RV30/40 intra 16x16 prediction types to standard H.264 types */ | |
898 static const int ittrans16[4] = { | |
899 DC_PRED8x8, VERT_PRED8x8, HOR_PRED8x8, PLANE_PRED8x8, | |
900 }; | |
901 | |
902 /** | |
903 * Perform 4x4 intra prediction. | |
904 */ | |
905 static void rv34_pred_4x4_block(RV34DecContext *r, uint8_t *dst, int stride, int itype, int up, int left, int down, int right) | |
906 { | |
907 uint8_t *prev = dst - stride + 4; | |
908 uint32_t topleft; | |
909 | |
910 if(!up && !left) | |
911 itype = DC_128_PRED; | |
912 else if(!up){ | |
913 if(itype == VERT_PRED) itype = HOR_PRED; | |
914 if(itype == DC_PRED) itype = LEFT_DC_PRED; | |
915 }else if(!left){ | |
916 if(itype == HOR_PRED) itype = VERT_PRED; | |
917 if(itype == DC_PRED) itype = TOP_DC_PRED; | |
918 if(itype == DIAG_DOWN_LEFT_PRED) itype = DIAG_DOWN_LEFT_PRED_RV40_NODOWN; | |
919 } | |
920 if(!down){ | |
921 if(itype == DIAG_DOWN_LEFT_PRED) itype = DIAG_DOWN_LEFT_PRED_RV40_NODOWN; | |
922 if(itype == HOR_UP_PRED) itype = HOR_UP_PRED_RV40_NODOWN; | |
6036
ce3b68242317
Correct spatial prediction mode in RV30/40 for vertical left direction
kostya
parents:
6026
diff
changeset
|
923 if(itype == VERT_LEFT_PRED) itype = VERT_LEFT_PRED_RV40_NODOWN; |
6026 | 924 } |
925 if(!right && up){ | |
926 topleft = dst[-stride + 3] * 0x01010101; | |
8721
42e258f2b931
Silence two pointer assignment compiler warnings in rv34.c
kostya
parents:
8718
diff
changeset
|
927 prev = (uint8_t*)&topleft; |
6026 | 928 } |
929 r->h.pred4x4[itype](dst, prev, stride); | |
930 } | |
931 | |
932 /** add_pixels_clamped for 4x4 block */ | |
933 static void rv34_add_4x4_block(uint8_t *dst, int stride, DCTELEM block[64], int off) | |
934 { | |
935 int x, y; | |
936 for(y = 0; y < 4; y++) | |
937 for(x = 0; x < 4; x++) | |
938 dst[x + y*stride] = av_clip_uint8(dst[x + y*stride] + block[off + x+y*8]); | |
939 } | |
940 | |
941 static inline int adjust_pred16(int itype, int up, int left) | |
942 { | |
943 if(!up && !left) | |
944 itype = DC_128_PRED8x8; | |
945 else if(!up){ | |
946 if(itype == PLANE_PRED8x8)itype = HOR_PRED8x8; | |
947 if(itype == VERT_PRED8x8) itype = HOR_PRED8x8; | |
948 if(itype == DC_PRED8x8) itype = LEFT_DC_PRED8x8; | |
949 }else if(!left){ | |
950 if(itype == PLANE_PRED8x8)itype = VERT_PRED8x8; | |
951 if(itype == HOR_PRED8x8) itype = VERT_PRED8x8; | |
952 if(itype == DC_PRED8x8) itype = TOP_DC_PRED8x8; | |
953 } | |
954 return itype; | |
955 } | |
956 | |
957 static void rv34_output_macroblock(RV34DecContext *r, int8_t *intra_types, int cbp, int is16) | |
958 { | |
959 MpegEncContext *s = &r->s; | |
960 DSPContext *dsp = &s->dsp; | |
961 int i, j; | |
962 uint8_t *Y, *U, *V; | |
963 int itype; | |
964 int avail[6*8] = {0}; | |
965 int idx; | |
966 | |
967 // Set neighbour information. | |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
968 if(r->avail_cache[1]) |
6026 | 969 avail[0] = 1; |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
970 if(r->avail_cache[2]) |
6026 | 971 avail[1] = avail[2] = 1; |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
972 if(r->avail_cache[3]) |
6026 | 973 avail[3] = avail[4] = 1; |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
974 if(r->avail_cache[4]) |
6026 | 975 avail[5] = 1; |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
976 if(r->avail_cache[5]) |
6026 | 977 avail[8] = avail[16] = 1; |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
978 if(r->avail_cache[9]) |
6026 | 979 avail[24] = avail[32] = 1; |
980 | |
981 Y = s->dest[0]; | |
982 U = s->dest[1]; | |
983 V = s->dest[2]; | |
984 if(!is16){ | |
985 for(j = 0; j < 4; j++){ | |
986 idx = 9 + j*8; | |
987 for(i = 0; i < 4; i++, cbp >>= 1, Y += 4, idx++){ | |
988 rv34_pred_4x4_block(r, Y, s->linesize, ittrans[intra_types[i]], avail[idx-8], avail[idx-1], avail[idx+7], avail[idx-7]); | |
989 avail[idx] = 1; | |
990 if(cbp & 1) | |
991 rv34_add_4x4_block(Y, s->linesize, s->block[(i>>1)+(j&2)], (i&1)*4+(j&1)*32); | |
992 } | |
993 Y += s->linesize * 4 - 4*4; | |
9903
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
994 intra_types += r->intra_types_stride; |
6026 | 995 } |
9903
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
996 intra_types -= r->intra_types_stride * 4; |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
997 fill_rectangle(r->avail_cache + 6, 2, 2, 4, 0, 4); |
6026 | 998 for(j = 0; j < 2; j++){ |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
999 idx = 6 + j*4; |
6026 | 1000 for(i = 0; i < 2; i++, cbp >>= 1, idx++){ |
9903
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1001 rv34_pred_4x4_block(r, U + i*4 + j*4*s->uvlinesize, s->uvlinesize, ittrans[intra_types[i*2+j*2*r->intra_types_stride]], r->avail_cache[idx-4], r->avail_cache[idx-1], !i && !j, r->avail_cache[idx-3]); |
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1002 rv34_pred_4x4_block(r, V + i*4 + j*4*s->uvlinesize, s->uvlinesize, ittrans[intra_types[i*2+j*2*r->intra_types_stride]], r->avail_cache[idx-4], r->avail_cache[idx-1], !i && !j, r->avail_cache[idx-3]); |
6026 | 1003 r->avail_cache[idx] = 1; |
1004 if(cbp & 0x01) | |
1005 rv34_add_4x4_block(U + i*4 + j*4*s->uvlinesize, s->uvlinesize, s->block[4], i*4+j*32); | |
1006 if(cbp & 0x10) | |
1007 rv34_add_4x4_block(V + i*4 + j*4*s->uvlinesize, s->uvlinesize, s->block[5], i*4+j*32); | |
1008 } | |
1009 } | |
1010 }else{ | |
1011 itype = ittrans16[intra_types[0]]; | |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
1012 itype = adjust_pred16(itype, r->avail_cache[6-4], r->avail_cache[6-1]); |
6026 | 1013 r->h.pred16x16[itype](Y, s->linesize); |
8180
f4a291734ad7
Eliminate direct use of s->current_picture in RV30/40 decoder
kostya
parents:
8179
diff
changeset
|
1014 dsp->add_pixels_clamped(s->block[0], Y, s->linesize); |
f4a291734ad7
Eliminate direct use of s->current_picture in RV30/40 decoder
kostya
parents:
8179
diff
changeset
|
1015 dsp->add_pixels_clamped(s->block[1], Y + 8, s->linesize); |
f4a291734ad7
Eliminate direct use of s->current_picture in RV30/40 decoder
kostya
parents:
8179
diff
changeset
|
1016 Y += s->linesize * 8; |
f4a291734ad7
Eliminate direct use of s->current_picture in RV30/40 decoder
kostya
parents:
8179
diff
changeset
|
1017 dsp->add_pixels_clamped(s->block[2], Y, s->linesize); |
f4a291734ad7
Eliminate direct use of s->current_picture in RV30/40 decoder
kostya
parents:
8179
diff
changeset
|
1018 dsp->add_pixels_clamped(s->block[3], Y + 8, s->linesize); |
6026 | 1019 |
1020 itype = ittrans16[intra_types[0]]; | |
1021 if(itype == PLANE_PRED8x8) itype = DC_PRED8x8; | |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
1022 itype = adjust_pred16(itype, r->avail_cache[6-4], r->avail_cache[6-1]); |
6026 | 1023 r->h.pred8x8[itype](U, s->uvlinesize); |
1024 dsp->add_pixels_clamped(s->block[4], U, s->uvlinesize); | |
1025 r->h.pred8x8[itype](V, s->uvlinesize); | |
1026 dsp->add_pixels_clamped(s->block[5], V, s->uvlinesize); | |
1027 } | |
1028 } | |
1029 | |
1030 /** @} */ // recons group | |
1031 | |
1032 /** | |
1033 * @addtogroup bitstream | |
1034 * Decode macroblock header and return CBP in case of success, -1 otherwise. | |
1035 */ | |
1036 static int rv34_decode_mb_header(RV34DecContext *r, int8_t *intra_types) | |
1037 { | |
1038 MpegEncContext *s = &r->s; | |
1039 GetBitContext *gb = &s->gb; | |
1040 int mb_pos = s->mb_x + s->mb_y * s->mb_stride; | |
1041 int i, t; | |
1042 | |
1043 if(!r->si.type){ | |
1044 r->is16 = get_bits1(gb); | |
1045 if(!r->is16 && !r->rv30){ | |
1046 if(!get_bits1(gb)) | |
1047 av_log(s->avctx, AV_LOG_ERROR, "Need DQUANT\n"); | |
1048 } | |
1049 s->current_picture_ptr->mb_type[mb_pos] = r->is16 ? MB_TYPE_INTRA16x16 : MB_TYPE_INTRA; | |
1050 r->block_type = r->is16 ? RV34_MB_TYPE_INTRA16x16 : RV34_MB_TYPE_INTRA; | |
1051 }else{ | |
1052 r->block_type = r->decode_mb_info(r); | |
1053 if(r->block_type == -1) | |
1054 return -1; | |
1055 s->current_picture_ptr->mb_type[mb_pos] = rv34_mb_type_to_lavc[r->block_type]; | |
1056 r->mb_type[mb_pos] = r->block_type; | |
1057 if(r->block_type == RV34_MB_SKIP){ | |
6481 | 1058 if(s->pict_type == FF_P_TYPE) |
6026 | 1059 r->mb_type[mb_pos] = RV34_MB_P_16x16; |
6481 | 1060 if(s->pict_type == FF_B_TYPE) |
6026 | 1061 r->mb_type[mb_pos] = RV34_MB_B_DIRECT; |
1062 } | |
1063 r->is16 = !!IS_INTRA16x16(s->current_picture_ptr->mb_type[mb_pos]); | |
1064 rv34_decode_mv(r, r->block_type); | |
1065 if(r->block_type == RV34_MB_SKIP){ | |
9903
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1066 fill_rectangle(intra_types, 4, 4, r->intra_types_stride, 0, sizeof(intra_types[0])); |
6026 | 1067 return 0; |
1068 } | |
1069 r->chroma_vlc = 1; | |
1070 r->luma_vlc = 0; | |
1071 } | |
1072 if(IS_INTRA(s->current_picture_ptr->mb_type[mb_pos])){ | |
1073 if(r->is16){ | |
1074 t = get_bits(gb, 2); | |
9903
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1075 fill_rectangle(intra_types, 4, 4, r->intra_types_stride, t, sizeof(intra_types[0])); |
6026 | 1076 r->luma_vlc = 2; |
1077 }else{ | |
1078 if(r->decode_intra_types(r, gb, intra_types) < 0) | |
1079 return -1; | |
1080 r->luma_vlc = 1; | |
1081 } | |
1082 r->chroma_vlc = 0; | |
1083 r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0); | |
1084 }else{ | |
1085 for(i = 0; i < 16; i++) | |
9903
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1086 intra_types[(i & 3) + (i>>2) * r->intra_types_stride] = 0; |
6026 | 1087 r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 1); |
1088 if(r->mb_type[mb_pos] == RV34_MB_P_MIX16x16){ | |
1089 r->is16 = 1; | |
1090 r->chroma_vlc = 1; | |
1091 r->luma_vlc = 2; | |
1092 r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 0); | |
1093 } | |
1094 } | |
1095 | |
1096 return rv34_decode_cbp(gb, r->cur_vlcs, r->is16); | |
1097 } | |
1098 | |
1099 /** | |
1100 * @addtogroup recons | |
1101 * @{ | |
1102 */ | |
1103 /** | |
1104 * mask for retrieving all bits in coded block pattern | |
1105 * corresponding to one 8x8 block | |
1106 */ | |
8181
d8f516ca0002
33l Fix applying residue condition in RV30/40 decoder
kostya
parents:
8180
diff
changeset
|
1107 #define LUMA_CBP_BLOCK_MASK 0x33 |
6026 | 1108 |
1109 #define U_CBP_MASK 0x0F0000 | |
1110 #define V_CBP_MASK 0xF00000 | |
1111 | |
1112 | |
1113 static void rv34_apply_differences(RV34DecContext *r, int cbp) | |
1114 { | |
1115 static const int shifts[4] = { 0, 2, 8, 10 }; | |
1116 MpegEncContext *s = &r->s; | |
1117 int i; | |
1118 | |
1119 for(i = 0; i < 4; i++) | |
8181
d8f516ca0002
33l Fix applying residue condition in RV30/40 decoder
kostya
parents:
8180
diff
changeset
|
1120 if((cbp & (LUMA_CBP_BLOCK_MASK << shifts[i])) || r->block_type == RV34_MB_P_MIX16x16) |
6026 | 1121 s->dsp.add_pixels_clamped(s->block[i], s->dest[0] + (i & 1)*8 + (i&2)*4*s->linesize, s->linesize); |
1122 if(cbp & U_CBP_MASK) | |
1123 s->dsp.add_pixels_clamped(s->block[4], s->dest[1], s->uvlinesize); | |
1124 if(cbp & V_CBP_MASK) | |
1125 s->dsp.add_pixels_clamped(s->block[5], s->dest[2], s->uvlinesize); | |
1126 } | |
1127 | |
8116
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1128 static int is_mv_diff_gt_3(int16_t (*motion_val)[2], int step) |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1129 { |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1130 int d; |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1131 d = motion_val[0][0] - motion_val[-step][0]; |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1132 if(d < -3 || d > 3) |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1133 return 1; |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1134 d = motion_val[0][1] - motion_val[-step][1]; |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1135 if(d < -3 || d > 3) |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1136 return 1; |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1137 return 0; |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1138 } |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1139 |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1140 static int rv34_set_deblock_coef(RV34DecContext *r) |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1141 { |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1142 MpegEncContext *s = &r->s; |
8122
aec296246352
Split RV3/4 deblock pattern into horizontal and vertical parts
kostya
parents:
8121
diff
changeset
|
1143 int hmvmask = 0, vmvmask = 0, i, j; |
8116
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1144 int midx = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride; |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1145 int16_t (*motion_val)[2] = s->current_picture_ptr->motion_val[0][midx]; |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1146 for(j = 0; j < 16; j += 8){ |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1147 for(i = 0; i < 2; i++){ |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1148 if(is_mv_diff_gt_3(motion_val + i, 1)) |
8122
aec296246352
Split RV3/4 deblock pattern into horizontal and vertical parts
kostya
parents:
8121
diff
changeset
|
1149 vmvmask |= 0x11 << (j + i*2); |
8245
7e6ca1be9e40
Fix reading out of buffer during RV30/40 deblock mask calculation
kostya
parents:
8244
diff
changeset
|
1150 if((j || s->mb_y) && is_mv_diff_gt_3(motion_val + i, s->b8_stride)) |
8122
aec296246352
Split RV3/4 deblock pattern into horizontal and vertical parts
kostya
parents:
8121
diff
changeset
|
1151 hmvmask |= 0x03 << (j + i*2); |
8116
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1152 } |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1153 motion_val += s->b8_stride; |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1154 } |
8122
aec296246352
Split RV3/4 deblock pattern into horizontal and vertical parts
kostya
parents:
8121
diff
changeset
|
1155 if(s->first_slice_line) |
aec296246352
Split RV3/4 deblock pattern into horizontal and vertical parts
kostya
parents:
8121
diff
changeset
|
1156 hmvmask &= ~0x000F; |
aec296246352
Split RV3/4 deblock pattern into horizontal and vertical parts
kostya
parents:
8121
diff
changeset
|
1157 if(!s->mb_x) |
aec296246352
Split RV3/4 deblock pattern into horizontal and vertical parts
kostya
parents:
8121
diff
changeset
|
1158 vmvmask &= ~0x1111; |
8368 | 1159 if(r->rv30){ //RV30 marks both subblocks on the edge for filtering |
1160 vmvmask |= (vmvmask & 0x4444) >> 1; | |
1161 hmvmask |= (hmvmask & 0x0F00) >> 4; | |
1162 if(s->mb_x) | |
1163 r->deblock_coefs[s->mb_x - 1 + s->mb_y*s->mb_stride] |= (vmvmask & 0x1111) << 3; | |
1164 if(!s->first_slice_line) | |
1165 r->deblock_coefs[s->mb_x + (s->mb_y - 1)*s->mb_stride] |= (hmvmask & 0xF) << 12; | |
1166 } | |
1167 return hmvmask | vmvmask; | |
8116
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1168 } |
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1169 |
6026 | 1170 static int rv34_decode_macroblock(RV34DecContext *r, int8_t *intra_types) |
1171 { | |
1172 MpegEncContext *s = &r->s; | |
1173 GetBitContext *gb = &s->gb; | |
1174 int cbp, cbp2; | |
1175 int i, blknum, blkoff; | |
1176 DCTELEM block16[64]; | |
1177 int luma_dc_quant; | |
1178 int dist; | |
1179 int mb_pos = s->mb_x + s->mb_y * s->mb_stride; | |
1180 | |
1181 // Calculate which neighbours are available. Maybe it's worth optimizing too. | |
1182 memset(r->avail_cache, 0, sizeof(r->avail_cache)); | |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
1183 fill_rectangle(r->avail_cache + 6, 2, 2, 4, 1, 4); |
6026 | 1184 dist = (s->mb_x - s->resync_mb_x) + (s->mb_y - s->resync_mb_y) * s->mb_width; |
1185 if(s->mb_x && dist) | |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
1186 r->avail_cache[5] = |
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
1187 r->avail_cache[9] = s->current_picture_ptr->mb_type[mb_pos - 1]; |
6026 | 1188 if(dist >= s->mb_width) |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
1189 r->avail_cache[2] = |
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
1190 r->avail_cache[3] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride]; |
6026 | 1191 if(((s->mb_x+1) < s->mb_width) && dist >= s->mb_width - 1) |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
1192 r->avail_cache[4] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride + 1]; |
6026 | 1193 if(s->mb_x && dist > s->mb_width) |
10117
d0f2f4e4436c
Adjust r->avail_cache[] indexes to avoid alignment issues when zeroing block
kostya
parents:
9903
diff
changeset
|
1194 r->avail_cache[1] = s->current_picture_ptr->mb_type[mb_pos - s->mb_stride - 1]; |
6026 | 1195 |
1196 s->qscale = r->si.quant; | |
1197 cbp = cbp2 = rv34_decode_mb_header(r, intra_types); | |
8370 | 1198 r->cbp_luma [mb_pos] = cbp; |
1199 r->cbp_chroma[mb_pos] = cbp >> 16; | |
8116
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1200 if(s->pict_type == FF_I_TYPE) |
8369
45c3780b1a96
Merge deblocking pattern with CBP for RV30/40 loop filtering
kostya
parents:
8368
diff
changeset
|
1201 r->deblock_coefs[mb_pos] = 0xFFFF; |
8116
2d01559f824c
Calculating an additional MV-based deblocking pattern is the same
kostya
parents:
8099
diff
changeset
|
1202 else |
8369
45c3780b1a96
Merge deblocking pattern with CBP for RV30/40 loop filtering
kostya
parents:
8368
diff
changeset
|
1203 r->deblock_coefs[mb_pos] = rv34_set_deblock_coef(r) | r->cbp_luma[mb_pos]; |
8370 | 1204 s->current_picture_ptr->qscale_table[mb_pos] = s->qscale; |
6026 | 1205 |
1206 if(cbp == -1) | |
1207 return -1; | |
1208 | |
8046 | 1209 luma_dc_quant = r->block_type == RV34_MB_P_MIX16x16 ? r->luma_dc_quant_p[s->qscale] : r->luma_dc_quant_i[s->qscale]; |
6026 | 1210 if(r->is16){ |
1211 memset(block16, 0, sizeof(block16)); | |
1212 rv34_decode_block(block16, gb, r->cur_vlcs, 3, 0); | |
1213 rv34_dequant4x4_16x16(block16, rv34_qscale_tab[luma_dc_quant],rv34_qscale_tab[s->qscale]); | |
1214 rv34_inv_transform_noround(block16); | |
1215 } | |
1216 | |
1217 for(i = 0; i < 16; i++, cbp >>= 1){ | |
1218 if(!r->is16 && !(cbp & 1)) continue; | |
1219 blknum = ((i & 2) >> 1) + ((i & 8) >> 2); | |
1220 blkoff = ((i & 1) << 2) + ((i & 4) << 3); | |
1221 if(cbp & 1) | |
1222 rv34_decode_block(s->block[blknum] + blkoff, gb, r->cur_vlcs, r->luma_vlc, 0); | |
8046 | 1223 rv34_dequant4x4(s->block[blknum] + blkoff, rv34_qscale_tab[s->qscale],rv34_qscale_tab[s->qscale]); |
6026 | 1224 if(r->is16) //FIXME: optimize |
1225 s->block[blknum][blkoff] = block16[(i & 3) | ((i & 0xC) << 1)]; | |
1226 rv34_inv_transform(s->block[blknum] + blkoff); | |
1227 } | |
1228 if(r->block_type == RV34_MB_P_MIX16x16) | |
1229 r->cur_vlcs = choose_vlc_set(r->si.quant, r->si.vlc_set, 1); | |
1230 for(; i < 24; i++, cbp >>= 1){ | |
1231 if(!(cbp & 1)) continue; | |
1232 blknum = ((i & 4) >> 2) + 4; | |
1233 blkoff = ((i & 1) << 2) + ((i & 2) << 4); | |
1234 rv34_decode_block(s->block[blknum] + blkoff, gb, r->cur_vlcs, r->chroma_vlc, 1); | |
1235 rv34_dequant4x4(s->block[blknum] + blkoff, rv34_qscale_tab[rv34_chroma_quant[1][s->qscale]],rv34_qscale_tab[rv34_chroma_quant[0][s->qscale]]); | |
1236 rv34_inv_transform(s->block[blknum] + blkoff); | |
1237 } | |
8370 | 1238 if(IS_INTRA(s->current_picture_ptr->mb_type[mb_pos])) |
6026 | 1239 rv34_output_macroblock(r, intra_types, cbp2, r->is16); |
1240 else | |
1241 rv34_apply_differences(r, cbp2); | |
1242 | |
1243 return 0; | |
1244 } | |
1245 | |
1246 static int check_slice_end(RV34DecContext *r, MpegEncContext *s) | |
1247 { | |
1248 int bits; | |
1249 if(s->mb_y >= s->mb_height) | |
1250 return 1; | |
1251 if(!s->mb_num_left) | |
1252 return 1; | |
1253 if(r->s.mb_skip_run > 1) | |
1254 return 0; | |
1255 bits = r->bits - get_bits_count(&s->gb); | |
1256 if(bits < 0 || (bits < 8 && !show_bits(&s->gb, bits))) | |
1257 return 1; | |
1258 return 0; | |
1259 } | |
1260 | |
1261 static inline int slice_compare(SliceInfo *si1, SliceInfo *si2) | |
1262 { | |
1263 return si1->type != si2->type || | |
1264 si1->start >= si2->start || | |
1265 si1->width != si2->width || | |
6714
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
1266 si1->height != si2->height|| |
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
1267 si1->pts != si2->pts; |
6026 | 1268 } |
1269 | |
8371
2ebc9b2c7459
add const qualifier to some pointers for input data
kostya
parents:
8370
diff
changeset
|
1270 static int rv34_decode_slice(RV34DecContext *r, int end, const uint8_t* buf, int buf_size) |
6026 | 1271 { |
1272 MpegEncContext *s = &r->s; | |
1273 GetBitContext *gb = &s->gb; | |
1274 int mb_pos; | |
1275 int res; | |
1276 | |
1277 init_get_bits(&r->s.gb, buf, buf_size*8); | |
1278 res = r->parse_slice_header(r, gb, &r->si); | |
1279 if(res < 0){ | |
1280 av_log(s->avctx, AV_LOG_ERROR, "Incorrect or unknown slice header\n"); | |
1281 return -1; | |
1282 } | |
1283 | |
1284 if ((s->mb_x == 0 && s->mb_y == 0) || s->current_picture_ptr==NULL) { | |
1285 if(s->width != r->si.width || s->height != r->si.height){ | |
1286 av_log(s->avctx, AV_LOG_DEBUG, "Changing dimensions to %dx%d\n", r->si.width,r->si.height); | |
1287 MPV_common_end(s); | |
10563
93f1f9d9d847
Call avcodec_set_dimensions() instead of simply setting avctx->width/height
kostya
parents:
10552
diff
changeset
|
1288 s->width = r->si.width; |
93f1f9d9d847
Call avcodec_set_dimensions() instead of simply setting avctx->width/height
kostya
parents:
10552
diff
changeset
|
1289 s->height = r->si.height; |
93f1f9d9d847
Call avcodec_set_dimensions() instead of simply setting avctx->width/height
kostya
parents:
10552
diff
changeset
|
1290 avcodec_set_dimensions(s->avctx, s->width, s->height); |
6026 | 1291 if(MPV_common_init(s) < 0) |
1292 return -1; | |
9903
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1293 r->intra_types_stride = s->mb_width*4 + 4; |
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1294 r->intra_types_hist = av_realloc(r->intra_types_hist, r->intra_types_stride * 4 * 2 * sizeof(*r->intra_types_hist)); |
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1295 r->intra_types = r->intra_types_hist + r->intra_types_stride * 4; |
6026 | 1296 r->mb_type = av_realloc(r->mb_type, r->s.mb_stride * r->s.mb_height * sizeof(*r->mb_type)); |
6155
a425bdc70ac5
Save coded block patterns for future loop filtering.
kostya
parents:
6121
diff
changeset
|
1297 r->cbp_luma = av_realloc(r->cbp_luma, r->s.mb_stride * r->s.mb_height * sizeof(*r->cbp_luma)); |
a425bdc70ac5
Save coded block patterns for future loop filtering.
kostya
parents:
6121
diff
changeset
|
1298 r->cbp_chroma = av_realloc(r->cbp_chroma, r->s.mb_stride * r->s.mb_height * sizeof(*r->cbp_chroma)); |
8037
b6d93bef844a
RV3 and RV4 decoders set some deblocking coefs for each macroblock,
kostya
parents:
8036
diff
changeset
|
1299 r->deblock_coefs = av_realloc(r->deblock_coefs, r->s.mb_stride * r->s.mb_height * sizeof(*r->deblock_coefs)); |
6026 | 1300 } |
6481 | 1301 s->pict_type = r->si.type ? r->si.type : FF_I_TYPE; |
6026 | 1302 if(MPV_frame_start(s, s->avctx) < 0) |
1303 return -1; | |
1304 ff_er_frame_start(s); | |
6714
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
1305 r->cur_pts = r->si.pts; |
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
1306 if(s->pict_type != FF_B_TYPE){ |
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
1307 r->last_pts = r->next_pts; |
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
1308 r->next_pts = r->cur_pts; |
05c3a4b419e9
Calculate motion vector information based on PTS provided in slice header
kostya
parents:
6693
diff
changeset
|
1309 } |
6026 | 1310 s->mb_x = s->mb_y = 0; |
1311 } | |
1312 | |
1313 r->si.end = end; | |
1314 s->qscale = r->si.quant; | |
1315 r->bits = buf_size*8; | |
1316 s->mb_num_left = r->si.end - r->si.start; | |
1317 r->s.mb_skip_run = 0; | |
1318 | |
1319 mb_pos = s->mb_x + s->mb_y * s->mb_width; | |
1320 if(r->si.start != mb_pos){ | |
1321 av_log(s->avctx, AV_LOG_ERROR, "Slice indicates MB offset %d, got %d\n", r->si.start, mb_pos); | |
1322 s->mb_x = r->si.start % s->mb_width; | |
1323 s->mb_y = r->si.start / s->mb_width; | |
1324 } | |
9903
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1325 memset(r->intra_types_hist, -1, r->intra_types_stride * 4 * 2 * sizeof(*r->intra_types_hist)); |
6026 | 1326 s->first_slice_line = 1; |
1327 s->resync_mb_x= s->mb_x; | |
1328 s->resync_mb_y= s->mb_y; | |
1329 | |
1330 ff_init_block_index(s); | |
1331 while(!check_slice_end(r, s)) { | |
1332 ff_update_block_index(s); | |
1333 s->dsp.clear_blocks(s->block[0]); | |
1334 | |
9903
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1335 if(rv34_decode_macroblock(r, r->intra_types + s->mb_x * 4 + 4) < 0){ |
6026 | 1336 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_ERROR|DC_ERROR|MV_ERROR); |
1337 return -1; | |
1338 } | |
1339 if (++s->mb_x == s->mb_width) { | |
1340 s->mb_x = 0; | |
1341 s->mb_y++; | |
1342 ff_init_block_index(s); | |
1343 | |
9903
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1344 memmove(r->intra_types_hist, r->intra_types, r->intra_types_stride * 4 * sizeof(*r->intra_types_hist)); |
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1345 memset(r->intra_types, -1, r->intra_types_stride * 4 * sizeof(*r->intra_types_hist)); |
8224
6771b3544991
Invoke future RV30/40 loop filter for already decoded rows instead of
kostya
parents:
8221
diff
changeset
|
1346 |
6771b3544991
Invoke future RV30/40 loop filter for already decoded rows instead of
kostya
parents:
8221
diff
changeset
|
1347 if(r->loop_filter && s->mb_y >= 2) |
6771b3544991
Invoke future RV30/40 loop filter for already decoded rows instead of
kostya
parents:
8221
diff
changeset
|
1348 r->loop_filter(r, s->mb_y - 2); |
6026 | 1349 } |
1350 if(s->mb_x == s->resync_mb_x) | |
1351 s->first_slice_line=0; | |
1352 s->mb_num_left--; | |
1353 } | |
1354 ff_er_add_slice(s, s->resync_mb_x, s->resync_mb_y, s->mb_x-1, s->mb_y, AC_END|DC_END|MV_END); | |
1355 | |
6750 | 1356 return s->mb_y == s->mb_height; |
6026 | 1357 } |
1358 | |
1359 /** @} */ // recons group end | |
1360 | |
1361 /** | |
1362 * Initialize decoder. | |
1363 */ | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6481
diff
changeset
|
1364 av_cold int ff_rv34_decode_init(AVCodecContext *avctx) |
6026 | 1365 { |
1366 RV34DecContext *r = avctx->priv_data; | |
1367 MpegEncContext *s = &r->s; | |
1368 | |
1369 MPV_decode_defaults(s); | |
1370 s->avctx= avctx; | |
1371 s->out_format = FMT_H263; | |
1372 s->codec_id= avctx->codec_id; | |
1373 | |
1374 s->width = avctx->width; | |
1375 s->height = avctx->height; | |
1376 | |
1377 r->s.avctx = avctx; | |
1378 avctx->flags |= CODEC_FLAG_EMU_EDGE; | |
1379 r->s.flags |= CODEC_FLAG_EMU_EDGE; | |
1380 avctx->pix_fmt = PIX_FMT_YUV420P; | |
1381 avctx->has_b_frames = 1; | |
1382 s->low_delay = 0; | |
1383 | |
1384 if (MPV_common_init(s) < 0) | |
1385 return -1; | |
1386 | |
1387 ff_h264_pred_init(&r->h, CODEC_ID_RV40); | |
1388 | |
9903
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1389 r->intra_types_stride = 4*s->mb_stride + 4; |
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1390 r->intra_types_hist = av_malloc(r->intra_types_stride * 4 * 2 * sizeof(*r->intra_types_hist)); |
305536ce781f
RV3/4 intra types array causes alignment issues (at least on ARM5), thus change
kostya
parents:
9568
diff
changeset
|
1391 r->intra_types = r->intra_types_hist + r->intra_types_stride * 4; |
6026 | 1392 |
1393 r->mb_type = av_mallocz(r->s.mb_stride * r->s.mb_height * sizeof(*r->mb_type)); | |
1394 | |
6155
a425bdc70ac5
Save coded block patterns for future loop filtering.
kostya
parents:
6121
diff
changeset
|
1395 r->cbp_luma = av_malloc(r->s.mb_stride * r->s.mb_height * sizeof(*r->cbp_luma)); |
a425bdc70ac5
Save coded block patterns for future loop filtering.
kostya
parents:
6121
diff
changeset
|
1396 r->cbp_chroma = av_malloc(r->s.mb_stride * r->s.mb_height * sizeof(*r->cbp_chroma)); |
8037
b6d93bef844a
RV3 and RV4 decoders set some deblocking coefs for each macroblock,
kostya
parents:
8036
diff
changeset
|
1397 r->deblock_coefs = av_malloc(r->s.mb_stride * r->s.mb_height * sizeof(*r->deblock_coefs)); |
6155
a425bdc70ac5
Save coded block patterns for future loop filtering.
kostya
parents:
6121
diff
changeset
|
1398 |
9568
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
1399 if(!intra_vlcs[0].cbppattern[0].bits) |
976a7ad342af
Revert changing VLC initialization type for RV3/4 decoder.
kostya
parents:
9554
diff
changeset
|
1400 rv34_init_tables(); |
6026 | 1401 |
1402 return 0; | |
1403 } | |
1404 | |
8371
2ebc9b2c7459
add const qualifier to some pointers for input data
kostya
parents:
8370
diff
changeset
|
1405 static int get_slice_offset(AVCodecContext *avctx, const uint8_t *buf, int n) |
6026 | 1406 { |
1407 if(avctx->slice_count) return avctx->slice_offset[n]; | |
1408 else return AV_RL32(buf + n*8 - 4) == 1 ? AV_RL32(buf + n*8) : AV_RB32(buf + n*8); | |
1409 } | |
1410 | |
1411 int ff_rv34_decode_frame(AVCodecContext *avctx, | |
1412 void *data, int *data_size, | |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9168
diff
changeset
|
1413 AVPacket *avpkt) |
6026 | 1414 { |
9355
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9168
diff
changeset
|
1415 const uint8_t *buf = avpkt->data; |
54bc8a2727b0
Implement avcodec_decode_video2(), _audio3() and _subtitle2() which takes an
rbultje
parents:
9168
diff
changeset
|
1416 int buf_size = avpkt->size; |
6026 | 1417 RV34DecContext *r = avctx->priv_data; |
1418 MpegEncContext *s = &r->s; | |
1419 AVFrame *pict = data; | |
1420 SliceInfo si; | |
1421 int i; | |
1422 int slice_count; | |
8371
2ebc9b2c7459
add const qualifier to some pointers for input data
kostya
parents:
8370
diff
changeset
|
1423 const uint8_t *slices_hdr = NULL; |
6026 | 1424 int last = 0; |
1425 | |
1426 /* no supplementary picture */ | |
1427 if (buf_size == 0) { | |
1428 /* special case for last picture */ | |
1429 if (s->low_delay==0 && s->next_picture_ptr) { | |
1430 *pict= *(AVFrame*)s->next_picture_ptr; | |
1431 s->next_picture_ptr= NULL; | |
1432 | |
1433 *data_size = sizeof(AVFrame); | |
1434 } | |
1435 return 0; | |
1436 } | |
1437 | |
1438 if(!avctx->slice_count){ | |
1439 slice_count = (*buf++) + 1; | |
1440 slices_hdr = buf + 4; | |
1441 buf += 8 * slice_count; | |
1442 }else | |
1443 slice_count = avctx->slice_count; | |
1444 | |
8754
f471abd09fef
Move RV3/4 frame type check up so 1-slice unanchored B-frames are checked, too.
kostya
parents:
8721
diff
changeset
|
1445 //parse first slice header to check whether this frame can be decoded |
f471abd09fef
Move RV3/4 frame type check up so 1-slice unanchored B-frames are checked, too.
kostya
parents:
8721
diff
changeset
|
1446 if(get_slice_offset(avctx, slices_hdr, 0) > buf_size){ |
f471abd09fef
Move RV3/4 frame type check up so 1-slice unanchored B-frames are checked, too.
kostya
parents:
8721
diff
changeset
|
1447 av_log(avctx, AV_LOG_ERROR, "Slice offset is greater than frame size\n"); |
f471abd09fef
Move RV3/4 frame type check up so 1-slice unanchored B-frames are checked, too.
kostya
parents:
8721
diff
changeset
|
1448 return -1; |
f471abd09fef
Move RV3/4 frame type check up so 1-slice unanchored B-frames are checked, too.
kostya
parents:
8721
diff
changeset
|
1449 } |
f471abd09fef
Move RV3/4 frame type check up so 1-slice unanchored B-frames are checked, too.
kostya
parents:
8721
diff
changeset
|
1450 init_get_bits(&s->gb, buf+get_slice_offset(avctx, slices_hdr, 0), buf_size-get_slice_offset(avctx, slices_hdr, 0)); |
8821
58706d84c938
In RV3/4 nonzero MB offset for the first slice also indicates error
kostya
parents:
8754
diff
changeset
|
1451 if(r->parse_slice_header(r, &r->s.gb, &si) < 0 || si.start){ |
8754
f471abd09fef
Move RV3/4 frame type check up so 1-slice unanchored B-frames are checked, too.
kostya
parents:
8721
diff
changeset
|
1452 av_log(avctx, AV_LOG_ERROR, "First slice header is incorrect\n"); |
f471abd09fef
Move RV3/4 frame type check up so 1-slice unanchored B-frames are checked, too.
kostya
parents:
8721
diff
changeset
|
1453 return -1; |
f471abd09fef
Move RV3/4 frame type check up so 1-slice unanchored B-frames are checked, too.
kostya
parents:
8721
diff
changeset
|
1454 } |
f471abd09fef
Move RV3/4 frame type check up so 1-slice unanchored B-frames are checked, too.
kostya
parents:
8721
diff
changeset
|
1455 if((!s->last_picture_ptr || !s->last_picture_ptr->data[0]) && si.type == FF_B_TYPE) |
f471abd09fef
Move RV3/4 frame type check up so 1-slice unanchored B-frames are checked, too.
kostya
parents:
8721
diff
changeset
|
1456 return -1; |
8827 | 1457 /* skip b frames if we are in a hurry */ |
1458 if(avctx->hurry_up && si.type==FF_B_TYPE) return buf_size; | |
1459 if( (avctx->skip_frame >= AVDISCARD_NONREF && si.type==FF_B_TYPE) | |
1460 || (avctx->skip_frame >= AVDISCARD_NONKEY && si.type!=FF_I_TYPE) | |
1461 || avctx->skip_frame >= AVDISCARD_ALL) | |
1462 return buf_size; | |
1463 /* skip everything if we are in a hurry>=5 */ | |
1464 if(avctx->hurry_up>=5) | |
1465 return buf_size; | |
8754
f471abd09fef
Move RV3/4 frame type check up so 1-slice unanchored B-frames are checked, too.
kostya
parents:
8721
diff
changeset
|
1466 |
6026 | 1467 for(i=0; i<slice_count; i++){ |
1468 int offset= get_slice_offset(avctx, slices_hdr, i); | |
1469 int size; | |
1470 if(i+1 == slice_count) | |
1471 size= buf_size - offset; | |
1472 else | |
1473 size= get_slice_offset(avctx, slices_hdr, i+1) - offset; | |
1474 | |
8243 | 1475 if(offset > buf_size){ |
1476 av_log(avctx, AV_LOG_ERROR, "Slice offset is greater than frame size\n"); | |
1477 break; | |
1478 } | |
1479 | |
6026 | 1480 r->si.end = s->mb_width * s->mb_height; |
1481 if(i+1 < slice_count){ | |
1482 init_get_bits(&s->gb, buf+get_slice_offset(avctx, slices_hdr, i+1), (buf_size-get_slice_offset(avctx, slices_hdr, i+1))*8); | |
1483 if(r->parse_slice_header(r, &r->s.gb, &si) < 0){ | |
1484 if(i+2 < slice_count) | |
1485 size = get_slice_offset(avctx, slices_hdr, i+2) - offset; | |
1486 else | |
1487 size = buf_size - offset; | |
1488 }else | |
1489 r->si.end = si.start; | |
1490 } | |
1491 last = rv34_decode_slice(r, r->si.end, buf + offset, size); | |
1492 s->mb_num_left = r->s.mb_x + r->s.mb_y*r->s.mb_width - r->si.start; | |
1493 if(last) | |
1494 break; | |
1495 } | |
1496 | |
1497 if(last){ | |
1498 if(r->loop_filter) | |
8224
6771b3544991
Invoke future RV30/40 loop filter for already decoded rows instead of
kostya
parents:
8221
diff
changeset
|
1499 r->loop_filter(r, s->mb_height - 1); |
6026 | 1500 ff_er_frame_end(s); |
1501 MPV_frame_end(s); | |
6481 | 1502 if (s->pict_type == FF_B_TYPE || s->low_delay) { |
6026 | 1503 *pict= *(AVFrame*)s->current_picture_ptr; |
1504 } else if (s->last_picture_ptr != NULL) { | |
1505 *pict= *(AVFrame*)s->last_picture_ptr; | |
1506 } | |
1507 | |
1508 if(s->last_picture_ptr || s->low_delay){ | |
1509 *data_size = sizeof(AVFrame); | |
1510 ff_print_debug_info(s, pict); | |
1511 } | |
1512 s->current_picture_ptr= NULL; //so we can detect if frame_end wasnt called (find some nicer solution...) | |
1513 } | |
1514 return buf_size; | |
1515 } | |
1516 | |
6517
48759bfbd073
Apply 'cold' attribute to init/uninit functions in libavcodec
zuxy
parents:
6481
diff
changeset
|
1517 av_cold int ff_rv34_decode_end(AVCodecContext *avctx) |
6026 | 1518 { |
1519 RV34DecContext *r = avctx->priv_data; | |
1520 | |
1521 MPV_common_end(&r->s); | |
1522 | |
1523 av_freep(&r->intra_types_hist); | |
1524 r->intra_types = NULL; | |
1525 av_freep(&r->mb_type); | |
8038 | 1526 av_freep(&r->cbp_luma); |
1527 av_freep(&r->cbp_chroma); | |
1528 av_freep(&r->deblock_coefs); | |
6026 | 1529 |
1530 return 0; | |
1531 } |