/src/ffmpeg/libavcodec/vc1_block.c
Line | Count | Source |
1 | | /* |
2 | | * VC-1 and WMV3 decoder |
3 | | * Copyright (c) 2011 Mashiat Sarker Shakkhar |
4 | | * Copyright (c) 2006-2007 Konstantin Shishkov |
5 | | * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer |
6 | | * |
7 | | * This file is part of FFmpeg. |
8 | | * |
9 | | * FFmpeg is free software; you can redistribute it and/or |
10 | | * modify it under the terms of the GNU Lesser General Public |
11 | | * License as published by the Free Software Foundation; either |
12 | | * version 2.1 of the License, or (at your option) any later version. |
13 | | * |
14 | | * FFmpeg is distributed in the hope that it will be useful, |
15 | | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
16 | | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
17 | | * Lesser General Public License for more details. |
18 | | * |
19 | | * You should have received a copy of the GNU Lesser General Public |
20 | | * License along with FFmpeg; if not, write to the Free Software |
21 | | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
22 | | */ |
23 | | |
24 | | /** |
25 | | * @file |
26 | | * VC-1 and WMV3 block decoding routines |
27 | | */ |
28 | | |
29 | | #include "avcodec.h" |
30 | | #include "mpegutils.h" |
31 | | #include "mpegvideo.h" |
32 | | #include "mpegvideodec.h" |
33 | | #include "msmpeg4_vc1_data.h" |
34 | | #include "unary.h" |
35 | | #include "vc1.h" |
36 | | #include "vc1_pred.h" |
37 | | #include "vc1acdata.h" |
38 | | #include "vc1data.h" |
39 | | |
40 | | // offset tables for interlaced picture MVDATA decoding |
41 | | static const uint8_t offset_table[2][9] = { |
42 | | { 0, 1, 2, 4, 8, 16, 32, 64, 128 }, |
43 | | { 0, 1, 3, 7, 15, 31, 63, 127, 255 }, |
44 | | }; |
45 | | |
46 | | // mapping table for internal block representation |
47 | | static const int block_map[6] = {0, 2, 1, 3, 4, 5}; |
48 | | |
49 | | /***********************************************************************/ |
50 | | /** |
51 | | * @name VC-1 Bitplane decoding |
52 | | * @see 8.7, p56 |
53 | | * @{ |
54 | | */ |
55 | | |
56 | | |
57 | | static inline void init_block_index(VC1Context *v) |
58 | 5.08M | { |
59 | 5.08M | MpegEncContext *s = &v->s; |
60 | 5.08M | ff_init_block_index(s); |
61 | 5.08M | if (v->field_mode && !(v->second_field ^ v->tff)) { |
62 | 98.2k | s->dest[0] += s->cur_pic.ptr->f->linesize[0]; |
63 | 98.2k | s->dest[1] += s->cur_pic.ptr->f->linesize[1]; |
64 | 98.2k | s->dest[2] += s->cur_pic.ptr->f->linesize[2]; |
65 | 98.2k | } |
66 | 5.08M | } |
67 | | |
68 | | static inline void update_block_index(MpegEncContext *s) |
69 | 60.9M | { |
70 | | /* VC1 is always 420 except when using AV_CODEC_FLAG_GRAY |
71 | | * (or a HWAccel). Shall we inline this value? */ |
72 | 60.9M | ff_update_block_index(s, 8, 0, s->chroma_x_shift); |
73 | 60.9M | } |
74 | | |
75 | | /** @} */ //Bitplane group |
76 | | |
77 | | static void vc1_put_blocks_clamped(VC1Context *v, int put_signed) |
78 | 36.8M | { |
79 | 36.8M | MpegEncContext *s = &v->s; |
80 | 36.8M | uint8_t *dest; |
81 | 36.8M | int block_count = CONFIG_GRAY && (s->avctx->flags & AV_CODEC_FLAG_GRAY) ? 4 : 6; |
82 | 36.8M | int fieldtx = 0; |
83 | 36.8M | int i; |
84 | | |
85 | | /* The put pixels loop is one MB row and one MB column behind the decoding |
86 | | * loop because we can only put pixels when overlap filtering is done. For |
87 | | * interlaced frame pictures, however, the put pixels loop is only one |
88 | | * column behind the decoding loop as interlaced frame pictures only need |
89 | | * horizontal overlap filtering. */ |
90 | 36.8M | if (!s->first_slice_line && v->fcm != ILACE_FRAME) { |
91 | 18.9M | if (s->mb_x) { |
92 | 123M | for (i = 0; i < block_count; i++) { |
93 | 105M | if (i > 3 ? v->mb_type[s->block_index[i] - s->block_wrap[i] - 1] : |
94 | 105M | v->mb_type[s->block_index[i] - 2 * s->block_wrap[i] - 2]) { |
95 | 27.6M | dest = s->dest[0] + ((i & 2) - 4) * 4 * s->linesize + ((i & 1) - 2) * 8; |
96 | 27.6M | if (put_signed) |
97 | 10.1M | s->idsp.put_signed_pixels_clamped(v->block[v->topleft_blk_idx][block_map[i]], |
98 | 10.1M | i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 8 : dest, |
99 | 10.1M | i > 3 ? s->uvlinesize : s->linesize); |
100 | 17.5M | else |
101 | 17.5M | s->idsp.put_pixels_clamped(v->block[v->topleft_blk_idx][block_map[i]], |
102 | 17.5M | i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize - 8 : dest, |
103 | 17.5M | i > 3 ? s->uvlinesize : s->linesize); |
104 | 27.6M | } |
105 | 105M | } |
106 | 17.5M | } |
107 | 18.9M | if (s->mb_x == v->end_mb_x - 1) { |
108 | 9.29M | for (i = 0; i < block_count; i++) { |
109 | 7.96M | if (i > 3 ? v->mb_type[s->block_index[i] - s->block_wrap[i]] : |
110 | 7.96M | v->mb_type[s->block_index[i] - 2 * s->block_wrap[i]]) { |
111 | 1.45M | dest = s->dest[0] + ((i & 2) - 4) * 4 * s->linesize + (i & 1) * 8; |
112 | 1.45M | if (put_signed) |
113 | 856k | s->idsp.put_signed_pixels_clamped(v->block[v->top_blk_idx][block_map[i]], |
114 | 856k | i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize : dest, |
115 | 856k | i > 3 ? s->uvlinesize : s->linesize); |
116 | 596k | else |
117 | 596k | s->idsp.put_pixels_clamped(v->block[v->top_blk_idx][block_map[i]], |
118 | 596k | i > 3 ? s->dest[i - 3] - 8 * s->uvlinesize : dest, |
119 | 596k | i > 3 ? s->uvlinesize : s->linesize); |
120 | 1.45M | } |
121 | 7.96M | } |
122 | 1.32M | } |
123 | 18.9M | } |
124 | 36.8M | if (s->mb_y == s->end_mb_y - 1 || v->fcm == ILACE_FRAME) { |
125 | 16.1M | if (s->mb_x) { |
126 | 14.6M | if (v->fcm == ILACE_FRAME) |
127 | 13.4M | fieldtx = v->fieldtx_plane[s->mb_y * s->mb_stride + s->mb_x - 1]; |
128 | 102M | for (i = 0; i < block_count; i++) { |
129 | 87.6M | if (i > 3 ? v->mb_type[s->block_index[i] - 1] : |
130 | 87.6M | v->mb_type[s->block_index[i] - 2]) { |
131 | 8.45M | if (fieldtx) |
132 | 4.42M | dest = s->dest[0] + ((i & 2) >> 1) * s->linesize + ((i & 1) - 2) * 8; |
133 | 4.02M | else |
134 | 4.02M | dest = s->dest[0] + (i & 2) * 4 * s->linesize + ((i & 1) - 2) * 8; |
135 | 8.45M | if (put_signed) |
136 | 7.82M | s->idsp.put_signed_pixels_clamped(v->block[v->left_blk_idx][block_map[i]], |
137 | 7.82M | i > 3 ? s->dest[i - 3] - 8 : dest, |
138 | 7.82M | i > 3 ? s->uvlinesize : s->linesize << fieldtx); |
139 | 632k | else |
140 | 632k | s->idsp.put_pixels_clamped(v->block[v->left_blk_idx][block_map[i]], |
141 | 632k | i > 3 ? s->dest[i - 3] - 8 : dest, |
142 | 632k | i > 3 ? s->uvlinesize : s->linesize << fieldtx); |
143 | 8.45M | } |
144 | 87.6M | } |
145 | 14.6M | } |
146 | 16.1M | if (s->mb_x == v->end_mb_x - 1) { |
147 | 1.41M | if (v->fcm == ILACE_FRAME) |
148 | 1.14M | fieldtx = v->fieldtx_plane[s->mb_y * s->mb_stride + s->mb_x]; |
149 | 9.92M | for (i = 0; i < block_count; i++) { |
150 | 8.51M | if (v->mb_type[s->block_index[i]]) { |
151 | 3.33M | if (fieldtx) |
152 | 719k | dest = s->dest[0] + ((i & 2) >> 1) * s->linesize + (i & 1) * 8; |
153 | 2.61M | else |
154 | 2.61M | dest = s->dest[0] + (i & 2) * 4 * s->linesize + (i & 1) * 8; |
155 | 3.33M | if (put_signed) |
156 | 2.17M | s->idsp.put_signed_pixels_clamped(v->block[v->cur_blk_idx][block_map[i]], |
157 | 2.17M | i > 3 ? s->dest[i - 3] : dest, |
158 | 2.17M | i > 3 ? s->uvlinesize : s->linesize << fieldtx); |
159 | 1.16M | else |
160 | 1.16M | s->idsp.put_pixels_clamped(v->block[v->cur_blk_idx][block_map[i]], |
161 | 1.16M | i > 3 ? s->dest[i - 3] : dest, |
162 | 1.16M | i > 3 ? s->uvlinesize : s->linesize << fieldtx); |
163 | 3.33M | } |
164 | 8.51M | } |
165 | 1.41M | } |
166 | 16.1M | } |
167 | 36.8M | } |
168 | | |
169 | 128M | #define inc_blk_idx(idx) do { \ |
170 | 128M | idx++; \ |
171 | 128M | if (idx >= v->n_allocated_blks) \ |
172 | 128M | idx = 0; \ |
173 | 128M | } while (0) |
174 | | |
175 | | /***********************************************************************/ |
176 | | /** |
177 | | * @name VC-1 Block-level functions |
178 | | * @see 7.1.4, p91 and 8.1.1.7, p(1)04 |
179 | | * @{ |
180 | | */ |
181 | | |
182 | | /** |
183 | | * @def GET_MQUANT |
184 | | * @brief Get macroblock-level quantizer scale |
185 | | */ |
186 | | #define GET_MQUANT() \ |
187 | 19.2M | if (v->dquantfrm) { \ |
188 | 10.2M | int edges = 0; \ |
189 | 10.2M | if (v->dqprofile == DQPROFILE_ALL_MBS) { \ |
190 | 6.34M | if (v->dqbilevel) { \ |
191 | 2.51M | mquant = (get_bits1(gb)) ? -v->altpq : v->pq; \ |
192 | 3.83M | } else { \ |
193 | 3.83M | mqdiff = get_bits(gb, 3); \ |
194 | 3.83M | if (mqdiff != 7) \ |
195 | 3.83M | mquant = -v->pq - mqdiff; \ |
196 | 3.83M | else \ |
197 | 3.83M | mquant = -get_bits(gb, 5); \ |
198 | 3.83M | } \ |
199 | 6.34M | } \ |
200 | 10.2M | if (v->dqprofile == DQPROFILE_SINGLE_EDGE) \ |
201 | 10.2M | edges = 1 << v->dqsbedge; \ |
202 | 10.2M | else if (v->dqprofile == DQPROFILE_DOUBLE_EDGES) \ |
203 | 8.45M | edges = (3 << v->dqsbedge) % 15; \ |
204 | 8.45M | else if (v->dqprofile == DQPROFILE_FOUR_EDGES) \ |
205 | 7.24M | edges = 15; \ |
206 | 10.2M | if ((edges&1) && !s->mb_x) \ |
207 | 10.2M | mquant = -v->altpq; \ |
208 | 10.2M | if ((edges&2) && !s->mb_y) \ |
209 | 10.2M | mquant = -v->altpq; \ |
210 | 10.2M | if ((edges&4) && s->mb_x == (s->mb_width - 1)) \ |
211 | 10.2M | mquant = -v->altpq; \ |
212 | 10.2M | if ((edges&8) && \ |
213 | 10.2M | s->mb_y == ((s->mb_height >> v->field_mode) - 1)) \ |
214 | 10.2M | mquant = -v->altpq; \ |
215 | 10.2M | if (!mquant || mquant > 31 || mquant < -31) { \ |
216 | 900k | av_log(v->s.avctx, AV_LOG_ERROR, \ |
217 | 900k | "Overriding invalid mquant %d\n", mquant); \ |
218 | 900k | mquant = 1; \ |
219 | 900k | } \ |
220 | 10.2M | } |
221 | | |
222 | | /** |
223 | | * @def GET_MVDATA(_dmv_x, _dmv_y) |
224 | | * @brief Get MV differentials |
225 | | * @see MVDATA decoding from 8.3.5.2, p(1)20 |
226 | | * @param _dmv_x Horizontal differential for decoded MV |
227 | | * @param _dmv_y Vertical differential for decoded MV |
228 | | */ |
229 | | #define GET_MVDATA(_dmv_x, _dmv_y) \ |
230 | 14.2M | index = 1 + get_vlc2(gb, ff_vc1_mv_diff_vlc[v->mv_table_index], \ |
231 | 14.2M | VC1_MV_DIFF_VLC_BITS, 2); \ |
232 | 14.2M | if (index > 36) { \ |
233 | 9.46M | mb_has_coeffs = 1; \ |
234 | 9.46M | index -= 37; \ |
235 | 9.46M | } else \ |
236 | 14.2M | mb_has_coeffs = 0; \ |
237 | 14.2M | s->mb_intra = 0; \ |
238 | 14.2M | if (!index) { \ |
239 | 1.53M | _dmv_x = _dmv_y = 0; \ |
240 | 12.6M | } else if (index == 35) { \ |
241 | 47.9k | _dmv_x = get_bits(gb, v->k_x - 1 + s->quarter_sample); \ |
242 | 47.9k | _dmv_y = get_bits(gb, v->k_y - 1 + s->quarter_sample); \ |
243 | 12.6M | } else if (index == 36) { \ |
244 | 1.55M | _dmv_x = 0; \ |
245 | 1.55M | _dmv_y = 0; \ |
246 | 1.55M | s->mb_intra = 1; \ |
247 | 11.0M | } else { \ |
248 | 11.0M | index1 = index % 6; \ |
249 | 11.0M | _dmv_x = offset_table[1][index1]; \ |
250 | 11.0M | val = size_table[index1] - (!s->quarter_sample && index1 == 5); \ |
251 | 11.0M | if (val > 0) { \ |
252 | 9.83M | val = get_bits(gb, val); \ |
253 | 9.83M | sign = 0 - (val & 1); \ |
254 | 9.83M | _dmv_x = (sign ^ ((val >> 1) + _dmv_x)) - sign; \ |
255 | 9.83M | } \ |
256 | 11.0M | \ |
257 | 11.0M | index1 = index / 6; \ |
258 | 11.0M | _dmv_y = offset_table[1][index1]; \ |
259 | 11.0M | val = size_table[index1] - (!s->quarter_sample && index1 == 5); \ |
260 | 11.0M | if (val > 0) { \ |
261 | 7.38M | val = get_bits(gb, val); \ |
262 | 7.38M | sign = 0 - (val & 1); \ |
263 | 7.38M | _dmv_y = (sign ^ ((val >> 1) + _dmv_y)) - sign; \ |
264 | 7.38M | } \ |
265 | 11.0M | } |
266 | | |
267 | | static av_always_inline void get_mvdata_interlaced(VC1Context *v, int *dmv_x, |
268 | | int *dmv_y, int *pred_flag) |
269 | 15.8M | { |
270 | 15.8M | int index, index1; |
271 | 15.8M | int extend_x, extend_y; |
272 | 15.8M | GetBitContext *const gb = &v->gb; |
273 | 15.8M | int bits, esc; |
274 | 15.8M | int val, sign; |
275 | | |
276 | 15.8M | if (v->numref) { |
277 | 1.69M | bits = VC1_2REF_MVDATA_VLC_BITS; |
278 | 1.69M | esc = 125; |
279 | 14.1M | } else { |
280 | 14.1M | bits = VC1_1REF_MVDATA_VLC_BITS; |
281 | 14.1M | esc = 71; |
282 | 14.1M | } |
283 | 15.8M | extend_x = v->dmvrange & 1; |
284 | 15.8M | extend_y = (v->dmvrange >> 1) & 1; |
285 | 15.8M | index = get_vlc2(gb, v->imv_vlc, bits, 3); |
286 | 15.8M | if (index == esc) { |
287 | 41.7k | *dmv_x = get_bits(gb, v->k_x); |
288 | 41.7k | *dmv_y = get_bits(gb, v->k_y); |
289 | 41.7k | if (v->numref) { |
290 | 10.4k | if (pred_flag) |
291 | 10.4k | *pred_flag = *dmv_y & 1; |
292 | 10.4k | *dmv_y = (*dmv_y + (*dmv_y & 1)) >> 1; |
293 | 10.4k | } |
294 | 41.7k | } |
295 | 15.7M | else { |
296 | 15.7M | av_assert0(index < esc); |
297 | 15.7M | index1 = (index + 1) % 9; |
298 | 15.7M | if (index1 != 0) { |
299 | 10.1M | val = get_bits(gb, index1 + extend_x); |
300 | 10.1M | sign = 0 - (val & 1); |
301 | 10.1M | *dmv_x = (sign ^ ((val >> 1) + offset_table[extend_x][index1])) - sign; |
302 | 10.1M | } else |
303 | 5.62M | *dmv_x = 0; |
304 | 15.7M | index1 = (index + 1) / 9; |
305 | 15.7M | if (index1 > v->numref) { |
306 | 10.2M | val = get_bits(gb, (index1 >> v->numref) + extend_y); |
307 | 10.2M | sign = 0 - (val & 1); |
308 | 10.2M | *dmv_y = (sign ^ ((val >> 1) + offset_table[extend_y][index1 >> v->numref])) - sign; |
309 | 10.2M | } else |
310 | 5.49M | *dmv_y = 0; |
311 | 15.7M | if (v->numref && pred_flag) |
312 | 1.68M | *pred_flag = index1 & 1; |
313 | 15.7M | } |
314 | 15.8M | } |
315 | | |
316 | | /** Reconstruct motion vector for B-frame and do motion compensation |
317 | | */ |
318 | | static inline void vc1_b_mc(VC1Context *v, int dmv_x[2], int dmv_y[2], |
319 | | int direct, int mode) |
320 | 9.58M | { |
321 | 9.58M | if (direct) { |
322 | 2.75M | ff_vc1_mc_1mv(v, 0); |
323 | 2.75M | ff_vc1_interp_mc(v); |
324 | 2.75M | return; |
325 | 2.75M | } |
326 | 6.82M | if (mode == BMV_TYPE_INTERPOLATED) { |
327 | 1.56M | ff_vc1_mc_1mv(v, 0); |
328 | 1.56M | ff_vc1_interp_mc(v); |
329 | 1.56M | return; |
330 | 1.56M | } |
331 | | |
332 | 5.26M | ff_vc1_mc_1mv(v, (mode == BMV_TYPE_BACKWARD)); |
333 | 5.26M | } |
334 | | |
335 | | /** Get predicted DC value for I-frames only |
336 | | * prediction dir: left=0, top=1 |
337 | | * @param s MpegEncContext |
338 | | * @param overlap flag indicating that overlap filtering is used |
339 | | * @param pq integer part of picture quantizer |
340 | | * @param[in] n block index in the current MB |
341 | | * @param dc_val_ptr Pointer to DC predictor |
342 | | * @param dir_ptr Prediction direction for use in AC prediction |
343 | | */ |
344 | | static inline int vc1_i_pred_dc(MpegEncContext *s, int overlap, int pq, int n, |
345 | | int16_t **dc_val_ptr, int *dir_ptr) |
346 | 27.9M | { |
347 | 27.9M | int a, b, c, wrap, pred, scale; |
348 | 27.9M | int16_t *dc_val; |
349 | 27.9M | static const uint16_t dcpred[32] = { |
350 | 27.9M | -1, 1024, 512, 341, 256, 205, 171, 146, 128, |
351 | 27.9M | 114, 102, 93, 85, 79, 73, 68, 64, |
352 | 27.9M | 60, 57, 54, 51, 49, 47, 45, 43, |
353 | 27.9M | 41, 39, 38, 37, 35, 34, 33 |
354 | 27.9M | }; |
355 | | |
356 | | /* find prediction - wmv3_dc_scale always used here in fact */ |
357 | 27.9M | scale = s->y_dc_scale; |
358 | | |
359 | 27.9M | wrap = s->block_wrap[n]; |
360 | 27.9M | dc_val = s->dc_val + s->block_index[n]; |
361 | | |
362 | | /* B A |
363 | | * C X |
364 | | */ |
365 | 27.9M | c = dc_val[ - 1]; |
366 | 27.9M | b = dc_val[ - 1 - wrap]; |
367 | 27.9M | a = dc_val[ - wrap]; |
368 | | |
369 | 27.9M | if (pq < 9 || !overlap) { |
370 | | /* Set outer values */ |
371 | 21.8M | if (s->first_slice_line && (n != 2 && n != 3)) |
372 | 2.43M | b = a = dcpred[scale]; |
373 | 21.8M | if (s->mb_x == 0 && (n != 1 && n != 3)) |
374 | 1.58M | b = c = dcpred[scale]; |
375 | 21.8M | } else { |
376 | | /* Set outer values */ |
377 | 6.12M | if (s->first_slice_line && (n != 2 && n != 3)) |
378 | 487k | b = a = 0; |
379 | 6.12M | if (s->mb_x == 0 && (n != 1 && n != 3)) |
380 | 433k | b = c = 0; |
381 | 6.12M | } |
382 | | |
383 | 27.9M | if (abs(a - b) <= abs(b - c)) { |
384 | 18.9M | pred = c; |
385 | 18.9M | *dir_ptr = 1; // left |
386 | 18.9M | } else { |
387 | 9.03M | pred = a; |
388 | 9.03M | *dir_ptr = 0; // top |
389 | 9.03M | } |
390 | | |
391 | | /* update predictor */ |
392 | 27.9M | *dc_val_ptr = &dc_val[0]; |
393 | 27.9M | return pred; |
394 | 27.9M | } |
395 | | |
396 | | |
397 | | /** Get predicted DC value |
398 | | * prediction dir: left=0, top=1 |
399 | | * @param s MpegEncContext |
400 | | * @param overlap flag indicating that overlap filtering is used |
401 | | * @param pq integer part of picture quantizer |
402 | | * @param[in] n block index in the current MB |
403 | | * @param a_avail flag indicating top block availability |
404 | | * @param c_avail flag indicating left block availability |
405 | | * @param dc_val_ptr Pointer to DC predictor |
406 | | * @param dir_ptr Prediction direction for use in AC prediction |
407 | | */ |
408 | | static inline int ff_vc1_pred_dc(MpegEncContext *s, int overlap, int pq, int n, |
409 | | int a_avail, int c_avail, |
410 | | int16_t **dc_val_ptr, int *dir_ptr) |
411 | 20.9M | { |
412 | 20.9M | int a, b, c, wrap, pred; |
413 | 20.9M | int16_t *dc_val; |
414 | 20.9M | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; |
415 | 20.9M | int q1, q2 = 0; |
416 | 20.9M | int dqscale_index; |
417 | | |
418 | | /* scale predictors if needed */ |
419 | 20.9M | q1 = FFABS(s->cur_pic.qscale_table[mb_pos]); |
420 | 20.9M | dqscale_index = ff_wmv3_dc_scale_table[q1] - 1; |
421 | 20.9M | if (dqscale_index < 0) |
422 | 0 | return 0; |
423 | | |
424 | 20.9M | wrap = s->block_wrap[n]; |
425 | 20.9M | dc_val = s->dc_val + s->block_index[n]; |
426 | | |
427 | | /* B A |
428 | | * C X |
429 | | */ |
430 | 20.9M | c = dc_val[ - 1]; |
431 | 20.9M | b = dc_val[ - 1 - wrap]; |
432 | 20.9M | a = dc_val[ - wrap]; |
433 | | |
434 | 20.9M | if (c_avail && (n != 1 && n != 3)) { |
435 | 6.86M | q2 = FFABS(s->cur_pic.qscale_table[mb_pos - 1]); |
436 | 6.86M | if (q2 && q2 != q1) |
437 | 1.38M | c = (int)((unsigned)c * ff_wmv3_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18; |
438 | 6.86M | } |
439 | 20.9M | if (a_avail && (n != 2 && n != 3)) { |
440 | 7.44M | q2 = FFABS(s->cur_pic.qscale_table[mb_pos - s->mb_stride]); |
441 | 7.44M | if (q2 && q2 != q1) |
442 | 1.26M | a = (int)((unsigned)a * ff_wmv3_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18; |
443 | 7.44M | } |
444 | 20.9M | if (a_avail && c_avail && (n != 3)) { |
445 | 7.71M | int off = mb_pos; |
446 | 7.71M | if (n != 1) |
447 | 5.85M | off--; |
448 | 7.71M | if (n != 2) |
449 | 5.99M | off -= s->mb_stride; |
450 | 7.71M | q2 = FFABS(s->cur_pic.qscale_table[off]); |
451 | 7.71M | if (q2 && q2 != q1) |
452 | 1.51M | b = (int)((unsigned)b * ff_wmv3_dc_scale_table[q2] * ff_vc1_dqscale[dqscale_index] + 0x20000) >> 18; |
453 | 7.71M | } |
454 | | |
455 | 20.9M | if (c_avail && (!a_avail || abs(a - b) <= abs(b - c))) { |
456 | 8.74M | pred = c; |
457 | 8.74M | *dir_ptr = 1; // left |
458 | 12.1M | } else if (a_avail) { |
459 | 8.04M | pred = a; |
460 | 8.04M | *dir_ptr = 0; // top |
461 | 8.04M | } else { |
462 | 4.12M | pred = 0; |
463 | 4.12M | *dir_ptr = 1; // left |
464 | 4.12M | } |
465 | | |
466 | | /* update predictor */ |
467 | 20.9M | *dc_val_ptr = &dc_val[0]; |
468 | 20.9M | return pred; |
469 | 20.9M | } |
470 | | |
471 | | /** @} */ // Block group |
472 | | |
473 | | /** |
474 | | * @name VC1 Macroblock-level functions in Simple/Main Profiles |
475 | | * @see 7.1.4, p91 and 8.1.1.7, p(1)04 |
476 | | * @{ |
477 | | */ |
478 | | |
479 | | static inline int vc1_coded_block_pred(MPVContext *const s, int n, int diff) |
480 | 26.3M | { |
481 | 26.3M | int xy, wrap, pred, a, b, c; |
482 | | |
483 | 26.3M | xy = s->block_index[n]; |
484 | 26.3M | wrap = s->b8_stride; |
485 | | |
486 | | /* B C |
487 | | * A X |
488 | | */ |
489 | 26.3M | a = s->coded_block[xy - 1 ]; |
490 | 26.3M | b = s->coded_block[xy - 1 - wrap]; |
491 | 26.3M | c = s->coded_block[xy - wrap]; |
492 | | |
493 | 26.3M | if (b == c) { |
494 | 17.8M | pred = a; |
495 | 17.8M | } else { |
496 | 8.54M | pred = c; |
497 | 8.54M | } |
498 | | |
499 | | /* store value */ |
500 | 26.3M | s->coded_block[xy] = pred ^ diff; |
501 | | |
502 | 26.3M | return pred ^ diff; |
503 | 26.3M | } |
504 | | |
505 | | /** |
506 | | * Decode one AC coefficient |
507 | | * @param v The VC1 context |
508 | | * @param last Last coefficient |
509 | | * @param skip How much zero coefficients to skip |
510 | | * @param value Decoded AC coefficient value |
511 | | * @param codingset set of VLC to decode data |
512 | | * @see 8.1.3.4 |
513 | | */ |
514 | | static int vc1_decode_ac_coeff(VC1Context *v, int *last, int *skip, |
515 | | int *value, int codingset) |
516 | 314M | { |
517 | 314M | GetBitContext *const gb = &v->gb; |
518 | 314M | int index, run, level, lst, sign; |
519 | | |
520 | 314M | index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset], AC_VLC_BITS, 3); |
521 | 314M | if (index < 0) |
522 | 1.07M | return index; |
523 | 313M | if (index != ff_vc1_ac_sizes[codingset] - 1) { |
524 | 311M | run = vc1_index_decode_table[codingset][index][0]; |
525 | 311M | level = vc1_index_decode_table[codingset][index][1]; |
526 | 311M | lst = index >= vc1_last_decode_table[codingset] || get_bits_left(gb) < 0; |
527 | 311M | sign = get_bits1(gb); |
528 | 311M | } else { |
529 | 2.02M | int escape = decode210(gb); |
530 | 2.02M | if (escape != 2) { |
531 | 949k | index = get_vlc2(gb, ff_vc1_ac_coeff_table[codingset], AC_VLC_BITS, 3); |
532 | 949k | if (index >= ff_vc1_ac_sizes[codingset] - 1U) |
533 | 93.8k | return AVERROR_INVALIDDATA; |
534 | 855k | run = vc1_index_decode_table[codingset][index][0]; |
535 | 855k | level = vc1_index_decode_table[codingset][index][1]; |
536 | 855k | lst = index >= vc1_last_decode_table[codingset]; |
537 | 855k | if (escape == 0) { |
538 | 589k | if (lst) |
539 | 100k | level += vc1_last_delta_level_table[codingset][run]; |
540 | 488k | else |
541 | 488k | level += vc1_delta_level_table[codingset][run]; |
542 | 589k | } else { |
543 | 266k | if (lst) |
544 | 49.8k | run += vc1_last_delta_run_table[codingset][level] + 1; |
545 | 216k | else |
546 | 216k | run += vc1_delta_run_table[codingset][level] + 1; |
547 | 266k | } |
548 | 855k | sign = get_bits1(gb); |
549 | 1.07M | } else { |
550 | 1.07M | lst = get_bits1(gb); |
551 | 1.07M | if (v->esc3_level_length == 0) { |
552 | 23.8k | if (v->pq < 8 || v->dquantfrm) { // table 59 |
553 | 12.5k | v->esc3_level_length = get_bits(gb, 3); |
554 | 12.5k | if (!v->esc3_level_length) |
555 | 5.49k | v->esc3_level_length = get_bits(gb, 2) + 8; |
556 | 12.5k | } else { // table 60 |
557 | 11.2k | v->esc3_level_length = get_unary(gb, 1, 6) + 2; |
558 | 11.2k | } |
559 | 23.8k | v->esc3_run_length = 3 + get_bits(gb, 2); |
560 | 23.8k | } |
561 | 1.07M | run = get_bits(gb, v->esc3_run_length); |
562 | 1.07M | sign = get_bits1(gb); |
563 | 1.07M | level = get_bits(gb, v->esc3_level_length); |
564 | 1.07M | } |
565 | 2.02M | } |
566 | | |
567 | 313M | *last = lst; |
568 | 313M | *skip = run; |
569 | 313M | *value = (level ^ -sign) + sign; |
570 | | |
571 | 313M | return 0; |
572 | 313M | } |
573 | | |
574 | | /** Decode intra block in intra frames - should be faster than decode_intra_block |
575 | | * @param v VC1Context |
576 | | * @param block block to decode |
577 | | * @param[in] n subblock index |
578 | | * @param coded are AC coeffs present or not |
579 | | * @param codingset set of VLC to decode data |
580 | | */ |
581 | | static int vc1_decode_i_block(VC1Context *v, int16_t block[64], int n, |
582 | | int coded, int codingset) |
583 | 27.9M | { |
584 | 27.9M | GetBitContext *const gb = &v->gb; |
585 | 27.9M | MpegEncContext *s = &v->s; |
586 | 27.9M | int dc_pred_dir = 0; /* Direction of the DC prediction used */ |
587 | 27.9M | int16_t *dc_val; |
588 | 27.9M | int16_t *ac_val, *ac_val2; |
589 | 27.9M | int dcdiff, scale; |
590 | | |
591 | | /* Get DC differential */ |
592 | 27.9M | dcdiff = get_vlc2(gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4], |
593 | 27.9M | MSMP4_DC_VLC_BITS, 3); |
594 | 27.9M | if (dcdiff) { |
595 | 17.3M | const int m = (v->pq == 1 || v->pq == 2) ? 3 - v->pq : 0; |
596 | 17.3M | if (dcdiff == 119 /* ESC index value */) { |
597 | 1.56k | dcdiff = get_bits(gb, 8 + m); |
598 | 17.3M | } else { |
599 | 17.3M | if (m) |
600 | 6.23M | dcdiff = (dcdiff << m) + get_bits(gb, m) - ((1 << m) - 1); |
601 | 17.3M | } |
602 | 17.3M | if (get_bits1(gb)) |
603 | 7.46M | dcdiff = -dcdiff; |
604 | 17.3M | } |
605 | | |
606 | | /* Prediction */ |
607 | 27.9M | dcdiff += vc1_i_pred_dc(&v->s, v->overlap, v->pq, n, &dc_val, &dc_pred_dir); |
608 | 27.9M | *dc_val = dcdiff; |
609 | | |
610 | | /* Store the quantized DC coeff, used for prediction */ |
611 | 27.9M | block[0] = dcdiff * s->y_dc_scale; |
612 | | |
613 | 27.9M | ac_val = s->ac_val[s->block_index[n]]; |
614 | 27.9M | ac_val2 = ac_val; |
615 | 27.9M | if (dc_pred_dir) // left |
616 | 18.9M | ac_val -= 16; |
617 | 9.03M | else // top |
618 | 9.03M | ac_val -= 16 * s->block_wrap[n]; |
619 | | |
620 | 27.9M | scale = v->pq * 2 + v->halfpq; |
621 | | |
622 | | //AC Decoding |
623 | | |
624 | 27.9M | if (coded) { |
625 | 10.4M | int last = 0, skip, value; |
626 | 10.4M | const uint8_t *zz_table; |
627 | 10.4M | int k; |
628 | | |
629 | 10.4M | if (v->s.ac_pred) { |
630 | 4.56M | if (!dc_pred_dir) |
631 | 1.50M | zz_table = v->zz_8x8[2]; |
632 | 3.05M | else |
633 | 3.05M | zz_table = v->zz_8x8[3]; |
634 | 4.56M | } else |
635 | 5.88M | zz_table = v->zz_8x8[1]; |
636 | | |
637 | 111M | for (int i = 1; !last; ++i) { |
638 | 102M | int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, codingset); |
639 | 102M | if (ret < 0) |
640 | 551k | return ret; |
641 | 101M | i += skip; |
642 | 101M | if (i > 63) |
643 | 1.27M | break; |
644 | 100M | block[zz_table[i]] = value; |
645 | 100M | } |
646 | | |
647 | | /* apply AC prediction if needed */ |
648 | 9.89M | if (s->ac_pred) { |
649 | 4.45M | int sh; |
650 | 4.45M | if (dc_pred_dir) { // left |
651 | 2.98M | sh = v->left_blk_sh; |
652 | 2.98M | } else { // top |
653 | 1.46M | sh = v->top_blk_sh; |
654 | 1.46M | ac_val += 8; |
655 | 1.46M | } |
656 | 35.6M | for (k = 1; k < 8; k++) |
657 | 31.1M | block[k << sh] += ac_val[k]; |
658 | 4.45M | } |
659 | | /* save AC coeffs for further prediction */ |
660 | 79.1M | for (k = 1; k < 8; k++) { |
661 | 69.2M | ac_val2[k] = block[k << v->left_blk_sh]; |
662 | 69.2M | ac_val2[k + 8] = block[k << v->top_blk_sh]; |
663 | 69.2M | } |
664 | | |
665 | | /* scale AC coeffs */ |
666 | 633M | for (k = 1; k < 64; k++) |
667 | 623M | if (block[k]) { |
668 | 104M | block[k] *= scale; |
669 | 104M | if (!v->pquantizer) |
670 | 27.0M | block[k] += (block[k] < 0) ? -v->pq : v->pq; |
671 | 104M | } |
672 | | |
673 | 17.5M | } else { |
674 | 17.5M | int k; |
675 | | |
676 | 17.5M | memset(ac_val2, 0, 16 * 2); |
677 | | |
678 | | /* apply AC prediction if needed */ |
679 | 17.5M | if (s->ac_pred) { |
680 | 9.07M | int sh; |
681 | 9.07M | if (dc_pred_dir) { //left |
682 | 6.51M | sh = v->left_blk_sh; |
683 | 6.51M | } else { // top |
684 | 2.56M | sh = v->top_blk_sh; |
685 | 2.56M | ac_val += 8; |
686 | 2.56M | ac_val2 += 8; |
687 | 2.56M | } |
688 | 9.07M | memcpy(ac_val2, ac_val, 8 * 2); |
689 | 72.5M | for (k = 1; k < 8; k++) { |
690 | 63.5M | block[k << sh] = ac_val[k] * scale; |
691 | 63.5M | if (!v->pquantizer && block[k << sh]) |
692 | 2.79M | block[k << sh] += (block[k << sh] < 0) ? -v->pq : v->pq; |
693 | 63.5M | } |
694 | 9.07M | } |
695 | 17.5M | } |
696 | | |
697 | 27.4M | return 0; |
698 | 27.9M | } |
699 | | |
700 | | /** Decode intra block in intra frames - should be faster than decode_intra_block |
701 | | * @param v VC1Context |
702 | | * @param block block to decode |
703 | | * @param[in] n subblock number |
704 | | * @param coded are AC coeffs present or not |
705 | | * @param codingset set of VLC to decode data |
706 | | * @param mquant quantizer value for this macroblock |
707 | | */ |
708 | | static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n, |
709 | | int coded, int codingset, int mquant) |
710 | 11.6M | { |
711 | 11.6M | GetBitContext *const gb = &v->gb; |
712 | 11.6M | MpegEncContext *s = &v->s; |
713 | 11.6M | int dc_pred_dir = 0; /* Direction of the DC prediction used */ |
714 | 11.6M | int16_t *dc_val = NULL; |
715 | 11.6M | int16_t *ac_val, *ac_val2; |
716 | 11.6M | int dcdiff; |
717 | 11.6M | int a_avail = v->a_avail, c_avail = v->c_avail; |
718 | 11.6M | int use_pred = s->ac_pred; |
719 | 11.6M | int scale; |
720 | 11.6M | int q1, q2 = 0; |
721 | 11.6M | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; |
722 | 11.6M | int quant = FFABS(mquant); |
723 | | |
724 | | /* Get DC differential */ |
725 | 11.6M | dcdiff = get_vlc2(gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4], |
726 | 11.6M | MSMP4_DC_VLC_BITS, 3); |
727 | 11.6M | if (dcdiff) { |
728 | 6.83M | const int m = (quant == 1 || quant == 2) ? 3 - quant : 0; |
729 | 6.83M | if (dcdiff == 119 /* ESC index value */) { |
730 | 1.48k | dcdiff = get_bits(gb, 8 + m); |
731 | 6.83M | } else { |
732 | 6.83M | if (m) |
733 | 878k | dcdiff = (dcdiff << m) + get_bits(gb, m) - ((1 << m) - 1); |
734 | 6.83M | } |
735 | 6.83M | if (get_bits1(gb)) |
736 | 3.09M | dcdiff = -dcdiff; |
737 | 6.83M | } |
738 | | |
739 | | /* Prediction */ |
740 | 11.6M | dcdiff += ff_vc1_pred_dc(&v->s, v->overlap, quant, n, v->a_avail, v->c_avail, &dc_val, &dc_pred_dir); |
741 | 11.6M | *dc_val = dcdiff; |
742 | | |
743 | | /* Store the quantized DC coeff, used for prediction */ |
744 | 11.6M | block[0] = dcdiff * s->y_dc_scale; |
745 | | |
746 | | /* check if AC is needed at all */ |
747 | 11.6M | if (!a_avail && !c_avail) |
748 | 121k | use_pred = 0; |
749 | | |
750 | 11.6M | scale = quant * 2 + ((mquant < 0) ? 0 : v->halfpq); |
751 | | |
752 | 11.6M | ac_val = s->ac_val[s->block_index[n]]; |
753 | 11.6M | ac_val2 = ac_val; |
754 | 11.6M | if (dc_pred_dir) // left |
755 | 5.75M | ac_val -= 16; |
756 | 5.84M | else // top |
757 | 5.84M | ac_val -= 16 * s->block_wrap[n]; |
758 | | |
759 | 11.6M | q1 = s->cur_pic.qscale_table[mb_pos]; |
760 | 11.6M | if (n == 3) |
761 | 1.93M | q2 = q1; |
762 | 9.66M | else if (dc_pred_dir) { |
763 | 4.77M | if (n == 1) |
764 | 1.00M | q2 = q1; |
765 | 3.76M | else if (c_avail && mb_pos) |
766 | 3.64M | q2 = s->cur_pic.qscale_table[mb_pos - 1]; |
767 | 4.88M | } else { |
768 | 4.88M | if (n == 2) |
769 | 1.02M | q2 = q1; |
770 | 3.86M | else if (a_avail && mb_pos >= s->mb_stride) |
771 | 3.86M | q2 = s->cur_pic.qscale_table[mb_pos - s->mb_stride]; |
772 | 4.88M | } |
773 | | |
774 | | //AC Decoding |
775 | | |
776 | 11.6M | if (coded) { |
777 | 4.39M | int last = 0, skip, value; |
778 | 4.39M | const uint8_t *zz_table; |
779 | 4.39M | int k; |
780 | | |
781 | 4.39M | if (v->s.ac_pred) { |
782 | 1.75M | if (!use_pred && v->fcm == ILACE_FRAME) { |
783 | 2.65k | zz_table = v->zzi_8x8; |
784 | 1.75M | } else { |
785 | 1.75M | if (!dc_pred_dir) // top |
786 | 817k | zz_table = v->zz_8x8[2]; |
787 | 938k | else // left |
788 | 938k | zz_table = v->zz_8x8[3]; |
789 | 1.75M | } |
790 | 2.63M | } else { |
791 | 2.63M | if (v->fcm != ILACE_FRAME) |
792 | 898k | zz_table = v->zz_8x8[1]; |
793 | 1.73M | else |
794 | 1.73M | zz_table = v->zzi_8x8; |
795 | 2.63M | } |
796 | | |
797 | 28.5M | for (int i = 1; !last; ++i) { |
798 | 24.6M | int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, codingset); |
799 | 24.6M | if (ret < 0) |
800 | 208k | return ret; |
801 | 24.4M | i += skip; |
802 | 24.4M | if (i > 63) |
803 | 338k | break; |
804 | 24.1M | block[zz_table[i]] = value; |
805 | 24.1M | } |
806 | | |
807 | | /* apply AC prediction if needed */ |
808 | 4.18M | if (use_pred) { |
809 | 1.66M | int sh; |
810 | 1.66M | if (dc_pred_dir) { // left |
811 | 873k | sh = v->left_blk_sh; |
812 | 873k | } else { // top |
813 | 790k | sh = v->top_blk_sh; |
814 | 790k | ac_val += 8; |
815 | 790k | } |
816 | | /* scale predictors if needed*/ |
817 | 1.66M | q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1; |
818 | 1.66M | if (q1 < 1) |
819 | 0 | return AVERROR_INVALIDDATA; |
820 | 1.66M | if (q2) |
821 | 1.66M | q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1; |
822 | 1.66M | if (q2 && q1 != q2) { |
823 | 1.38M | for (k = 1; k < 8; k++) |
824 | 1.21M | block[k << sh] += (int)(ac_val[k] * (unsigned)q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18; |
825 | 1.48M | } else { |
826 | 11.9M | for (k = 1; k < 8; k++) |
827 | 10.4M | block[k << sh] += ac_val[k]; |
828 | 1.48M | } |
829 | 1.66M | } |
830 | | /* save AC coeffs for further prediction */ |
831 | 33.4M | for (k = 1; k < 8; k++) { |
832 | 29.2M | ac_val2[k ] = block[k << v->left_blk_sh]; |
833 | 29.2M | ac_val2[k + 8] = block[k << v->top_blk_sh]; |
834 | 29.2M | } |
835 | | |
836 | | /* scale AC coeffs */ |
837 | 267M | for (k = 1; k < 64; k++) |
838 | 263M | if (block[k]) { |
839 | 25.7M | block[k] *= scale; |
840 | 25.7M | if (!v->pquantizer) |
841 | 12.9M | block[k] += (block[k] < 0) ? -quant : quant; |
842 | 25.7M | } |
843 | | |
844 | 7.21M | } else { // no AC coeffs |
845 | 7.21M | int k; |
846 | | |
847 | 7.21M | memset(ac_val2, 0, 16 * 2); |
848 | | |
849 | | /* apply AC prediction if needed */ |
850 | 7.21M | if (use_pred) { |
851 | 3.52M | int sh; |
852 | 3.52M | if (dc_pred_dir) { // left |
853 | 1.57M | sh = v->left_blk_sh; |
854 | 1.94M | } else { // top |
855 | 1.94M | sh = v->top_blk_sh; |
856 | 1.94M | ac_val += 8; |
857 | 1.94M | ac_val2 += 8; |
858 | 1.94M | } |
859 | 3.52M | memcpy(ac_val2, ac_val, 8 * 2); |
860 | 3.52M | q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1; |
861 | 3.52M | if (q1 < 1) |
862 | 0 | return AVERROR_INVALIDDATA; |
863 | 3.52M | if (q2) |
864 | 3.52M | q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1; |
865 | 3.52M | if (q2 && q1 != q2) { |
866 | 2.96M | for (k = 1; k < 8; k++) |
867 | 2.59M | ac_val2[k] = (int)(ac_val2[k] * q2 * (unsigned)ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18; |
868 | 370k | } |
869 | 28.2M | for (k = 1; k < 8; k++) { |
870 | 24.6M | block[k << sh] = ac_val2[k] * scale; |
871 | 24.6M | if (!v->pquantizer && block[k << sh]) |
872 | 2.12M | block[k << sh] += (block[k << sh] < 0) ? -quant : quant; |
873 | 24.6M | } |
874 | 3.52M | } |
875 | 7.21M | } |
876 | | |
877 | 11.3M | return 0; |
878 | 11.6M | } |
879 | | |
880 | | /** Decode intra block in inter frames - more generic version than vc1_decode_i_block |
881 | | * @param v VC1Context |
882 | | * @param block block to decode |
883 | | * @param[in] n subblock index |
884 | | * @param coded are AC coeffs present or not |
885 | | * @param mquant block quantizer |
886 | | * @param codingset set of VLC to decode data |
887 | | */ |
888 | | static int vc1_decode_intra_block(VC1Context *v, int16_t block[64], int n, |
889 | | int coded, int mquant, int codingset) |
890 | 9.30M | { |
891 | 9.30M | GetBitContext *const gb = &v->gb; |
892 | 9.30M | MpegEncContext *s = &v->s; |
893 | 9.30M | int dc_pred_dir = 0; /* Direction of the DC prediction used */ |
894 | 9.30M | int16_t *dc_val = NULL; |
895 | 9.30M | int16_t *ac_val, *ac_val2; |
896 | 9.30M | int dcdiff; |
897 | 9.30M | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; |
898 | 9.30M | int a_avail = v->a_avail, c_avail = v->c_avail; |
899 | 9.30M | int use_pred = s->ac_pred; |
900 | 9.30M | int scale; |
901 | 9.30M | int q1, q2 = 0; |
902 | 9.30M | int quant = FFABS(mquant); |
903 | | |
904 | 9.30M | s->bdsp.clear_block(block); |
905 | | |
906 | | /* XXX: Guard against dumb values of mquant */ |
907 | 9.30M | quant = av_clip_uintp2(quant, 5); |
908 | | |
909 | | /* Set DC scale - y and c use the same so we only set y */ |
910 | 9.30M | s->y_dc_scale = ff_wmv3_dc_scale_table[quant]; |
911 | | |
912 | | /* Get DC differential */ |
913 | 9.30M | dcdiff = get_vlc2(gb, ff_msmp4_dc_vlc[v->dc_table_index][n >= 4], |
914 | 9.30M | MSMP4_DC_VLC_BITS, 3); |
915 | 9.30M | if (dcdiff) { |
916 | 5.75M | const int m = (quant == 1 || quant == 2) ? 3 - quant : 0; |
917 | 5.75M | if (dcdiff == 119 /* ESC index value */) { |
918 | 635 | dcdiff = get_bits(gb, 8 + m); |
919 | 5.75M | } else { |
920 | 5.75M | if (m) |
921 | 489k | dcdiff = (dcdiff << m) + get_bits(gb, m) - ((1 << m) - 1); |
922 | 5.75M | } |
923 | 5.75M | if (get_bits1(gb)) |
924 | 2.70M | dcdiff = -dcdiff; |
925 | 5.75M | } |
926 | | |
927 | | /* Prediction */ |
928 | 9.30M | dcdiff += ff_vc1_pred_dc(&v->s, v->overlap, quant, n, a_avail, c_avail, &dc_val, &dc_pred_dir); |
929 | 9.30M | *dc_val = dcdiff; |
930 | | |
931 | | /* Store the quantized DC coeff, used for prediction */ |
932 | 9.30M | block[0] = dcdiff * s->y_dc_scale; |
933 | | |
934 | | //AC Decoding |
935 | | |
936 | | /* check if AC is needed at all and adjust direction if needed */ |
937 | 9.30M | if (!a_avail) dc_pred_dir = 1; |
938 | 9.30M | if (!c_avail) dc_pred_dir = 0; |
939 | 9.30M | if (!a_avail && !c_avail) use_pred = 0; |
940 | 9.30M | ac_val = s->ac_val[s->block_index[n]]; |
941 | 9.30M | ac_val2 = ac_val; |
942 | | |
943 | 9.30M | scale = quant * 2 + ((mquant < 0) ? 0 : v->halfpq); |
944 | | |
945 | 9.30M | if (dc_pred_dir) //left |
946 | 3.11M | ac_val -= 16; |
947 | 6.19M | else //top |
948 | 6.19M | ac_val -= 16 * s->block_wrap[n]; |
949 | | |
950 | 9.30M | q1 = s->cur_pic.qscale_table[mb_pos]; |
951 | 9.30M | if (dc_pred_dir && c_avail && mb_pos) |
952 | 3.06M | q2 = s->cur_pic.qscale_table[mb_pos - 1]; |
953 | 9.30M | if (!dc_pred_dir && a_avail && mb_pos >= s->mb_stride) |
954 | 2.02M | q2 = s->cur_pic.qscale_table[mb_pos - s->mb_stride]; |
955 | 9.30M | if (dc_pred_dir && n == 1) |
956 | 1.39M | q2 = q1; |
957 | 9.30M | if (!dc_pred_dir && n == 2) |
958 | 1.41M | q2 = q1; |
959 | 9.30M | if (n == 3) q2 = q1; |
960 | | |
961 | 9.30M | if (coded) { |
962 | 3.43M | int last = 0, skip, value; |
963 | 3.43M | int k; |
964 | | |
965 | 22.5M | for (int i = 1; !last; ++i) { |
966 | 19.3M | int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, codingset); |
967 | 19.3M | if (ret < 0) |
968 | 31.6k | return ret; |
969 | 19.2M | i += skip; |
970 | 19.2M | if (i > 63) |
971 | 129k | break; |
972 | 19.1M | if (v->fcm == PROGRESSIVE) |
973 | 14.8M | block[v->zz_8x8[0][i]] = value; |
974 | 4.29M | else { |
975 | 4.29M | if (use_pred && (v->fcm == ILACE_FRAME)) { |
976 | 1.11M | if (!dc_pred_dir) // top |
977 | 454k | block[v->zz_8x8[2][i]] = value; |
978 | 660k | else // left |
979 | 660k | block[v->zz_8x8[3][i]] = value; |
980 | 3.17M | } else { |
981 | 3.17M | block[v->zzi_8x8[i]] = value; |
982 | 3.17M | } |
983 | 4.29M | } |
984 | 19.1M | } |
985 | | |
986 | | /* apply AC prediction if needed */ |
987 | 3.40M | if (use_pred) { |
988 | | /* scale predictors if needed*/ |
989 | 1.22M | q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1; |
990 | 1.22M | if (q1 < 1) |
991 | 0 | return AVERROR_INVALIDDATA; |
992 | 1.22M | if (q2) |
993 | 1.22M | q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1; |
994 | 1.22M | if (q2 && q1 != q2) { |
995 | 67.1k | if (dc_pred_dir) { // left |
996 | 341k | for (k = 1; k < 8; k++) |
997 | 299k | block[k << v->left_blk_sh] += (int)(ac_val[k] * q2 * (unsigned)ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18; |
998 | 42.7k | } else { //top |
999 | 195k | for (k = 1; k < 8; k++) |
1000 | 171k | block[k << v->top_blk_sh] += (int)(ac_val[k + 8] * q2 * (unsigned)ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18; |
1001 | 24.4k | } |
1002 | 1.15M | } else { |
1003 | 1.15M | if (dc_pred_dir) { // left |
1004 | 5.41M | for (k = 1; k < 8; k++) |
1005 | 4.73M | block[k << v->left_blk_sh] += ac_val[k]; |
1006 | 676k | } else { // top |
1007 | 3.84M | for (k = 1; k < 8; k++) |
1008 | 3.36M | block[k << v->top_blk_sh] += ac_val[k + 8]; |
1009 | 480k | } |
1010 | 1.15M | } |
1011 | 1.22M | } |
1012 | | /* save AC coeffs for further prediction */ |
1013 | 27.2M | for (k = 1; k < 8; k++) { |
1014 | 23.8M | ac_val2[k ] = block[k << v->left_blk_sh]; |
1015 | 23.8M | ac_val2[k + 8] = block[k << v->top_blk_sh]; |
1016 | 23.8M | } |
1017 | | |
1018 | | /* scale AC coeffs */ |
1019 | 218M | for (k = 1; k < 64; k++) |
1020 | 214M | if (block[k]) { |
1021 | 18.8M | block[k] *= scale; |
1022 | 18.8M | if (!v->pquantizer) |
1023 | 8.10M | block[k] += (block[k] < 0) ? -quant : quant; |
1024 | 18.8M | } |
1025 | 5.86M | } else { // no AC coeffs |
1026 | 5.86M | int k; |
1027 | | |
1028 | 5.86M | memset(ac_val2, 0, 16 * 2); |
1029 | 5.86M | if (dc_pred_dir) { // left |
1030 | 1.97M | if (use_pred) { |
1031 | 802k | memcpy(ac_val2, ac_val, 8 * 2); |
1032 | 802k | q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1; |
1033 | 802k | if (q1 < 1) |
1034 | 0 | return AVERROR_INVALIDDATA; |
1035 | 802k | if (q2) |
1036 | 802k | q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1; |
1037 | 802k | if (q2 && q1 != q2) { |
1038 | 662k | for (k = 1; k < 8; k++) |
1039 | 579k | ac_val2[k] = (int)(ac_val2[k] * (unsigned)q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18; |
1040 | 82.8k | } |
1041 | 802k | } |
1042 | 3.89M | } else { // top |
1043 | 3.89M | if (use_pred) { |
1044 | 584k | memcpy(ac_val2 + 8, ac_val + 8, 8 * 2); |
1045 | 584k | q1 = FFABS(q1) * 2 + ((q1 < 0) ? 0 : v->halfpq) - 1; |
1046 | 584k | if (q1 < 1) |
1047 | 0 | return AVERROR_INVALIDDATA; |
1048 | 584k | if (q2) |
1049 | 584k | q2 = FFABS(q2) * 2 + ((q2 < 0) ? 0 : v->halfpq) - 1; |
1050 | 584k | if (q2 && q1 != q2) { |
1051 | 376k | for (k = 1; k < 8; k++) |
1052 | 329k | ac_val2[k + 8] = (int)(ac_val2[k + 8] * (unsigned)q2 * ff_vc1_dqscale[q1 - 1] + 0x20000) >> 18; |
1053 | 47.0k | } |
1054 | 584k | } |
1055 | 3.89M | } |
1056 | | |
1057 | | /* apply AC prediction if needed */ |
1058 | 5.86M | if (use_pred) { |
1059 | 1.38M | if (dc_pred_dir) { // left |
1060 | 6.41M | for (k = 1; k < 8; k++) { |
1061 | 5.61M | block[k << v->left_blk_sh] = ac_val2[k] * scale; |
1062 | 5.61M | if (!v->pquantizer && block[k << v->left_blk_sh]) |
1063 | 113k | block[k << v->left_blk_sh] += (block[k << v->left_blk_sh] < 0) ? -quant : quant; |
1064 | 5.61M | } |
1065 | 802k | } else { // top |
1066 | 4.67M | for (k = 1; k < 8; k++) { |
1067 | 4.09M | block[k << v->top_blk_sh] = ac_val2[k + 8] * scale; |
1068 | 4.09M | if (!v->pquantizer && block[k << v->top_blk_sh]) |
1069 | 50.0k | block[k << v->top_blk_sh] += (block[k << v->top_blk_sh] < 0) ? -quant : quant; |
1070 | 4.09M | } |
1071 | 584k | } |
1072 | 1.38M | } |
1073 | 5.86M | } |
1074 | | |
1075 | 9.27M | return 0; |
1076 | 9.30M | } |
1077 | | |
1078 | | /** Decode P block |
1079 | | */ |
1080 | | static int vc1_decode_p_block(VC1Context *v, int16_t block[64], int n, |
1081 | | int mquant, int ttmb, int first_block, |
1082 | | uint8_t *dst, int linesize, int skip_block, |
1083 | | int *ttmb_out) |
1084 | 43.9M | { |
1085 | 43.9M | MpegEncContext *s = &v->s; |
1086 | 43.9M | GetBitContext *const gb = &v->gb; |
1087 | 43.9M | int i, j; |
1088 | 43.9M | int subblkpat = 0; |
1089 | 43.9M | int scale, off, idx, last, skip, value; |
1090 | 43.9M | int ttblk = ttmb & 7; |
1091 | 43.9M | int pat = 0; |
1092 | 43.9M | int quant = FFABS(mquant); |
1093 | | |
1094 | 43.9M | s->bdsp.clear_block(block); |
1095 | | |
1096 | 43.9M | if (ttmb == -1) { |
1097 | 13.9M | ttblk = ff_vc1_ttblk_to_tt[v->tt_index][get_vlc2(gb, ff_vc1_ttblk_vlc[v->tt_index], VC1_TTBLK_VLC_BITS, 1)]; |
1098 | 13.9M | } |
1099 | 43.9M | if (ttblk == TT_4X4) { |
1100 | 5.52M | subblkpat = ~(get_vlc2(gb, ff_vc1_subblkpat_vlc[v->tt_index], VC1_SUBBLKPAT_VLC_BITS, 1) + 1); |
1101 | 5.52M | } |
1102 | 43.9M | if ((ttblk != TT_8X8 && ttblk != TT_4X4) |
1103 | 20.0M | && ((v->ttmbf || (ttmb != -1 && (ttmb & 8) && !first_block)) |
1104 | 14.3M | || (!v->res_rtm_flag && !first_block))) { |
1105 | 6.71M | subblkpat = decode012(gb); |
1106 | 6.71M | if (subblkpat) |
1107 | 3.32M | subblkpat ^= 3; // swap decoded pattern bits |
1108 | 6.71M | if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) |
1109 | 365k | ttblk = TT_8X4; |
1110 | 6.71M | if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) |
1111 | 509k | ttblk = TT_4X8; |
1112 | 6.71M | } |
1113 | 43.9M | scale = quant * 2 + ((mquant < 0) ? 0 : v->halfpq); |
1114 | | |
1115 | | // convert transforms like 8X4_TOP to generic TT and SUBBLKPAT |
1116 | 43.9M | if (ttblk == TT_8X4_TOP || ttblk == TT_8X4_BOTTOM) { |
1117 | 3.88M | subblkpat = 2 - (ttblk == TT_8X4_TOP); |
1118 | 3.88M | ttblk = TT_8X4; |
1119 | 3.88M | } |
1120 | 43.9M | if (ttblk == TT_4X8_RIGHT || ttblk == TT_4X8_LEFT) { |
1121 | 4.80M | subblkpat = 2 - (ttblk == TT_4X8_LEFT); |
1122 | 4.80M | ttblk = TT_4X8; |
1123 | 4.80M | } |
1124 | 43.9M | switch (ttblk) { |
1125 | 18.2M | case TT_8X8: |
1126 | 18.2M | pat = 0xF; |
1127 | 18.2M | i = 0; |
1128 | 18.2M | last = 0; |
1129 | 72.8M | while (!last) { |
1130 | 55.0M | int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2); |
1131 | 55.0M | if (ret < 0) |
1132 | 119k | return ret; |
1133 | 54.9M | i += skip; |
1134 | 54.9M | if (i > 63) |
1135 | 356k | break; |
1136 | 54.5M | if (!v->fcm) |
1137 | 15.7M | idx = v->zz_8x8[0][i++]; |
1138 | 38.8M | else |
1139 | 38.8M | idx = v->zzi_8x8[i++]; |
1140 | 54.5M | block[idx] = value * scale; |
1141 | 54.5M | if (!v->pquantizer) |
1142 | 30.1M | block[idx] += (block[idx] < 0) ? -quant : quant; |
1143 | 54.5M | } |
1144 | 18.1M | if (!skip_block) { |
1145 | 18.1M | if (i == 1) |
1146 | 3.67M | v->vc1dsp.vc1_inv_trans_8x8_dc(dst, linesize, block); |
1147 | 14.4M | else { |
1148 | 14.4M | v->vc1dsp.vc1_inv_trans_8x8(block); |
1149 | 14.4M | s->idsp.add_pixels_clamped(block, dst, linesize); |
1150 | 14.4M | } |
1151 | 18.1M | } |
1152 | 18.1M | break; |
1153 | 5.52M | case TT_4X4: |
1154 | 5.52M | pat = ~subblkpat & 0xF; |
1155 | 27.4M | for (j = 0; j < 4; j++) { |
1156 | 21.9M | last = subblkpat & (1 << (3 - j)); |
1157 | 21.9M | i = 0; |
1158 | 21.9M | off = (j & 1) * 4 + (j & 2) * 16; |
1159 | 47.7M | while (!last) { |
1160 | 28.3M | int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2); |
1161 | 28.3M | if (ret < 0) |
1162 | 82.1k | return ret; |
1163 | 28.3M | i += skip; |
1164 | 28.3M | if (i > 15) |
1165 | 2.54M | break; |
1166 | 25.7M | if (!v->fcm) |
1167 | 8.78M | idx = ff_vc1_simple_progressive_4x4_zz[i++]; |
1168 | 16.9M | else |
1169 | 16.9M | idx = ff_vc1_adv_interlaced_4x4_zz[i++]; |
1170 | 25.7M | block[idx + off] = value * scale; |
1171 | 25.7M | if (!v->pquantizer) |
1172 | 13.4M | block[idx + off] += (block[idx + off] < 0) ? -quant : quant; |
1173 | 25.7M | } |
1174 | 21.8M | if (!(subblkpat & (1 << (3 - j))) && !skip_block) { |
1175 | 11.1M | if (i == 1) |
1176 | 2.12M | v->vc1dsp.vc1_inv_trans_4x4_dc(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off); |
1177 | 9.01M | else |
1178 | 9.01M | v->vc1dsp.vc1_inv_trans_4x4(dst + (j & 1) * 4 + (j & 2) * 2 * linesize, linesize, block + off); |
1179 | 11.1M | } |
1180 | 21.8M | } |
1181 | 5.44M | break; |
1182 | 8.33M | case TT_8X4: |
1183 | 8.33M | pat = ~((subblkpat & 2) * 6 + (subblkpat & 1) * 3) & 0xF; |
1184 | 24.8M | for (j = 0; j < 2; j++) { |
1185 | 16.6M | last = subblkpat & (1 << (1 - j)); |
1186 | 16.6M | i = 0; |
1187 | 16.6M | off = j * 32; |
1188 | 49.3M | while (!last) { |
1189 | 33.6M | int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2); |
1190 | 33.6M | if (ret < 0) |
1191 | 91.6k | return ret; |
1192 | 33.5M | i += skip; |
1193 | 33.5M | if (i > 31) |
1194 | 903k | break; |
1195 | 32.6M | if (!v->fcm) |
1196 | 10.9M | idx = v->zz_8x4[i++] + off; |
1197 | 21.7M | else |
1198 | 21.7M | idx = ff_vc1_adv_interlaced_8x4_zz[i++] + off; |
1199 | 32.6M | block[idx] = value * scale; |
1200 | 32.6M | if (!v->pquantizer) |
1201 | 12.5M | block[idx] += (block[idx] < 0) ? -quant : quant; |
1202 | 32.6M | } |
1203 | 16.5M | if (!(subblkpat & (1 << (1 - j))) && !skip_block) { |
1204 | 11.2M | if (i == 1) |
1205 | 2.11M | v->vc1dsp.vc1_inv_trans_8x4_dc(dst + j * 4 * linesize, linesize, block + off); |
1206 | 9.16M | else |
1207 | 9.16M | v->vc1dsp.vc1_inv_trans_8x4(dst + j * 4 * linesize, linesize, block + off); |
1208 | 11.2M | } |
1209 | 16.5M | } |
1210 | 8.24M | break; |
1211 | 11.7M | case TT_4X8: |
1212 | 11.7M | pat = ~(subblkpat * 5) & 0xF; |
1213 | 35.1M | for (j = 0; j < 2; j++) { |
1214 | 23.4M | last = subblkpat & (1 << (1 - j)); |
1215 | 23.4M | i = 0; |
1216 | 23.4M | off = j * 4; |
1217 | 73.2M | while (!last) { |
1218 | 51.3M | int ret = vc1_decode_ac_coeff(v, &last, &skip, &value, v->codingset2); |
1219 | 51.3M | if (ret < 0) |
1220 | 85.6k | return ret; |
1221 | 51.2M | i += skip; |
1222 | 51.2M | if (i > 31) |
1223 | 1.42M | break; |
1224 | 49.8M | if (!v->fcm) |
1225 | 13.3M | idx = v->zz_4x8[i++] + off; |
1226 | 36.4M | else |
1227 | 36.4M | idx = ff_vc1_adv_interlaced_4x8_zz[i++] + off; |
1228 | 49.8M | block[idx] = value * scale; |
1229 | 49.8M | if (!v->pquantizer) |
1230 | 22.2M | block[idx] += (block[idx] < 0) ? -quant : quant; |
1231 | 49.8M | } |
1232 | 23.3M | if (!(subblkpat & (1 << (1 - j))) && !skip_block) { |
1233 | 16.6M | if (i == 1) |
1234 | 3.05M | v->vc1dsp.vc1_inv_trans_4x8_dc(dst + j * 4, linesize, block + off); |
1235 | 13.5M | else |
1236 | 13.5M | v->vc1dsp.vc1_inv_trans_4x8(dst + j*4, linesize, block + off); |
1237 | 16.6M | } |
1238 | 23.3M | } |
1239 | 11.6M | break; |
1240 | 43.9M | } |
1241 | 43.5M | if (ttmb_out) |
1242 | 36.4M | *ttmb_out |= ttblk << (n * 4); |
1243 | 43.5M | return pat; |
1244 | 43.9M | } |
1245 | | |
1246 | | /** @} */ // Macroblock group |
1247 | | |
1248 | | static const uint8_t size_table[6] = { 0, 2, 3, 4, 5, 8 }; |
1249 | | |
1250 | | /** Decode one P-frame MB |
1251 | | */ |
1252 | | static int vc1_decode_p_mb(VC1Context *v) |
1253 | 15.2M | { |
1254 | 15.2M | MpegEncContext *s = &v->s; |
1255 | 15.2M | GetBitContext *const gb = &v->gb; |
1256 | 15.2M | int i, j; |
1257 | 15.2M | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; |
1258 | 15.2M | int cbp; /* cbp decoding stuff */ |
1259 | 15.2M | int mqdiff, mquant; /* MB quantization */ |
1260 | 15.2M | int ttmb = v->ttfrm; /* MB Transform type */ |
1261 | | |
1262 | 15.2M | int mb_has_coeffs = 1; /* last_flag */ |
1263 | 15.2M | int dmv_x, dmv_y; /* Differential MV components */ |
1264 | 15.2M | int index, index1; /* LUT indexes */ |
1265 | 15.2M | int val, sign; /* temp values */ |
1266 | 15.2M | int first_block = 1; |
1267 | 15.2M | int dst_idx, off; |
1268 | 15.2M | int skipped, fourmv; |
1269 | 15.2M | int block_cbp = 0, pat, block_tt = 0, block_intra = 0; |
1270 | 15.2M | int ret; |
1271 | | |
1272 | 15.2M | mquant = v->pq; /* lossy initialization */ |
1273 | | |
1274 | 15.2M | if (v->mv_type_is_raw) |
1275 | 6.66M | fourmv = get_bits1(gb); |
1276 | 8.61M | else |
1277 | 8.61M | fourmv = v->mv_type_mb_plane[mb_pos]; |
1278 | 15.2M | if (v->skip_is_raw) |
1279 | 7.44M | skipped = get_bits1(gb); |
1280 | 7.83M | else |
1281 | 7.83M | skipped = v->s.mbskip_table[mb_pos]; |
1282 | | |
1283 | 15.2M | if (!fourmv) { /* 1MV mode */ |
1284 | 9.79M | if (!skipped) { |
1285 | 4.92M | GET_MVDATA(dmv_x, dmv_y); |
1286 | | |
1287 | 4.92M | if (s->mb_intra) { |
1288 | 414k | s->cur_pic.motion_val[1][s->block_index[0]][0] = 0; |
1289 | 414k | s->cur_pic.motion_val[1][s->block_index[0]][1] = 0; |
1290 | 414k | } |
1291 | 4.92M | s->cur_pic.mb_type[mb_pos] = s->mb_intra ? MB_TYPE_INTRA : MB_TYPE_16x16; |
1292 | 4.92M | ff_vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type, 0, 0); |
1293 | | |
1294 | | /* FIXME Set DC val for inter block ? */ |
1295 | 4.92M | if (s->mb_intra && !mb_has_coeffs) { |
1296 | 56.0k | GET_MQUANT(); |
1297 | 56.0k | s->ac_pred = get_bits1(gb); |
1298 | 56.0k | cbp = 0; |
1299 | 4.87M | } else if (mb_has_coeffs) { |
1300 | 2.90M | if (s->mb_intra) |
1301 | 358k | s->ac_pred = get_bits1(gb); |
1302 | 2.90M | cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2); |
1303 | 2.90M | GET_MQUANT(); |
1304 | 2.90M | } else { |
1305 | 1.97M | mquant = v->pq; |
1306 | 1.97M | cbp = 0; |
1307 | 1.97M | } |
1308 | 4.92M | s->cur_pic.qscale_table[mb_pos] = mquant; |
1309 | | |
1310 | 4.92M | if (!v->ttmbf && !s->mb_intra && mb_has_coeffs) |
1311 | 1.01M | ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], |
1312 | 1.01M | VC1_TTMB_VLC_BITS, 2); |
1313 | 4.92M | if (!s->mb_intra) ff_vc1_mc_1mv(v, 0); |
1314 | 4.92M | dst_idx = 0; |
1315 | 34.4M | for (i = 0; i < 6; i++) { |
1316 | 29.5M | s->dc_val[s->block_index[i]] = 0; |
1317 | 29.5M | dst_idx += i >> 2; |
1318 | 29.5M | val = ((cbp >> (5 - i)) & 1); |
1319 | 29.5M | off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize); |
1320 | 29.5M | v->mb_type[s->block_index[i]] = s->mb_intra; |
1321 | 29.5M | if (s->mb_intra) { |
1322 | | /* check if prediction blocks A and C are available */ |
1323 | 2.47M | v->a_avail = v->c_avail = 0; |
1324 | 2.47M | if (i == 2 || i == 3 || !s->first_slice_line) |
1325 | 2.23M | v->a_avail = v->mb_type[s->block_index[i] - s->block_wrap[i]]; |
1326 | 2.47M | if (i == 1 || i == 3 || s->mb_x) |
1327 | 2.36M | v->c_avail = v->mb_type[s->block_index[i] - 1]; |
1328 | | |
1329 | 2.47M | ret = vc1_decode_intra_block(v, v->block[v->cur_blk_idx][block_map[i]], i, val, mquant, |
1330 | 2.47M | (i & 4) ? v->codingset2 : v->codingset); |
1331 | 2.47M | if (ret < 0) |
1332 | 4.49k | return ret; |
1333 | 2.46M | if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY)) |
1334 | 0 | continue; |
1335 | 2.46M | v->vc1dsp.vc1_inv_trans_8x8(v->block[v->cur_blk_idx][block_map[i]]); |
1336 | 2.46M | if (v->rangeredfrm) |
1337 | 45.3M | for (j = 0; j < 64; j++) |
1338 | 44.7M | v->block[v->cur_blk_idx][block_map[i]][j] *= 2; |
1339 | 2.46M | block_cbp |= 0xF << (i << 2); |
1340 | 2.46M | block_intra |= 1 << i; |
1341 | 27.0M | } else if (val) { |
1342 | 5.72M | pat = vc1_decode_p_block(v, v->block[v->cur_blk_idx][block_map[i]], i, mquant, ttmb, first_block, |
1343 | 5.72M | s->dest[dst_idx] + off, (i & 4) ? s->uvlinesize : s->linesize, |
1344 | 5.72M | CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), &block_tt); |
1345 | 5.72M | if (pat < 0) |
1346 | 11.6k | return pat; |
1347 | 5.71M | block_cbp |= pat << (i << 2); |
1348 | 5.71M | if (!v->ttmbf && ttmb < 8) |
1349 | 2.29M | ttmb = -1; |
1350 | 5.71M | first_block = 0; |
1351 | 5.71M | } |
1352 | 29.5M | } |
1353 | 4.92M | } else { // skipped |
1354 | 4.86M | s->mb_intra = 0; |
1355 | 34.0M | for (i = 0; i < 6; i++) { |
1356 | 29.2M | v->mb_type[s->block_index[i]] = 0; |
1357 | 29.2M | s->dc_val[s->block_index[i]] = 0; |
1358 | 29.2M | } |
1359 | 4.86M | s->cur_pic.mb_type[mb_pos] = MB_TYPE_SKIP; |
1360 | 4.86M | s->cur_pic.qscale_table[mb_pos] = 0; |
1361 | 4.86M | ff_vc1_pred_mv(v, 0, 0, 0, 1, v->range_x, v->range_y, v->mb_type, 0, 0); |
1362 | 4.86M | ff_vc1_mc_1mv(v, 0); |
1363 | 4.86M | } |
1364 | 9.79M | } else { // 4MV mode |
1365 | 5.48M | if (!skipped /* unskipped MB */) { |
1366 | 2.56M | int intra_count = 0, coded_inter = 0; |
1367 | 2.56M | int is_intra[6], is_coded[6]; |
1368 | | /* Get CBPCY */ |
1369 | 2.56M | cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2); |
1370 | 17.9M | for (i = 0; i < 6; i++) { |
1371 | 15.4M | val = ((cbp >> (5 - i)) & 1); |
1372 | 15.4M | s->dc_val[s->block_index[i]] = 0; |
1373 | 15.4M | s->mb_intra = 0; |
1374 | 15.4M | if (i < 4) { |
1375 | 10.2M | dmv_x = dmv_y = 0; |
1376 | 10.2M | s->mb_intra = 0; |
1377 | 10.2M | mb_has_coeffs = 0; |
1378 | 10.2M | if (val) { |
1379 | 5.20M | GET_MVDATA(dmv_x, dmv_y); |
1380 | 5.20M | } |
1381 | 10.2M | ff_vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type, 0, 0); |
1382 | 10.2M | if (!s->mb_intra) |
1383 | 9.59M | ff_vc1_mc_4mv_luma(v, i, 0, 0); |
1384 | 10.2M | intra_count += s->mb_intra; |
1385 | 10.2M | is_intra[i] = s->mb_intra; |
1386 | 10.2M | is_coded[i] = mb_has_coeffs; |
1387 | 10.2M | } |
1388 | 15.4M | if (i & 4) { |
1389 | 5.13M | is_intra[i] = (intra_count >= 3); |
1390 | 5.13M | is_coded[i] = val; |
1391 | 5.13M | } |
1392 | 15.4M | if (i == 4) |
1393 | 2.56M | ff_vc1_mc_4mv_chroma(v, 0); |
1394 | 15.4M | v->mb_type[s->block_index[i]] = is_intra[i]; |
1395 | 15.4M | if (!coded_inter) |
1396 | 7.64M | coded_inter = !is_intra[i] & is_coded[i]; |
1397 | 15.4M | } |
1398 | | // if there are no coded blocks then don't do anything more |
1399 | 2.56M | dst_idx = 0; |
1400 | 2.56M | if (!intra_count && !coded_inter) |
1401 | 335k | goto end; |
1402 | 2.23M | GET_MQUANT(); |
1403 | 2.23M | s->cur_pic.qscale_table[mb_pos] = mquant; |
1404 | | /* test if block is intra and has pred */ |
1405 | 2.23M | { |
1406 | 2.23M | int intrapred = 0; |
1407 | 15.2M | for (i = 0; i < 6; i++) |
1408 | 13.0M | if (is_intra[i]) { |
1409 | 644k | if (((!s->first_slice_line || (i == 2 || i == 3)) && v->mb_type[s->block_index[i] - s->block_wrap[i]]) |
1410 | 604k | || ((s->mb_x || (i == 1 || i == 3)) && v->mb_type[s->block_index[i] - 1])) { |
1411 | 91.7k | intrapred = 1; |
1412 | 91.7k | break; |
1413 | 91.7k | } |
1414 | 644k | } |
1415 | 2.23M | if (intrapred) |
1416 | 91.7k | s->ac_pred = get_bits1(gb); |
1417 | 2.14M | else |
1418 | 2.14M | s->ac_pred = 0; |
1419 | 2.23M | } |
1420 | 2.23M | if (!v->ttmbf && coded_inter) |
1421 | 1.22M | ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2); |
1422 | 15.5M | for (i = 0; i < 6; i++) { |
1423 | 13.3M | dst_idx += i >> 2; |
1424 | 13.3M | off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize); |
1425 | 13.3M | s->mb_intra = is_intra[i]; |
1426 | 13.3M | if (is_intra[i]) { |
1427 | | /* check if prediction blocks A and C are available */ |
1428 | 736k | v->a_avail = v->c_avail = 0; |
1429 | 736k | if (i == 2 || i == 3 || !s->first_slice_line) |
1430 | 694k | v->a_avail = v->mb_type[s->block_index[i] - s->block_wrap[i]]; |
1431 | 736k | if (i == 1 || i == 3 || s->mb_x) |
1432 | 717k | v->c_avail = v->mb_type[s->block_index[i] - 1]; |
1433 | | |
1434 | 736k | ret = vc1_decode_intra_block(v, v->block[v->cur_blk_idx][block_map[i]], i, is_coded[i], mquant, |
1435 | 736k | (i & 4) ? v->codingset2 : v->codingset); |
1436 | 736k | if (ret < 0) |
1437 | 4.26k | return ret; |
1438 | 732k | if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY)) |
1439 | 0 | continue; |
1440 | 732k | v->vc1dsp.vc1_inv_trans_8x8(v->block[v->cur_blk_idx][block_map[i]]); |
1441 | 732k | if (v->rangeredfrm) |
1442 | 19.5M | for (j = 0; j < 64; j++) |
1443 | 19.2M | v->block[v->cur_blk_idx][block_map[i]][j] *= 2; |
1444 | 732k | block_cbp |= 0xF << (i << 2); |
1445 | 732k | block_intra |= 1 << i; |
1446 | 12.6M | } else if (is_coded[i]) { |
1447 | 4.51M | pat = vc1_decode_p_block(v, v->block[v->cur_blk_idx][block_map[i]], i, mquant, ttmb, |
1448 | 4.51M | first_block, s->dest[dst_idx] + off, |
1449 | 4.51M | (i & 4) ? s->uvlinesize : s->linesize, |
1450 | 4.51M | CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), |
1451 | 4.51M | &block_tt); |
1452 | 4.51M | if (pat < 0) |
1453 | 4.98k | return pat; |
1454 | 4.51M | block_cbp |= pat << (i << 2); |
1455 | 4.51M | if (!v->ttmbf && ttmb < 8) |
1456 | 2.26M | ttmb = -1; |
1457 | 4.51M | first_block = 0; |
1458 | 4.51M | } |
1459 | 13.3M | } |
1460 | 2.91M | } else { // skipped MB |
1461 | 2.91M | s->mb_intra = 0; |
1462 | 2.91M | s->cur_pic.qscale_table[mb_pos] = 0; |
1463 | 20.3M | for (i = 0; i < 6; i++) { |
1464 | 17.4M | v->mb_type[s->block_index[i]] = 0; |
1465 | 17.4M | s->dc_val[s->block_index[i]] = 0; |
1466 | 17.4M | } |
1467 | 14.5M | for (i = 0; i < 4; i++) { |
1468 | 11.6M | ff_vc1_pred_mv(v, i, 0, 0, 0, v->range_x, v->range_y, v->mb_type, 0, 0); |
1469 | 11.6M | ff_vc1_mc_4mv_luma(v, i, 0, 0); |
1470 | 11.6M | } |
1471 | 2.91M | ff_vc1_mc_4mv_chroma(v, 0); |
1472 | 2.91M | s->cur_pic.qscale_table[mb_pos] = 0; |
1473 | 2.91M | } |
1474 | 5.48M | } |
1475 | 15.2M | end: |
1476 | 15.2M | if (v->overlap && v->pq >= 9) |
1477 | 11.5M | ff_vc1_p_overlap_filter(v); |
1478 | 15.2M | vc1_put_blocks_clamped(v, 1); |
1479 | | |
1480 | 15.2M | v->cbp[s->mb_x] = block_cbp; |
1481 | 15.2M | v->ttblk[s->mb_x] = block_tt; |
1482 | 15.2M | v->is_intra[s->mb_x] = block_intra; |
1483 | | |
1484 | 15.2M | return 0; |
1485 | 15.2M | } |
1486 | | |
1487 | | /* Decode one macroblock in an interlaced frame p picture */ |
1488 | | |
1489 | | static int vc1_decode_p_mb_intfr(VC1Context *v) |
1490 | 13.2M | { |
1491 | 13.2M | MpegEncContext *s = &v->s; |
1492 | 13.2M | GetBitContext *const gb = &v->gb; |
1493 | 13.2M | int i; |
1494 | 13.2M | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; |
1495 | 13.2M | int cbp = 0; /* cbp decoding stuff */ |
1496 | 13.2M | int mqdiff, mquant; /* MB quantization */ |
1497 | 13.2M | int ttmb = v->ttfrm; /* MB Transform type */ |
1498 | | |
1499 | 13.2M | int mb_has_coeffs = 1; /* last_flag */ |
1500 | 13.2M | int dmv_x, dmv_y; /* Differential MV components */ |
1501 | 13.2M | int val; /* temp value */ |
1502 | 13.2M | int first_block = 1; |
1503 | 13.2M | int dst_idx, off; |
1504 | 13.2M | int skipped, fourmv = 0, twomv = 0; |
1505 | 13.2M | int block_cbp = 0, pat, block_tt = 0; |
1506 | 13.2M | int idx_mbmode = 0, mvbp; |
1507 | 13.2M | int fieldtx; |
1508 | 13.2M | int ret; |
1509 | | |
1510 | 13.2M | mquant = v->pq; /* Lossy initialization */ |
1511 | | |
1512 | 13.2M | if (v->skip_is_raw) |
1513 | 8.16M | skipped = get_bits1(gb); |
1514 | 5.05M | else |
1515 | 5.05M | skipped = v->s.mbskip_table[mb_pos]; |
1516 | 13.2M | if (!skipped) { |
1517 | 7.29M | if (v->fourmvswitch) |
1518 | 4.58M | idx_mbmode = get_vlc2(gb, v->mbmode_vlc, VC1_INTFR_4MV_MBMODE_VLC_BITS, 2); // try getting this done |
1519 | 2.70M | else |
1520 | 2.70M | idx_mbmode = get_vlc2(gb, v->mbmode_vlc, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); // in a single line |
1521 | 7.29M | switch (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0]) { |
1522 | | /* store the motion vector type in a flag (useful later) */ |
1523 | 112k | case MV_PMODE_INTFR_4MV: |
1524 | 112k | fourmv = 1; |
1525 | 112k | v->blk_mv_type[s->block_index[0]] = 0; |
1526 | 112k | v->blk_mv_type[s->block_index[1]] = 0; |
1527 | 112k | v->blk_mv_type[s->block_index[2]] = 0; |
1528 | 112k | v->blk_mv_type[s->block_index[3]] = 0; |
1529 | 112k | break; |
1530 | 525k | case MV_PMODE_INTFR_4MV_FIELD: |
1531 | 525k | fourmv = 1; |
1532 | 525k | v->blk_mv_type[s->block_index[0]] = 1; |
1533 | 525k | v->blk_mv_type[s->block_index[1]] = 1; |
1534 | 525k | v->blk_mv_type[s->block_index[2]] = 1; |
1535 | 525k | v->blk_mv_type[s->block_index[3]] = 1; |
1536 | 525k | break; |
1537 | 3.11M | case MV_PMODE_INTFR_2MV_FIELD: |
1538 | 3.11M | twomv = 1; |
1539 | 3.11M | v->blk_mv_type[s->block_index[0]] = 1; |
1540 | 3.11M | v->blk_mv_type[s->block_index[1]] = 1; |
1541 | 3.11M | v->blk_mv_type[s->block_index[2]] = 1; |
1542 | 3.11M | v->blk_mv_type[s->block_index[3]] = 1; |
1543 | 3.11M | break; |
1544 | 3.37M | case MV_PMODE_INTFR_1MV: |
1545 | 3.37M | v->blk_mv_type[s->block_index[0]] = 0; |
1546 | 3.37M | v->blk_mv_type[s->block_index[1]] = 0; |
1547 | 3.37M | v->blk_mv_type[s->block_index[2]] = 0; |
1548 | 3.37M | v->blk_mv_type[s->block_index[3]] = 0; |
1549 | 3.37M | break; |
1550 | 7.29M | } |
1551 | 7.29M | if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB |
1552 | 839k | for (i = 0; i < 4; i++) { |
1553 | 671k | s->cur_pic.motion_val[1][s->block_index[i]][0] = 0; |
1554 | 671k | s->cur_pic.motion_val[1][s->block_index[i]][1] = 0; |
1555 | 671k | } |
1556 | 167k | v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1. |
1557 | 167k | s->mb_intra = 1; |
1558 | 167k | s->cur_pic.mb_type[mb_pos] = MB_TYPE_INTRA; |
1559 | 167k | fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb); |
1560 | 167k | mb_has_coeffs = get_bits1(gb); |
1561 | 167k | if (mb_has_coeffs) |
1562 | 94.3k | cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2); |
1563 | 167k | v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb); |
1564 | 167k | GET_MQUANT(); |
1565 | 167k | s->cur_pic.qscale_table[mb_pos] = mquant; |
1566 | | /* Set DC scale - y and c use the same so we only set y */ |
1567 | 167k | s->y_dc_scale = ff_wmv3_dc_scale_table[FFABS(mquant)]; |
1568 | 167k | dst_idx = 0; |
1569 | 1.17M | for (i = 0; i < 6; i++) { |
1570 | 1.00M | v->a_avail = v->c_avail = 0; |
1571 | 1.00M | v->mb_type[s->block_index[i]] = 1; |
1572 | 1.00M | s->dc_val[s->block_index[i]] = 0; |
1573 | 1.00M | dst_idx += i >> 2; |
1574 | 1.00M | val = ((cbp >> (5 - i)) & 1); |
1575 | 1.00M | if (i == 2 || i == 3 || !s->first_slice_line) |
1576 | 961k | v->a_avail = v->mb_type[s->block_index[i] - s->block_wrap[i]]; |
1577 | 1.00M | if (i == 1 || i == 3 || s->mb_x) |
1578 | 975k | v->c_avail = v->mb_type[s->block_index[i] - 1]; |
1579 | | |
1580 | 1.00M | ret = vc1_decode_intra_block(v, v->block[v->cur_blk_idx][block_map[i]], i, val, mquant, |
1581 | 1.00M | (i & 4) ? v->codingset2 : v->codingset); |
1582 | 1.00M | if (ret < 0) |
1583 | 742 | return ret; |
1584 | 1.00M | if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY)) |
1585 | 0 | continue; |
1586 | 1.00M | v->vc1dsp.vc1_inv_trans_8x8(v->block[v->cur_blk_idx][block_map[i]]); |
1587 | 1.00M | block_cbp |= 0xf << (i << 2); |
1588 | 1.00M | } |
1589 | | |
1590 | 7.12M | } else { // inter MB |
1591 | 7.12M | mb_has_coeffs = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][3]; |
1592 | 7.12M | if (mb_has_coeffs) |
1593 | 3.23M | cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2); |
1594 | 7.12M | if (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) { |
1595 | 3.11M | v->twomvbp = get_vlc2(gb, v->twomvbp_vlc, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1); |
1596 | 4.01M | } else { |
1597 | 4.01M | if ((ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV) |
1598 | 3.89M | || (ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][0] == MV_PMODE_INTFR_4MV_FIELD)) { |
1599 | 637k | v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1); |
1600 | 637k | } |
1601 | 4.01M | } |
1602 | 7.12M | s->mb_intra = v->is_intra[s->mb_x] = 0; |
1603 | 49.8M | for (i = 0; i < 6; i++) |
1604 | 42.7M | v->mb_type[s->block_index[i]] = 0; |
1605 | 7.12M | fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][1]; |
1606 | | /* for all motion vector read MVDATA and motion compensate each block */ |
1607 | 7.12M | dst_idx = 0; |
1608 | 7.12M | if (fourmv) { |
1609 | 637k | mvbp = v->fourmvbp; |
1610 | 3.18M | for (i = 0; i < 4; i++) { |
1611 | 2.55M | dmv_x = dmv_y = 0; |
1612 | 2.55M | if (mvbp & (8 >> i)) |
1613 | 1.66M | get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0); |
1614 | 2.55M | ff_vc1_pred_mv_intfr(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, 0); |
1615 | 2.55M | ff_vc1_mc_4mv_luma(v, i, 0, 0); |
1616 | 2.55M | } |
1617 | 637k | ff_vc1_mc_4mv_chroma4(v, 0, 0, 0); |
1618 | 6.48M | } else if (twomv) { |
1619 | 3.11M | mvbp = v->twomvbp; |
1620 | 3.11M | dmv_x = dmv_y = 0; |
1621 | 3.11M | if (mvbp & 2) { |
1622 | 1.38M | get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0); |
1623 | 1.38M | } |
1624 | 3.11M | ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, 0); |
1625 | 3.11M | ff_vc1_mc_4mv_luma(v, 0, 0, 0); |
1626 | 3.11M | ff_vc1_mc_4mv_luma(v, 1, 0, 0); |
1627 | 3.11M | dmv_x = dmv_y = 0; |
1628 | 3.11M | if (mvbp & 1) { |
1629 | 1.41M | get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0); |
1630 | 1.41M | } |
1631 | 3.11M | ff_vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, 0); |
1632 | 3.11M | ff_vc1_mc_4mv_luma(v, 2, 0, 0); |
1633 | 3.11M | ff_vc1_mc_4mv_luma(v, 3, 0, 0); |
1634 | 3.11M | ff_vc1_mc_4mv_chroma4(v, 0, 0, 0); |
1635 | 3.37M | } else { |
1636 | 3.37M | mvbp = ff_vc1_mbmode_intfrp[v->fourmvswitch][idx_mbmode][2]; |
1637 | 3.37M | dmv_x = dmv_y = 0; |
1638 | 3.37M | if (mvbp) { |
1639 | 2.99M | get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0); |
1640 | 2.99M | } |
1641 | 3.37M | ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, 0); |
1642 | 3.37M | ff_vc1_mc_1mv(v, 0); |
1643 | 3.37M | } |
1644 | 7.12M | if (cbp) |
1645 | 3.23M | GET_MQUANT(); // p. 227 |
1646 | 7.12M | s->cur_pic.qscale_table[mb_pos] = mquant; |
1647 | 7.12M | if (!v->ttmbf && cbp) |
1648 | 1.96M | ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2); |
1649 | 49.8M | for (i = 0; i < 6; i++) { |
1650 | 42.7M | s->dc_val[s->block_index[i]] = 0; |
1651 | 42.7M | dst_idx += i >> 2; |
1652 | 42.7M | val = ((cbp >> (5 - i)) & 1); |
1653 | 42.7M | if (!fieldtx) |
1654 | 20.1M | off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize); |
1655 | 22.5M | else |
1656 | 22.5M | off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize)); |
1657 | 42.7M | if (val) { |
1658 | 9.63M | pat = vc1_decode_p_block(v, v->block[v->cur_blk_idx][block_map[i]], i, mquant, ttmb, |
1659 | 9.63M | first_block, s->dest[dst_idx] + off, |
1660 | 9.63M | (i & 4) ? s->uvlinesize : (s->linesize << fieldtx), |
1661 | 9.63M | CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), &block_tt); |
1662 | 9.63M | if (pat < 0) |
1663 | 5.35k | return pat; |
1664 | 9.62M | block_cbp |= pat << (i << 2); |
1665 | 9.62M | if (!v->ttmbf && ttmb < 8) |
1666 | 4.89M | ttmb = -1; |
1667 | 9.62M | first_block = 0; |
1668 | 9.62M | } |
1669 | 42.7M | } |
1670 | 7.12M | } |
1671 | 7.29M | } else { // skipped |
1672 | 5.92M | s->mb_intra = v->is_intra[s->mb_x] = 0; |
1673 | 41.5M | for (i = 0; i < 6; i++) { |
1674 | 35.5M | v->mb_type[s->block_index[i]] = 0; |
1675 | 35.5M | s->dc_val[s->block_index[i]] = 0; |
1676 | 35.5M | } |
1677 | 5.92M | s->cur_pic.mb_type[mb_pos] = MB_TYPE_SKIP; |
1678 | 5.92M | s->cur_pic.qscale_table[mb_pos] = 0; |
1679 | 5.92M | v->blk_mv_type[s->block_index[0]] = 0; |
1680 | 5.92M | v->blk_mv_type[s->block_index[1]] = 0; |
1681 | 5.92M | v->blk_mv_type[s->block_index[2]] = 0; |
1682 | 5.92M | v->blk_mv_type[s->block_index[3]] = 0; |
1683 | 5.92M | ff_vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, 0); |
1684 | 5.92M | ff_vc1_mc_1mv(v, 0); |
1685 | 5.92M | v->fieldtx_plane[mb_pos] = 0; |
1686 | 5.92M | } |
1687 | 13.2M | if (v->overlap && v->pq >= 9) |
1688 | 7.71M | ff_vc1_p_overlap_filter(v); |
1689 | 13.2M | vc1_put_blocks_clamped(v, 1); |
1690 | | |
1691 | 13.2M | v->cbp[s->mb_x] = block_cbp; |
1692 | 13.2M | v->ttblk[s->mb_x] = block_tt; |
1693 | | |
1694 | 13.2M | return 0; |
1695 | 13.2M | } |
1696 | | |
1697 | | static int vc1_decode_p_mb_intfi(VC1Context *v) |
1698 | 1.79M | { |
1699 | 1.79M | MpegEncContext *s = &v->s; |
1700 | 1.79M | GetBitContext *const gb = &v->gb; |
1701 | 1.79M | int i; |
1702 | 1.79M | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; |
1703 | 1.79M | int cbp = 0; /* cbp decoding stuff */ |
1704 | 1.79M | int mqdiff, mquant; /* MB quantization */ |
1705 | 1.79M | int ttmb = v->ttfrm; /* MB Transform type */ |
1706 | | |
1707 | 1.79M | int mb_has_coeffs = 1; /* last_flag */ |
1708 | 1.79M | int dmv_x, dmv_y; /* Differential MV components */ |
1709 | 1.79M | int val; /* temp values */ |
1710 | 1.79M | int first_block = 1; |
1711 | 1.79M | int dst_idx, off; |
1712 | 1.79M | int pred_flag = 0; |
1713 | 1.79M | int block_cbp = 0, pat, block_tt = 0; |
1714 | 1.79M | int idx_mbmode = 0; |
1715 | 1.79M | int ret; |
1716 | | |
1717 | 1.79M | mquant = v->pq; /* Lossy initialization */ |
1718 | | |
1719 | 1.79M | idx_mbmode = get_vlc2(gb, v->mbmode_vlc, VC1_IF_MBMODE_VLC_BITS, 2); |
1720 | 1.79M | if (idx_mbmode <= 1) { // intra MB |
1721 | 134k | v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1. |
1722 | 134k | s->mb_intra = 1; |
1723 | 134k | s->cur_pic.motion_val[1][s->block_index[0] + v->blocks_off][0] = 0; |
1724 | 134k | s->cur_pic.motion_val[1][s->block_index[0] + v->blocks_off][1] = 0; |
1725 | 134k | s->cur_pic.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA; |
1726 | 134k | GET_MQUANT(); |
1727 | 134k | s->cur_pic.qscale_table[mb_pos] = mquant; |
1728 | | /* Set DC scale - y and c use the same so we only set y */ |
1729 | 134k | s->y_dc_scale = ff_wmv3_dc_scale_table[FFABS(mquant)]; |
1730 | 134k | v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb); |
1731 | 134k | mb_has_coeffs = idx_mbmode & 1; |
1732 | 134k | if (mb_has_coeffs) |
1733 | 33.0k | cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2); |
1734 | 134k | dst_idx = 0; |
1735 | 935k | for (i = 0; i < 6; i++) { |
1736 | 802k | v->a_avail = v->c_avail = 0; |
1737 | 802k | v->mb_type[s->block_index[i]] = 1; |
1738 | 802k | s->dc_val[s->block_index[i]] = 0; |
1739 | 802k | dst_idx += i >> 2; |
1740 | 802k | val = ((cbp >> (5 - i)) & 1); |
1741 | 802k | if (i == 2 || i == 3 || !s->first_slice_line) |
1742 | 700k | v->a_avail = v->mb_type[s->block_index[i] - s->block_wrap[i]]; |
1743 | 802k | if (i == 1 || i == 3 || s->mb_x) |
1744 | 748k | v->c_avail = v->mb_type[s->block_index[i] - 1]; |
1745 | | |
1746 | 802k | ret = vc1_decode_intra_block(v, v->block[v->cur_blk_idx][block_map[i]], i, val, mquant, |
1747 | 802k | (i & 4) ? v->codingset2 : v->codingset); |
1748 | 802k | if (ret < 0) |
1749 | 704 | return ret; |
1750 | 801k | if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY)) |
1751 | 0 | continue; |
1752 | 801k | v->vc1dsp.vc1_inv_trans_8x8(v->block[v->cur_blk_idx][block_map[i]]); |
1753 | 801k | block_cbp |= 0xf << (i << 2); |
1754 | 801k | } |
1755 | 1.66M | } else { |
1756 | 1.66M | s->mb_intra = v->is_intra[s->mb_x] = 0; |
1757 | 1.66M | s->cur_pic.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16; |
1758 | 11.6M | for (i = 0; i < 6; i++) |
1759 | 9.98M | v->mb_type[s->block_index[i]] = 0; |
1760 | 1.66M | if (idx_mbmode <= 5) { // 1-MV |
1761 | 1.43M | dmv_x = dmv_y = pred_flag = 0; |
1762 | 1.43M | if (idx_mbmode & 1) { |
1763 | 522k | get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag); |
1764 | 522k | } |
1765 | 1.43M | ff_vc1_pred_mv(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, v->mb_type, pred_flag, 0); |
1766 | 1.43M | ff_vc1_mc_1mv(v, 0); |
1767 | 1.43M | mb_has_coeffs = !(idx_mbmode & 2); |
1768 | 1.43M | } else { // 4-MV |
1769 | 231k | v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1); |
1770 | 1.15M | for (i = 0; i < 4; i++) { |
1771 | 926k | dmv_x = dmv_y = pred_flag = 0; |
1772 | 926k | if (v->fourmvbp & (8 >> i)) |
1773 | 624k | get_mvdata_interlaced(v, &dmv_x, &dmv_y, &pred_flag); |
1774 | 926k | ff_vc1_pred_mv(v, i, dmv_x, dmv_y, 0, v->range_x, v->range_y, v->mb_type, pred_flag, 0); |
1775 | 926k | ff_vc1_mc_4mv_luma(v, i, 0, 0); |
1776 | 926k | } |
1777 | 231k | ff_vc1_mc_4mv_chroma(v, 0); |
1778 | 231k | mb_has_coeffs = idx_mbmode & 1; |
1779 | 231k | } |
1780 | 1.66M | if (mb_has_coeffs) |
1781 | 898k | cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2); |
1782 | 1.66M | if (cbp) { |
1783 | 898k | GET_MQUANT(); |
1784 | 898k | } |
1785 | 1.66M | s->cur_pic.qscale_table[mb_pos] = mquant; |
1786 | 1.66M | if (!v->ttmbf && cbp) { |
1787 | 381k | ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2); |
1788 | 381k | } |
1789 | 1.66M | dst_idx = 0; |
1790 | 11.6M | for (i = 0; i < 6; i++) { |
1791 | 9.97M | s->dc_val[s->block_index[i]] = 0; |
1792 | 9.97M | dst_idx += i >> 2; |
1793 | 9.97M | val = ((cbp >> (5 - i)) & 1); |
1794 | 9.97M | off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize; |
1795 | 9.97M | if (val) { |
1796 | 3.28M | pat = vc1_decode_p_block(v, v->block[v->cur_blk_idx][block_map[i]], i, mquant, ttmb, |
1797 | 3.28M | first_block, s->dest[dst_idx] + off, |
1798 | 3.28M | (i & 4) ? s->uvlinesize : s->linesize, |
1799 | 3.28M | CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), |
1800 | 3.28M | &block_tt); |
1801 | 3.28M | if (pat < 0) |
1802 | 2.94k | return pat; |
1803 | 3.28M | block_cbp |= pat << (i << 2); |
1804 | 3.28M | if (!v->ttmbf && ttmb < 8) |
1805 | 963k | ttmb = -1; |
1806 | 3.28M | first_block = 0; |
1807 | 3.28M | } |
1808 | 9.97M | } |
1809 | 1.66M | } |
1810 | 1.79M | if (v->overlap && v->pq >= 9) |
1811 | 842k | ff_vc1_p_overlap_filter(v); |
1812 | 1.79M | vc1_put_blocks_clamped(v, 1); |
1813 | | |
1814 | 1.79M | v->cbp[s->mb_x] = block_cbp; |
1815 | 1.79M | v->ttblk[s->mb_x] = block_tt; |
1816 | | |
1817 | 1.79M | return 0; |
1818 | 1.79M | } |
1819 | | |
1820 | | /** Decode one B-frame MB (in Main profile) |
1821 | | */ |
1822 | | static int vc1_decode_b_mb(VC1Context *v) |
1823 | 9.09M | { |
1824 | 9.09M | MpegEncContext *s = &v->s; |
1825 | 9.09M | GetBitContext *const gb = &v->gb; |
1826 | 9.09M | int i, j; |
1827 | 9.09M | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; |
1828 | 9.09M | int cbp = 0; /* cbp decoding stuff */ |
1829 | 9.09M | int mqdiff, mquant; /* MB quantization */ |
1830 | 9.09M | int ttmb = v->ttfrm; /* MB Transform type */ |
1831 | 9.09M | int mb_has_coeffs = 0; /* last_flag */ |
1832 | 9.09M | int index, index1; /* LUT indexes */ |
1833 | 9.09M | int val, sign; /* temp values */ |
1834 | 9.09M | int first_block = 1; |
1835 | 9.09M | int dst_idx, off; |
1836 | 9.09M | int skipped, direct; |
1837 | 9.09M | int dmv_x[2], dmv_y[2]; |
1838 | 9.09M | int bmvtype = BMV_TYPE_BACKWARD; |
1839 | 9.09M | int ret; |
1840 | | |
1841 | 9.09M | mquant = v->pq; /* lossy initialization */ |
1842 | 9.09M | s->mb_intra = 0; |
1843 | | |
1844 | 9.09M | if (v->dmb_is_raw) |
1845 | 1.56M | direct = get_bits1(gb); |
1846 | 7.53M | else |
1847 | 7.53M | direct = v->direct_mb_plane[mb_pos]; |
1848 | 9.09M | if (v->skip_is_raw) |
1849 | 3.86M | skipped = get_bits1(gb); |
1850 | 5.23M | else |
1851 | 5.23M | skipped = v->s.mbskip_table[mb_pos]; |
1852 | | |
1853 | 9.09M | dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0; |
1854 | 63.6M | for (i = 0; i < 6; i++) { |
1855 | 54.5M | v->mb_type[s->block_index[i]] = 0; |
1856 | 54.5M | s->dc_val[s->block_index[i]] = 0; |
1857 | 54.5M | } |
1858 | 9.09M | s->cur_pic.qscale_table[mb_pos] = 0; |
1859 | | |
1860 | 9.09M | if (!direct) { |
1861 | 6.35M | if (!skipped) { |
1862 | 3.65M | GET_MVDATA(dmv_x[0], dmv_y[0]); |
1863 | 3.65M | dmv_x[1] = dmv_x[0]; |
1864 | 3.65M | dmv_y[1] = dmv_y[0]; |
1865 | 3.65M | } |
1866 | 6.35M | if (skipped || !s->mb_intra) { |
1867 | 5.97M | bmvtype = decode012(gb); |
1868 | 5.97M | switch (bmvtype) { |
1869 | 3.45M | case 0: |
1870 | 3.45M | bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD; |
1871 | 3.45M | break; |
1872 | 1.00M | case 1: |
1873 | 1.00M | bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD; |
1874 | 1.00M | break; |
1875 | 1.51M | case 2: |
1876 | 1.51M | bmvtype = BMV_TYPE_INTERPOLATED; |
1877 | 1.51M | dmv_x[0] = dmv_y[0] = 0; |
1878 | 5.97M | } |
1879 | 5.97M | } |
1880 | 6.35M | } |
1881 | 63.6M | for (i = 0; i < 6; i++) |
1882 | 54.5M | v->mb_type[s->block_index[i]] = s->mb_intra; |
1883 | | |
1884 | 9.09M | if (skipped) { |
1885 | 4.24M | if (direct) |
1886 | 1.54M | bmvtype = BMV_TYPE_INTERPOLATED; |
1887 | 4.24M | ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype); |
1888 | 4.24M | vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype); |
1889 | 4.24M | return 0; |
1890 | 4.24M | } |
1891 | 4.84M | if (direct) { |
1892 | 1.19M | cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2); |
1893 | 1.19M | GET_MQUANT(); |
1894 | 1.19M | s->mb_intra = 0; |
1895 | 1.19M | s->cur_pic.qscale_table[mb_pos] = mquant; |
1896 | 1.19M | if (!v->ttmbf) |
1897 | 879k | ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2); |
1898 | 1.19M | dmv_x[0] = dmv_y[0] = dmv_x[1] = dmv_y[1] = 0; |
1899 | 1.19M | ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype); |
1900 | 1.19M | vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype); |
1901 | 3.65M | } else { |
1902 | 3.65M | if (!mb_has_coeffs && !s->mb_intra) { |
1903 | | /* no coded blocks - effectively skipped */ |
1904 | 1.49M | ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype); |
1905 | 1.49M | vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype); |
1906 | 1.49M | return 0; |
1907 | 1.49M | } |
1908 | 2.15M | if (s->mb_intra && !mb_has_coeffs) { |
1909 | 61.8k | GET_MQUANT(); |
1910 | 61.8k | s->cur_pic.qscale_table[mb_pos] = mquant; |
1911 | 61.8k | s->ac_pred = get_bits1(gb); |
1912 | 61.8k | cbp = 0; |
1913 | 61.8k | ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype); |
1914 | 2.09M | } else { |
1915 | 2.09M | if (bmvtype == BMV_TYPE_INTERPOLATED) { |
1916 | 434k | GET_MVDATA(dmv_x[0], dmv_y[0]); |
1917 | 434k | if (!mb_has_coeffs) { |
1918 | | /* interpolated skipped block */ |
1919 | 79.1k | ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype); |
1920 | 79.1k | vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype); |
1921 | 79.1k | return 0; |
1922 | 79.1k | } |
1923 | 434k | } |
1924 | 2.01M | ff_vc1_pred_b_mv(v, dmv_x, dmv_y, direct, bmvtype); |
1925 | 2.01M | if (!s->mb_intra) { |
1926 | 1.62M | vc1_b_mc(v, dmv_x, dmv_y, direct, bmvtype); |
1927 | 1.62M | } |
1928 | 2.01M | if (s->mb_intra) |
1929 | 386k | s->ac_pred = get_bits1(gb); |
1930 | 2.01M | cbp = get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2); |
1931 | 2.01M | GET_MQUANT(); |
1932 | 2.01M | s->cur_pic.qscale_table[mb_pos] = mquant; |
1933 | 2.01M | if (!v->ttmbf && !s->mb_intra && mb_has_coeffs) |
1934 | 1.20M | ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2); |
1935 | 2.01M | } |
1936 | 2.15M | } |
1937 | 3.26M | dst_idx = 0; |
1938 | 22.4M | for (i = 0; i < 6; i++) { |
1939 | 19.2M | s->dc_val[s->block_index[i]] = 0; |
1940 | 19.2M | dst_idx += i >> 2; |
1941 | 19.2M | val = ((cbp >> (5 - i)) & 1); |
1942 | 19.2M | off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize); |
1943 | 19.2M | v->mb_type[s->block_index[i]] = s->mb_intra; |
1944 | 19.2M | if (s->mb_intra) { |
1945 | | /* check if prediction blocks A and C are available */ |
1946 | 2.62M | v->a_avail = v->c_avail = 0; |
1947 | 2.62M | if (i == 2 || i == 3 || !s->first_slice_line) |
1948 | 2.53M | v->a_avail = v->mb_type[s->block_index[i] - s->block_wrap[i]]; |
1949 | 2.62M | if (i == 1 || i == 3 || s->mb_x) |
1950 | 2.58M | v->c_avail = v->mb_type[s->block_index[i] - 1]; |
1951 | | |
1952 | 2.62M | ret = vc1_decode_intra_block(v, v->blocks[i], i, val, mquant, |
1953 | 2.62M | (i & 4) ? v->codingset2 : v->codingset); |
1954 | 2.62M | if (ret < 0) |
1955 | 16.9k | return ret; |
1956 | 2.61M | if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY)) |
1957 | 0 | continue; |
1958 | 2.61M | v->vc1dsp.vc1_inv_trans_8x8(v->blocks[i]); |
1959 | 2.61M | if (v->rangeredfrm) |
1960 | 19.2M | for (j = 0; j < 64; j++) |
1961 | 18.9M | v->blocks[i][j] *= 2; |
1962 | 2.61M | s->idsp.put_signed_pixels_clamped(v->blocks[i], |
1963 | 2.61M | s->dest[dst_idx] + off, |
1964 | 2.61M | i & 4 ? s->uvlinesize |
1965 | 2.61M | : s->linesize); |
1966 | 16.6M | } else if (val) { |
1967 | 7.12M | int pat = vc1_decode_p_block(v, v->blocks[i], i, mquant, ttmb, |
1968 | 7.12M | first_block, s->dest[dst_idx] + off, |
1969 | 7.12M | (i & 4) ? s->uvlinesize : s->linesize, |
1970 | 7.12M | CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), NULL); |
1971 | 7.12M | if (pat < 0) |
1972 | 83.8k | return pat; |
1973 | 7.03M | if (!v->ttmbf && ttmb < 8) |
1974 | 3.93M | ttmb = -1; |
1975 | 7.03M | first_block = 0; |
1976 | 7.03M | } |
1977 | 19.2M | } |
1978 | 3.16M | return 0; |
1979 | 3.26M | } |
1980 | | |
1981 | | /** Decode one B-frame MB (in interlaced field B picture) |
1982 | | */ |
1983 | | static int vc1_decode_b_mb_intfi(VC1Context *v) |
1984 | 1.32M | { |
1985 | 1.32M | MpegEncContext *s = &v->s; |
1986 | 1.32M | GetBitContext *const gb = &v->gb; |
1987 | 1.32M | int i, j; |
1988 | 1.32M | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; |
1989 | 1.32M | int cbp = 0; /* cbp decoding stuff */ |
1990 | 1.32M | int mqdiff, mquant; /* MB quantization */ |
1991 | 1.32M | int ttmb = v->ttfrm; /* MB Transform type */ |
1992 | 1.32M | int mb_has_coeffs = 0; /* last_flag */ |
1993 | 1.32M | int val; /* temp value */ |
1994 | 1.32M | int first_block = 1; |
1995 | 1.32M | int dst_idx, off; |
1996 | 1.32M | int fwd; |
1997 | 1.32M | int dmv_x[2], dmv_y[2], pred_flag[2]; |
1998 | 1.32M | int bmvtype = BMV_TYPE_BACKWARD; |
1999 | 1.32M | int block_cbp = 0, pat, block_tt = 0; |
2000 | 1.32M | int idx_mbmode; |
2001 | 1.32M | int ret; |
2002 | | |
2003 | 1.32M | mquant = v->pq; /* Lossy initialization */ |
2004 | 1.32M | s->mb_intra = 0; |
2005 | | |
2006 | 1.32M | idx_mbmode = get_vlc2(gb, v->mbmode_vlc, VC1_IF_MBMODE_VLC_BITS, 2); |
2007 | 1.32M | if (idx_mbmode <= 1) { // intra MB |
2008 | 127k | v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1. |
2009 | 127k | s->mb_intra = 1; |
2010 | 127k | s->cur_pic.motion_val[1][s->block_index[0]][0] = 0; |
2011 | 127k | s->cur_pic.motion_val[1][s->block_index[0]][1] = 0; |
2012 | 127k | s->cur_pic.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA; |
2013 | 127k | GET_MQUANT(); |
2014 | 127k | s->cur_pic.qscale_table[mb_pos] = mquant; |
2015 | | /* Set DC scale - y and c use the same so we only set y */ |
2016 | 127k | s->y_dc_scale = ff_wmv3_dc_scale_table[FFABS(mquant)]; |
2017 | 127k | v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb); |
2018 | 127k | mb_has_coeffs = idx_mbmode & 1; |
2019 | 127k | if (mb_has_coeffs) |
2020 | 22.4k | cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_ICBPCY_VLC_BITS, 2); |
2021 | 127k | dst_idx = 0; |
2022 | 887k | for (i = 0; i < 6; i++) { |
2023 | 760k | v->a_avail = v->c_avail = 0; |
2024 | 760k | v->mb_type[s->block_index[i]] = 1; |
2025 | 760k | s->dc_val[s->block_index[i]] = 0; |
2026 | 760k | dst_idx += i >> 2; |
2027 | 760k | val = ((cbp >> (5 - i)) & 1); |
2028 | 760k | if (i == 2 || i == 3 || !s->first_slice_line) |
2029 | 693k | v->a_avail = v->mb_type[s->block_index[i] - s->block_wrap[i]]; |
2030 | 760k | if (i == 1 || i == 3 || s->mb_x) |
2031 | 738k | v->c_avail = v->mb_type[s->block_index[i] - 1]; |
2032 | | |
2033 | 760k | ret = vc1_decode_intra_block(v, v->blocks[i], i, val, mquant, |
2034 | 760k | (i & 4) ? v->codingset2 : v->codingset); |
2035 | 760k | if (ret < 0) |
2036 | 1.34k | return ret; |
2037 | 759k | if (CONFIG_GRAY && (i > 3) && (s->avctx->flags & AV_CODEC_FLAG_GRAY)) |
2038 | 0 | continue; |
2039 | 759k | v->vc1dsp.vc1_inv_trans_8x8(v->blocks[i]); |
2040 | 759k | if (v->rangeredfrm) |
2041 | 0 | for (j = 0; j < 64; j++) |
2042 | 0 | v->blocks[i][j] <<= 1; |
2043 | 759k | off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize); |
2044 | 759k | s->idsp.put_signed_pixels_clamped(v->blocks[i], |
2045 | 759k | s->dest[dst_idx] + off, |
2046 | 759k | (i & 4) ? s->uvlinesize |
2047 | 759k | : s->linesize); |
2048 | 759k | } |
2049 | 1.19M | } else { |
2050 | 1.19M | s->mb_intra = v->is_intra[s->mb_x] = 0; |
2051 | 1.19M | s->cur_pic.mb_type[mb_pos + v->mb_off] = MB_TYPE_16x16; |
2052 | 8.36M | for (i = 0; i < 6; i++) |
2053 | 7.16M | v->mb_type[s->block_index[i]] = 0; |
2054 | 1.19M | if (v->fmb_is_raw) |
2055 | 637k | fwd = v->forward_mb_plane[mb_pos] = get_bits1(gb); |
2056 | 557k | else |
2057 | 557k | fwd = v->forward_mb_plane[mb_pos]; |
2058 | 1.19M | if (idx_mbmode <= 5) { // 1-MV |
2059 | 1.01M | int interpmvp = 0; |
2060 | 1.01M | dmv_x[0] = dmv_x[1] = dmv_y[0] = dmv_y[1] = 0; |
2061 | 1.01M | pred_flag[0] = pred_flag[1] = 0; |
2062 | 1.01M | if (fwd) |
2063 | 464k | bmvtype = BMV_TYPE_FORWARD; |
2064 | 550k | else { |
2065 | 550k | bmvtype = decode012(gb); |
2066 | 550k | switch (bmvtype) { |
2067 | 334k | case 0: |
2068 | 334k | bmvtype = BMV_TYPE_BACKWARD; |
2069 | 334k | break; |
2070 | 91.7k | case 1: |
2071 | 91.7k | bmvtype = BMV_TYPE_DIRECT; |
2072 | 91.7k | break; |
2073 | 123k | case 2: |
2074 | 123k | bmvtype = BMV_TYPE_INTERPOLATED; |
2075 | 123k | interpmvp = get_bits1(gb); |
2076 | 550k | } |
2077 | 550k | } |
2078 | 1.01M | v->bmvtype = bmvtype; |
2079 | 1.01M | if (bmvtype != BMV_TYPE_DIRECT && idx_mbmode & 1) { |
2080 | 247k | get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], &dmv_y[bmvtype == BMV_TYPE_BACKWARD], &pred_flag[bmvtype == BMV_TYPE_BACKWARD]); |
2081 | 247k | } |
2082 | 1.01M | if (interpmvp) { |
2083 | 77.2k | get_mvdata_interlaced(v, &dmv_x[1], &dmv_y[1], &pred_flag[1]); |
2084 | 77.2k | } |
2085 | 1.01M | if (bmvtype == BMV_TYPE_DIRECT) { |
2086 | 91.7k | dmv_x[0] = dmv_y[0] = pred_flag[0] = 0; |
2087 | 91.7k | dmv_x[1] = dmv_y[1] = pred_flag[0] = 0; |
2088 | 91.7k | if (!s->next_pic.ptr->field_picture) { |
2089 | 79.4k | av_log(s->avctx, AV_LOG_ERROR, "Mixed field/frame direct mode not supported\n"); |
2090 | 79.4k | return AVERROR_INVALIDDATA; |
2091 | 79.4k | } |
2092 | 91.7k | } |
2093 | 934k | ff_vc1_pred_b_mv_intfi(v, 0, dmv_x, dmv_y, 1, pred_flag); |
2094 | 934k | vc1_b_mc(v, dmv_x, dmv_y, (bmvtype == BMV_TYPE_DIRECT), bmvtype); |
2095 | 934k | mb_has_coeffs = !(idx_mbmode & 2); |
2096 | 934k | } else { // 4-MV |
2097 | 180k | if (fwd) |
2098 | 63.2k | bmvtype = BMV_TYPE_FORWARD; |
2099 | 180k | v->bmvtype = bmvtype; |
2100 | 180k | v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1); |
2101 | 903k | for (i = 0; i < 4; i++) { |
2102 | 722k | dmv_x[0] = dmv_y[0] = pred_flag[0] = 0; |
2103 | 722k | dmv_x[1] = dmv_y[1] = pred_flag[1] = 0; |
2104 | 722k | if (v->fourmvbp & (8 >> i)) { |
2105 | 431k | get_mvdata_interlaced(v, &dmv_x[bmvtype == BMV_TYPE_BACKWARD], |
2106 | 431k | &dmv_y[bmvtype == BMV_TYPE_BACKWARD], |
2107 | 431k | &pred_flag[bmvtype == BMV_TYPE_BACKWARD]); |
2108 | 431k | } |
2109 | 722k | ff_vc1_pred_b_mv_intfi(v, i, dmv_x, dmv_y, 0, pred_flag); |
2110 | 722k | ff_vc1_mc_4mv_luma(v, i, bmvtype == BMV_TYPE_BACKWARD, 0); |
2111 | 722k | } |
2112 | 180k | ff_vc1_mc_4mv_chroma(v, bmvtype == BMV_TYPE_BACKWARD); |
2113 | 180k | mb_has_coeffs = idx_mbmode & 1; |
2114 | 180k | } |
2115 | 1.11M | if (mb_has_coeffs) |
2116 | 428k | cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2); |
2117 | 1.11M | if (cbp) { |
2118 | 428k | GET_MQUANT(); |
2119 | 428k | } |
2120 | 1.11M | s->cur_pic.qscale_table[mb_pos] = mquant; |
2121 | 1.11M | if (!v->ttmbf && cbp) { |
2122 | 251k | ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2); |
2123 | 251k | } |
2124 | 1.11M | dst_idx = 0; |
2125 | 7.60M | for (i = 0; i < 6; i++) { |
2126 | 6.53M | s->dc_val[s->block_index[i]] = 0; |
2127 | 6.53M | dst_idx += i >> 2; |
2128 | 6.53M | val = ((cbp >> (5 - i)) & 1); |
2129 | 6.53M | off = (i & 4) ? 0 : (i & 1) * 8 + (i & 2) * 4 * s->linesize; |
2130 | 6.53M | if (val) { |
2131 | 1.50M | pat = vc1_decode_p_block(v, v->blocks[i], i, mquant, ttmb, |
2132 | 1.50M | first_block, s->dest[dst_idx] + off, |
2133 | 1.50M | (i & 4) ? s->uvlinesize : s->linesize, |
2134 | 1.50M | CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), &block_tt); |
2135 | 1.50M | if (pat < 0) |
2136 | 39.6k | return pat; |
2137 | 1.46M | block_cbp |= pat << (i << 2); |
2138 | 1.46M | if (!v->ttmbf && ttmb < 8) |
2139 | 783k | ttmb = -1; |
2140 | 1.46M | first_block = 0; |
2141 | 1.46M | } |
2142 | 6.53M | } |
2143 | 1.11M | } |
2144 | 1.20M | v->cbp[s->mb_x] = block_cbp; |
2145 | 1.20M | v->ttblk[s->mb_x] = block_tt; |
2146 | | |
2147 | 1.20M | return 0; |
2148 | 1.32M | } |
2149 | | |
2150 | | /** Decode one B-frame MB (in interlaced frame B picture) |
2151 | | */ |
2152 | | static int vc1_decode_b_mb_intfr(VC1Context *v) |
2153 | 12.8M | { |
2154 | 12.8M | MpegEncContext *s = &v->s; |
2155 | 12.8M | GetBitContext *const gb = &v->gb; |
2156 | 12.8M | int i, j; |
2157 | 12.8M | int mb_pos = s->mb_x + s->mb_y * s->mb_stride; |
2158 | 12.8M | int cbp = 0; /* cbp decoding stuff */ |
2159 | 12.8M | int mqdiff, mquant; /* MB quantization */ |
2160 | 12.8M | int ttmb = v->ttfrm; /* MB Transform type */ |
2161 | 12.8M | int mvsw = 0; /* motion vector switch */ |
2162 | 12.8M | int mb_has_coeffs = 1; /* last_flag */ |
2163 | 12.8M | int dmv_x, dmv_y; /* Differential MV components */ |
2164 | 12.8M | int val; /* temp value */ |
2165 | 12.8M | int first_block = 1; |
2166 | 12.8M | int dst_idx, off; |
2167 | 12.8M | int skipped, direct, twomv = 0; |
2168 | 12.8M | int block_cbp = 0, pat, block_tt = 0; |
2169 | 12.8M | int idx_mbmode = 0, mvbp; |
2170 | 12.8M | int stride_y, fieldtx; |
2171 | 12.8M | int bmvtype = BMV_TYPE_BACKWARD; |
2172 | 12.8M | int dir, dir2; |
2173 | 12.8M | int ret; |
2174 | | |
2175 | 12.8M | mquant = v->pq; /* Lossy initialization */ |
2176 | 12.8M | s->mb_intra = 0; |
2177 | 12.8M | if (v->skip_is_raw) |
2178 | 3.55M | skipped = get_bits1(gb); |
2179 | 9.32M | else |
2180 | 9.32M | skipped = v->s.mbskip_table[mb_pos]; |
2181 | | |
2182 | 12.8M | if (!skipped) { |
2183 | 8.62M | idx_mbmode = get_vlc2(gb, v->mbmode_vlc, VC1_INTFR_NON4MV_MBMODE_VLC_BITS, 2); |
2184 | 8.62M | if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_2MV_FIELD) { |
2185 | 3.38M | twomv = 1; |
2186 | 3.38M | v->blk_mv_type[s->block_index[0]] = 1; |
2187 | 3.38M | v->blk_mv_type[s->block_index[1]] = 1; |
2188 | 3.38M | v->blk_mv_type[s->block_index[2]] = 1; |
2189 | 3.38M | v->blk_mv_type[s->block_index[3]] = 1; |
2190 | 5.24M | } else { |
2191 | 5.24M | v->blk_mv_type[s->block_index[0]] = 0; |
2192 | 5.24M | v->blk_mv_type[s->block_index[1]] = 0; |
2193 | 5.24M | v->blk_mv_type[s->block_index[2]] = 0; |
2194 | 5.24M | v->blk_mv_type[s->block_index[3]] = 0; |
2195 | 5.24M | } |
2196 | 8.62M | } |
2197 | | |
2198 | 12.8M | if (ff_vc1_mbmode_intfrp[0][idx_mbmode][0] == MV_PMODE_INTFR_INTRA) { // intra MB |
2199 | 761k | for (i = 0; i < 4; i++) { |
2200 | 609k | s->mv[0][i][0] = s->cur_pic.motion_val[0][s->block_index[i]][0] = 0; |
2201 | 609k | s->mv[0][i][1] = s->cur_pic.motion_val[0][s->block_index[i]][1] = 0; |
2202 | 609k | s->mv[1][i][0] = s->cur_pic.motion_val[1][s->block_index[i]][0] = 0; |
2203 | 609k | s->mv[1][i][1] = s->cur_pic.motion_val[1][s->block_index[i]][1] = 0; |
2204 | 609k | } |
2205 | 152k | v->is_intra[s->mb_x] = 0x3f; // Set the bitfield to all 1. |
2206 | 152k | s->mb_intra = 1; |
2207 | 152k | s->cur_pic.mb_type[mb_pos] = MB_TYPE_INTRA; |
2208 | 152k | fieldtx = v->fieldtx_plane[mb_pos] = get_bits1(gb); |
2209 | 152k | mb_has_coeffs = get_bits1(gb); |
2210 | 152k | if (mb_has_coeffs) |
2211 | 63.5k | cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2); |
2212 | 152k | v->s.ac_pred = v->acpred_plane[mb_pos] = get_bits1(gb); |
2213 | 152k | GET_MQUANT(); |
2214 | 152k | s->cur_pic.qscale_table[mb_pos] = mquant; |
2215 | | /* Set DC scale - y and c use the same so we only set y */ |
2216 | 152k | s->y_dc_scale = ff_wmv3_dc_scale_table[FFABS(mquant)]; |
2217 | 152k | dst_idx = 0; |
2218 | 1.05M | for (i = 0; i < 6; i++) { |
2219 | 901k | v->a_avail = v->c_avail = 0; |
2220 | 901k | v->mb_type[s->block_index[i]] = 1; |
2221 | 901k | s->dc_val[s->block_index[i]] = 0; |
2222 | 901k | dst_idx += i >> 2; |
2223 | 901k | val = ((cbp >> (5 - i)) & 1); |
2224 | 901k | if (i == 2 || i == 3 || !s->first_slice_line) |
2225 | 829k | v->a_avail = v->mb_type[s->block_index[i] - s->block_wrap[i]]; |
2226 | 901k | if (i == 1 || i == 3 || s->mb_x) |
2227 | 873k | v->c_avail = v->mb_type[s->block_index[i] - 1]; |
2228 | | |
2229 | 901k | ret = vc1_decode_intra_block(v, v->blocks[i], i, val, mquant, |
2230 | 901k | (i & 4) ? v->codingset2 : v->codingset); |
2231 | 901k | if (ret < 0) |
2232 | 3.07k | return ret; |
2233 | 898k | if (CONFIG_GRAY && i > 3 && (s->avctx->flags & AV_CODEC_FLAG_GRAY)) |
2234 | 0 | continue; |
2235 | 898k | v->vc1dsp.vc1_inv_trans_8x8(v->blocks[i]); |
2236 | 898k | if (i < 4) { |
2237 | 599k | stride_y = s->linesize << fieldtx; |
2238 | 599k | off = (fieldtx) ? ((i & 1) * 8) + ((i & 2) >> 1) * s->linesize : (i & 1) * 8 + 4 * (i & 2) * s->linesize; |
2239 | 599k | } else { |
2240 | 298k | stride_y = s->uvlinesize; |
2241 | 298k | off = 0; |
2242 | 298k | } |
2243 | 898k | s->idsp.put_signed_pixels_clamped(v->blocks[i], |
2244 | 898k | s->dest[dst_idx] + off, |
2245 | 898k | stride_y); |
2246 | 898k | } |
2247 | 12.7M | } else { |
2248 | 12.7M | s->mb_intra = v->is_intra[s->mb_x] = 0; |
2249 | | |
2250 | 12.7M | if (v->dmb_is_raw) |
2251 | 3.55M | direct = get_bits1(gb); |
2252 | 9.18M | else |
2253 | 9.18M | direct = v->direct_mb_plane[mb_pos]; |
2254 | | |
2255 | 12.7M | if (direct) { |
2256 | 3.44M | if (s->next_pic.ptr->field_picture) |
2257 | 59.5k | av_log(s->avctx, AV_LOG_WARNING, "Mixed frame/field direct mode not supported\n"); |
2258 | 3.44M | s->mv[0][0][0] = s->cur_pic.motion_val[0][s->block_index[0]][0] = scale_mv(s->next_pic.motion_val[1][s->block_index[0]][0], v->bfraction, 0, s->quarter_sample); |
2259 | 3.44M | s->mv[0][0][1] = s->cur_pic.motion_val[0][s->block_index[0]][1] = scale_mv(s->next_pic.motion_val[1][s->block_index[0]][1], v->bfraction, 0, s->quarter_sample); |
2260 | 3.44M | s->mv[1][0][0] = s->cur_pic.motion_val[1][s->block_index[0]][0] = scale_mv(s->next_pic.motion_val[1][s->block_index[0]][0], v->bfraction, 1, s->quarter_sample); |
2261 | 3.44M | s->mv[1][0][1] = s->cur_pic.motion_val[1][s->block_index[0]][1] = scale_mv(s->next_pic.motion_val[1][s->block_index[0]][1], v->bfraction, 1, s->quarter_sample); |
2262 | | |
2263 | 3.44M | if (twomv) { |
2264 | 961k | s->mv[0][2][0] = s->cur_pic.motion_val[0][s->block_index[2]][0] = scale_mv(s->next_pic.motion_val[1][s->block_index[2]][0], v->bfraction, 0, s->quarter_sample); |
2265 | 961k | s->mv[0][2][1] = s->cur_pic.motion_val[0][s->block_index[2]][1] = scale_mv(s->next_pic.motion_val[1][s->block_index[2]][1], v->bfraction, 0, s->quarter_sample); |
2266 | 961k | s->mv[1][2][0] = s->cur_pic.motion_val[1][s->block_index[2]][0] = scale_mv(s->next_pic.motion_val[1][s->block_index[2]][0], v->bfraction, 1, s->quarter_sample); |
2267 | 961k | s->mv[1][2][1] = s->cur_pic.motion_val[1][s->block_index[2]][1] = scale_mv(s->next_pic.motion_val[1][s->block_index[2]][1], v->bfraction, 1, s->quarter_sample); |
2268 | | |
2269 | 2.88M | for (i = 1; i < 4; i += 2) { |
2270 | 1.92M | s->mv[0][i][0] = s->cur_pic.motion_val[0][s->block_index[i]][0] = s->mv[0][i-1][0]; |
2271 | 1.92M | s->mv[0][i][1] = s->cur_pic.motion_val[0][s->block_index[i]][1] = s->mv[0][i-1][1]; |
2272 | 1.92M | s->mv[1][i][0] = s->cur_pic.motion_val[1][s->block_index[i]][0] = s->mv[1][i-1][0]; |
2273 | 1.92M | s->mv[1][i][1] = s->cur_pic.motion_val[1][s->block_index[i]][1] = s->mv[1][i-1][1]; |
2274 | 1.92M | } |
2275 | 2.47M | } else { |
2276 | 9.91M | for (i = 1; i < 4; i++) { |
2277 | 7.43M | s->mv[0][i][0] = s->cur_pic.motion_val[0][s->block_index[i]][0] = s->mv[0][0][0]; |
2278 | 7.43M | s->mv[0][i][1] = s->cur_pic.motion_val[0][s->block_index[i]][1] = s->mv[0][0][1]; |
2279 | 7.43M | s->mv[1][i][0] = s->cur_pic.motion_val[1][s->block_index[i]][0] = s->mv[1][0][0]; |
2280 | 7.43M | s->mv[1][i][1] = s->cur_pic.motion_val[1][s->block_index[i]][1] = s->mv[1][0][1]; |
2281 | 7.43M | } |
2282 | 2.47M | } |
2283 | 3.44M | } |
2284 | | |
2285 | 12.7M | if (!direct) { |
2286 | 9.29M | if (skipped || !s->mb_intra) { |
2287 | 9.29M | bmvtype = decode012(gb); |
2288 | 9.29M | switch (bmvtype) { |
2289 | 5.09M | case 0: |
2290 | 5.09M | bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_BACKWARD : BMV_TYPE_FORWARD; |
2291 | 5.09M | break; |
2292 | 1.73M | case 1: |
2293 | 1.73M | bmvtype = (v->bfraction >= (B_FRACTION_DEN/2)) ? BMV_TYPE_FORWARD : BMV_TYPE_BACKWARD; |
2294 | 1.73M | break; |
2295 | 2.45M | case 2: |
2296 | 2.45M | bmvtype = BMV_TYPE_INTERPOLATED; |
2297 | 9.29M | } |
2298 | 9.29M | } |
2299 | | |
2300 | 9.29M | if (twomv && bmvtype != BMV_TYPE_INTERPOLATED) |
2301 | 1.80M | mvsw = get_bits1(gb); |
2302 | 9.29M | } |
2303 | | |
2304 | 12.7M | if (!skipped) { // inter MB |
2305 | 8.47M | mb_has_coeffs = ff_vc1_mbmode_intfrp[0][idx_mbmode][3]; |
2306 | 8.47M | if (mb_has_coeffs) |
2307 | 3.73M | cbp = 1 + get_vlc2(gb, v->cbpcy_vlc, VC1_CBPCY_P_VLC_BITS, 2); |
2308 | 8.47M | if (!direct) { |
2309 | 6.10M | if (bmvtype == BMV_TYPE_INTERPOLATED && twomv) { |
2310 | 616k | v->fourmvbp = get_vlc2(gb, v->fourmvbp_vlc, VC1_4MV_BLOCK_PATTERN_VLC_BITS, 1); |
2311 | 5.49M | } else if (bmvtype == BMV_TYPE_INTERPOLATED || twomv) { |
2312 | 2.64M | v->twomvbp = get_vlc2(gb, v->twomvbp_vlc, VC1_2MV_BLOCK_PATTERN_VLC_BITS, 1); |
2313 | 2.64M | } |
2314 | 6.10M | } |
2315 | | |
2316 | 59.3M | for (i = 0; i < 6; i++) |
2317 | 50.8M | v->mb_type[s->block_index[i]] = 0; |
2318 | 8.47M | fieldtx = v->fieldtx_plane[mb_pos] = ff_vc1_mbmode_intfrp[0][idx_mbmode][1]; |
2319 | | /* for all motion vector read MVDATA and motion compensate each block */ |
2320 | 8.47M | dst_idx = 0; |
2321 | 8.47M | if (direct) { |
2322 | 2.36M | if (twomv) { |
2323 | 4.80M | for (i = 0; i < 4; i++) { |
2324 | 3.84M | ff_vc1_mc_4mv_luma(v, i, 0, 0); |
2325 | 3.84M | ff_vc1_mc_4mv_luma(v, i, 1, 1); |
2326 | 3.84M | } |
2327 | 961k | ff_vc1_mc_4mv_chroma4(v, 0, 0, 0); |
2328 | 961k | ff_vc1_mc_4mv_chroma4(v, 1, 1, 1); |
2329 | 1.40M | } else { |
2330 | 1.40M | ff_vc1_mc_1mv(v, 0); |
2331 | 1.40M | ff_vc1_interp_mc(v); |
2332 | 1.40M | } |
2333 | 6.10M | } else if (twomv && bmvtype == BMV_TYPE_INTERPOLATED) { |
2334 | 616k | mvbp = v->fourmvbp; |
2335 | 3.08M | for (i = 0; i < 4; i++) { |
2336 | 2.46M | dir = i==1 || i==3; |
2337 | 2.46M | dmv_x = dmv_y = 0; |
2338 | 2.46M | val = ((mvbp >> (3 - i)) & 1); |
2339 | 2.46M | if (val) |
2340 | 1.39M | get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0); |
2341 | 2.46M | j = i > 1 ? 2 : 0; |
2342 | 2.46M | ff_vc1_pred_mv_intfr(v, j, dmv_x, dmv_y, 2, v->range_x, v->range_y, dir); |
2343 | 2.46M | ff_vc1_mc_4mv_luma(v, j, dir, dir); |
2344 | 2.46M | ff_vc1_mc_4mv_luma(v, j+1, dir, dir); |
2345 | 2.46M | } |
2346 | | |
2347 | 616k | ff_vc1_mc_4mv_chroma4(v, 0, 0, 0); |
2348 | 616k | ff_vc1_mc_4mv_chroma4(v, 1, 1, 1); |
2349 | 5.49M | } else if (bmvtype == BMV_TYPE_INTERPOLATED) { |
2350 | 841k | mvbp = v->twomvbp; |
2351 | 841k | dmv_x = dmv_y = 0; |
2352 | 841k | if (mvbp & 2) |
2353 | 376k | get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0); |
2354 | | |
2355 | 841k | ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, 0); |
2356 | 841k | ff_vc1_mc_1mv(v, 0); |
2357 | | |
2358 | 841k | dmv_x = dmv_y = 0; |
2359 | 841k | if (mvbp & 1) |
2360 | 423k | get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0); |
2361 | | |
2362 | 841k | ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, 1); |
2363 | 841k | ff_vc1_interp_mc(v); |
2364 | 4.65M | } else if (twomv) { |
2365 | 1.80M | dir = bmvtype == BMV_TYPE_BACKWARD; |
2366 | 1.80M | dir2 = dir; |
2367 | 1.80M | if (mvsw) |
2368 | 753k | dir2 = !dir; |
2369 | 1.80M | mvbp = v->twomvbp; |
2370 | 1.80M | dmv_x = dmv_y = 0; |
2371 | 1.80M | if (mvbp & 2) |
2372 | 946k | get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0); |
2373 | 1.80M | ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 2, v->range_x, v->range_y, dir); |
2374 | | |
2375 | 1.80M | dmv_x = dmv_y = 0; |
2376 | 1.80M | if (mvbp & 1) |
2377 | 899k | get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0); |
2378 | 1.80M | ff_vc1_pred_mv_intfr(v, 2, dmv_x, dmv_y, 2, v->range_x, v->range_y, dir2); |
2379 | | |
2380 | 1.80M | if (mvsw) { |
2381 | 2.26M | for (i = 0; i < 2; i++) { |
2382 | 1.50M | s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->cur_pic.motion_val[dir][s->block_index[i+2]][0] = s->cur_pic.motion_val[dir][s->block_index[i]][0]; |
2383 | 1.50M | s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->cur_pic.motion_val[dir][s->block_index[i+2]][1] = s->cur_pic.motion_val[dir][s->block_index[i]][1]; |
2384 | 1.50M | s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->cur_pic.motion_val[dir2][s->block_index[i]][0] = s->cur_pic.motion_val[dir2][s->block_index[i+2]][0]; |
2385 | 1.50M | s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->cur_pic.motion_val[dir2][s->block_index[i]][1] = s->cur_pic.motion_val[dir2][s->block_index[i+2]][1]; |
2386 | 1.50M | } |
2387 | 1.05M | } else { |
2388 | 1.05M | ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir); |
2389 | 1.05M | ff_vc1_pred_mv_intfr(v, 2, 0, 0, 2, v->range_x, v->range_y, !dir); |
2390 | 1.05M | } |
2391 | | |
2392 | 1.80M | ff_vc1_mc_4mv_luma(v, 0, dir, 0); |
2393 | 1.80M | ff_vc1_mc_4mv_luma(v, 1, dir, 0); |
2394 | 1.80M | ff_vc1_mc_4mv_luma(v, 2, dir2, 0); |
2395 | 1.80M | ff_vc1_mc_4mv_luma(v, 3, dir2, 0); |
2396 | 1.80M | ff_vc1_mc_4mv_chroma4(v, dir, dir2, 0); |
2397 | 2.84M | } else { |
2398 | 2.84M | dir = bmvtype == BMV_TYPE_BACKWARD; |
2399 | | |
2400 | 2.84M | mvbp = ff_vc1_mbmode_intfrp[0][idx_mbmode][2]; |
2401 | 2.84M | dmv_x = dmv_y = 0; |
2402 | 2.84M | if (mvbp) |
2403 | 2.38M | get_mvdata_interlaced(v, &dmv_x, &dmv_y, 0); |
2404 | | |
2405 | 2.84M | ff_vc1_pred_mv_intfr(v, 0, dmv_x, dmv_y, 1, v->range_x, v->range_y, dir); |
2406 | 2.84M | v->blk_mv_type[s->block_index[0]] = 1; |
2407 | 2.84M | v->blk_mv_type[s->block_index[1]] = 1; |
2408 | 2.84M | v->blk_mv_type[s->block_index[2]] = 1; |
2409 | 2.84M | v->blk_mv_type[s->block_index[3]] = 1; |
2410 | 2.84M | ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir); |
2411 | 8.53M | for (i = 0; i < 2; i++) { |
2412 | 5.69M | s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->cur_pic.motion_val[!dir][s->block_index[i+2]][0] = s->cur_pic.motion_val[!dir][s->block_index[i]][0]; |
2413 | 5.69M | s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->cur_pic.motion_val[!dir][s->block_index[i+2]][1] = s->cur_pic.motion_val[!dir][s->block_index[i]][1]; |
2414 | 5.69M | } |
2415 | 2.84M | ff_vc1_mc_1mv(v, dir); |
2416 | 2.84M | } |
2417 | | |
2418 | 8.47M | if (cbp) |
2419 | 3.73M | GET_MQUANT(); // p. 227 |
2420 | 8.47M | s->cur_pic.qscale_table[mb_pos] = mquant; |
2421 | 8.47M | if (!v->ttmbf && cbp) |
2422 | 2.01M | ttmb = get_vlc2(gb, ff_vc1_ttmb_vlc[v->tt_index], VC1_TTMB_VLC_BITS, 2); |
2423 | 58.3M | for (i = 0; i < 6; i++) { |
2424 | 50.0M | s->dc_val[s->block_index[i]] = 0; |
2425 | 50.0M | dst_idx += i >> 2; |
2426 | 50.0M | val = ((cbp >> (5 - i)) & 1); |
2427 | 50.0M | if (!fieldtx) |
2428 | 27.6M | off = (i & 4) ? 0 : ((i & 1) * 8 + (i & 2) * 4 * s->linesize); |
2429 | 22.4M | else |
2430 | 22.4M | off = (i & 4) ? 0 : ((i & 1) * 8 + ((i > 1) * s->linesize)); |
2431 | 50.0M | if (val) { |
2432 | 12.1M | pat = vc1_decode_p_block(v, v->blocks[i], i, mquant, ttmb, |
2433 | 12.1M | first_block, s->dest[dst_idx] + off, |
2434 | 12.1M | (i & 4) ? s->uvlinesize : (s->linesize << fieldtx), |
2435 | 12.1M | CONFIG_GRAY && (i & 4) && (s->avctx->flags & AV_CODEC_FLAG_GRAY), &block_tt); |
2436 | 12.1M | if (pat < 0) |
2437 | 230k | return pat; |
2438 | 11.8M | block_cbp |= pat << (i << 2); |
2439 | 11.8M | if (!v->ttmbf && ttmb < 8) |
2440 | 5.29M | ttmb = -1; |
2441 | 11.8M | first_block = 0; |
2442 | 11.8M | } |
2443 | 50.0M | } |
2444 | | |
2445 | 8.47M | } else { // skipped |
2446 | 4.25M | dir = 0; |
2447 | 29.7M | for (i = 0; i < 6; i++) { |
2448 | 25.5M | v->mb_type[s->block_index[i]] = 0; |
2449 | 25.5M | s->dc_val[s->block_index[i]] = 0; |
2450 | 25.5M | } |
2451 | 4.25M | s->cur_pic.mb_type[mb_pos] = MB_TYPE_SKIP; |
2452 | 4.25M | s->cur_pic.qscale_table[mb_pos] = 0; |
2453 | 4.25M | v->blk_mv_type[s->block_index[0]] = 0; |
2454 | 4.25M | v->blk_mv_type[s->block_index[1]] = 0; |
2455 | 4.25M | v->blk_mv_type[s->block_index[2]] = 0; |
2456 | 4.25M | v->blk_mv_type[s->block_index[3]] = 0; |
2457 | | |
2458 | 4.25M | if (!direct) { |
2459 | 3.18M | if (bmvtype == BMV_TYPE_INTERPOLATED) { |
2460 | 1.00M | ff_vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, 0); |
2461 | 1.00M | ff_vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, 1); |
2462 | 2.17M | } else { |
2463 | 2.17M | dir = bmvtype == BMV_TYPE_BACKWARD; |
2464 | 2.17M | ff_vc1_pred_mv_intfr(v, 0, 0, 0, 1, v->range_x, v->range_y, dir); |
2465 | 2.17M | if (mvsw) { |
2466 | 0 | int dir2 = dir; |
2467 | 0 | if (mvsw) |
2468 | 0 | dir2 = !dir; |
2469 | 0 | for (i = 0; i < 2; i++) { |
2470 | 0 | s->mv[dir][i+2][0] = s->mv[dir][i][0] = s->cur_pic.motion_val[dir][s->block_index[i+2]][0] = s->cur_pic.motion_val[dir][s->block_index[i]][0]; |
2471 | 0 | s->mv[dir][i+2][1] = s->mv[dir][i][1] = s->cur_pic.motion_val[dir][s->block_index[i+2]][1] = s->cur_pic.motion_val[dir][s->block_index[i]][1]; |
2472 | 0 | s->mv[dir2][i+2][0] = s->mv[dir2][i][0] = s->cur_pic.motion_val[dir2][s->block_index[i]][0] = s->cur_pic.motion_val[dir2][s->block_index[i+2]][0]; |
2473 | 0 | s->mv[dir2][i+2][1] = s->mv[dir2][i][1] = s->cur_pic.motion_val[dir2][s->block_index[i]][1] = s->cur_pic.motion_val[dir2][s->block_index[i+2]][1]; |
2474 | 0 | } |
2475 | 2.17M | } else { |
2476 | 2.17M | v->blk_mv_type[s->block_index[0]] = 1; |
2477 | 2.17M | v->blk_mv_type[s->block_index[1]] = 1; |
2478 | 2.17M | v->blk_mv_type[s->block_index[2]] = 1; |
2479 | 2.17M | v->blk_mv_type[s->block_index[3]] = 1; |
2480 | 2.17M | ff_vc1_pred_mv_intfr(v, 0, 0, 0, 2, v->range_x, v->range_y, !dir); |
2481 | 6.53M | for (i = 0; i < 2; i++) { |
2482 | 4.35M | s->mv[!dir][i+2][0] = s->mv[!dir][i][0] = s->cur_pic.motion_val[!dir][s->block_index[i+2]][0] = s->cur_pic.motion_val[!dir][s->block_index[i]][0]; |
2483 | 4.35M | s->mv[!dir][i+2][1] = s->mv[!dir][i][1] = s->cur_pic.motion_val[!dir][s->block_index[i+2]][1] = s->cur_pic.motion_val[!dir][s->block_index[i]][1]; |
2484 | 4.35M | } |
2485 | 2.17M | } |
2486 | 2.17M | } |
2487 | 3.18M | } |
2488 | | |
2489 | 4.25M | ff_vc1_mc_1mv(v, dir); |
2490 | 4.25M | if (direct || bmvtype == BMV_TYPE_INTERPOLATED) { |
2491 | 2.07M | ff_vc1_interp_mc(v); |
2492 | 2.07M | } |
2493 | 4.25M | v->fieldtx_plane[mb_pos] = 0; |
2494 | 4.25M | } |
2495 | 12.7M | } |
2496 | 12.6M | v->cbp[s->mb_x] = block_cbp; |
2497 | 12.6M | v->ttblk[s->mb_x] = block_tt; |
2498 | | |
2499 | 12.6M | return 0; |
2500 | 12.8M | } |
2501 | | |
2502 | | /** Decode blocks of I-frame |
2503 | | */ |
2504 | | static void vc1_decode_i_blocks(VC1Context *v) |
2505 | 323k | { |
2506 | 323k | int k, j; |
2507 | 323k | MpegEncContext *s = &v->s; |
2508 | 323k | int cbp, val; |
2509 | 323k | int mb_pos; |
2510 | | |
2511 | | /* select coding mode used for VLC tables selection */ |
2512 | 323k | switch (v->y_ac_table_index) { |
2513 | 106k | case 0: |
2514 | 106k | v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA; |
2515 | 106k | break; |
2516 | 22.0k | case 1: |
2517 | 22.0k | v->codingset = CS_HIGH_MOT_INTRA; |
2518 | 22.0k | break; |
2519 | 195k | case 2: |
2520 | 195k | v->codingset = CS_MID_RATE_INTRA; |
2521 | 195k | break; |
2522 | 323k | } |
2523 | | |
2524 | 323k | switch (v->c_ac_table_index) { |
2525 | 111k | case 0: |
2526 | 111k | v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER; |
2527 | 111k | break; |
2528 | 188k | case 1: |
2529 | 188k | v->codingset2 = CS_HIGH_MOT_INTER; |
2530 | 188k | break; |
2531 | 23.6k | case 2: |
2532 | 23.6k | v->codingset2 = CS_MID_RATE_INTER; |
2533 | 23.6k | break; |
2534 | 323k | } |
2535 | | |
2536 | | /* Set DC scale - y and c use the same so we only set y */ |
2537 | 323k | s->y_dc_scale = ff_wmv3_dc_scale_table[v->pq]; |
2538 | | |
2539 | | //do frame decode |
2540 | 323k | s->mb_x = s->mb_y = 0; |
2541 | 323k | s->mb_intra = 1; |
2542 | 323k | s->first_slice_line = 1; |
2543 | 690k | for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { |
2544 | 504k | s->mb_x = 0; |
2545 | 504k | init_block_index(v); |
2546 | 5.02M | for (; s->mb_x < v->end_mb_x; s->mb_x++) { |
2547 | 4.65M | update_block_index(s); |
2548 | 4.65M | s->bdsp.clear_blocks(v->block[v->cur_blk_idx][0]); |
2549 | 4.65M | mb_pos = s->mb_x + s->mb_y * s->mb_width; |
2550 | 4.65M | s->cur_pic.mb_type[mb_pos] = MB_TYPE_INTRA; |
2551 | 4.65M | s->cur_pic.qscale_table[mb_pos] = v->pq; |
2552 | 23.2M | for (int i = 0; i < 4; i++) { |
2553 | 18.6M | s->cur_pic.motion_val[1][s->block_index[i]][0] = 0; |
2554 | 18.6M | s->cur_pic.motion_val[1][s->block_index[i]][1] = 0; |
2555 | 18.6M | } |
2556 | | |
2557 | | // do actual MB decoding and displaying |
2558 | 4.65M | cbp = get_vlc2(&v->gb, ff_msmp4_mb_i_vlc, |
2559 | 4.65M | MSMP4_MB_INTRA_VLC_BITS, 2); |
2560 | 4.65M | v->s.ac_pred = get_bits1(&v->gb); |
2561 | | |
2562 | 32.6M | for (k = 0; k < 6; k++) { |
2563 | 27.9M | v->mb_type[s->block_index[k]] = 1; |
2564 | | |
2565 | 27.9M | val = ((cbp >> (5 - k)) & 1); |
2566 | | |
2567 | 27.9M | if (k < 4) |
2568 | 18.6M | val = vc1_coded_block_pred(&v->s, k, val); |
2569 | 27.9M | cbp |= val << (5 - k); |
2570 | | |
2571 | 27.9M | vc1_decode_i_block(v, v->block[v->cur_blk_idx][block_map[k]], k, val, (k < 4) ? v->codingset : v->codingset2); |
2572 | | |
2573 | 27.9M | if (CONFIG_GRAY && k > 3 && (s->avctx->flags & AV_CODEC_FLAG_GRAY)) |
2574 | 0 | continue; |
2575 | 27.9M | v->vc1dsp.vc1_inv_trans_8x8(v->block[v->cur_blk_idx][block_map[k]]); |
2576 | 27.9M | } |
2577 | | |
2578 | 4.65M | if (v->overlap && v->pq >= 9) { |
2579 | 1.02M | ff_vc1_i_overlap_filter(v); |
2580 | 1.02M | if (v->rangeredfrm) |
2581 | 1.36M | for (k = 0; k < 6; k++) |
2582 | 75.8M | for (j = 0; j < 64; j++) |
2583 | 74.6M | v->block[v->cur_blk_idx][block_map[k]][j] *= 2; |
2584 | 1.02M | vc1_put_blocks_clamped(v, 1); |
2585 | 3.63M | } else { |
2586 | 3.63M | if (v->rangeredfrm) |
2587 | 4.60M | for (k = 0; k < 6; k++) |
2588 | 256M | for (j = 0; j < 64; j++) |
2589 | 252M | v->block[v->cur_blk_idx][block_map[k]][j] = (v->block[v->cur_blk_idx][block_map[k]][j] - 64) * 2; |
2590 | 3.63M | vc1_put_blocks_clamped(v, 0); |
2591 | 3.63M | } |
2592 | | |
2593 | 4.65M | if (v->loop_filter) |
2594 | 2.56M | ff_vc1_i_loop_filter(v); |
2595 | | |
2596 | 4.65M | if (get_bits_left(&v->gb) < 0) { |
2597 | 138k | ff_er_add_slice(&s->er, 0, 0, s->mb_x, s->mb_y, ER_MB_ERROR); |
2598 | 138k | av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", |
2599 | 138k | get_bits_count(&v->gb), v->gb.size_in_bits); |
2600 | 138k | return; |
2601 | 138k | } |
2602 | | |
2603 | 4.52M | v->topleft_blk_idx = (v->topleft_blk_idx + 1) % (v->end_mb_x + 2); |
2604 | 4.52M | v->top_blk_idx = (v->top_blk_idx + 1) % (v->end_mb_x + 2); |
2605 | 4.52M | v->left_blk_idx = (v->left_blk_idx + 1) % (v->end_mb_x + 2); |
2606 | 4.52M | v->cur_blk_idx = (v->cur_blk_idx + 1) % (v->end_mb_x + 2); |
2607 | 4.52M | } |
2608 | | |
2609 | 366k | s->first_slice_line = 0; |
2610 | 366k | } |
2611 | | |
2612 | | /* This is intentionally mb_height and not end_mb_y - unlike in advanced |
2613 | | * profile, these only differ are when decoding MSS2 rectangles. */ |
2614 | 185k | ff_er_add_slice(&s->er, 0, 0, s->mb_width - 1, s->mb_height - 1, ER_MB_END); |
2615 | 185k | } |
2616 | | |
2617 | | /** Decode blocks of I-frame for advanced profile |
2618 | | */ |
2619 | | static int vc1_decode_i_blocks_adv(VC1Context *v) |
2620 | 45.1k | { |
2621 | 45.1k | int k; |
2622 | 45.1k | MpegEncContext *s = &v->s; |
2623 | 45.1k | GetBitContext *const gb = &v->gb; |
2624 | 45.1k | int cbp, val; |
2625 | 45.1k | int mb_pos; |
2626 | 45.1k | int mquant; |
2627 | 45.1k | int mqdiff; |
2628 | | |
2629 | 45.1k | if (get_bits_left(gb) <= 1) |
2630 | 4.80k | return AVERROR_INVALIDDATA; |
2631 | | |
2632 | | /* select coding mode used for VLC tables selection */ |
2633 | 40.3k | switch (v->y_ac_table_index) { |
2634 | 20.5k | case 0: |
2635 | 20.5k | v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA; |
2636 | 20.5k | break; |
2637 | 9.19k | case 1: |
2638 | 9.19k | v->codingset = CS_HIGH_MOT_INTRA; |
2639 | 9.19k | break; |
2640 | 10.6k | case 2: |
2641 | 10.6k | v->codingset = CS_MID_RATE_INTRA; |
2642 | 10.6k | break; |
2643 | 40.3k | } |
2644 | | |
2645 | 40.3k | switch (v->c_ac_table_index) { |
2646 | 24.7k | case 0: |
2647 | 24.7k | v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER; |
2648 | 24.7k | break; |
2649 | 8.40k | case 1: |
2650 | 8.40k | v->codingset2 = CS_HIGH_MOT_INTER; |
2651 | 8.40k | break; |
2652 | 7.22k | case 2: |
2653 | 7.22k | v->codingset2 = CS_MID_RATE_INTER; |
2654 | 7.22k | break; |
2655 | 40.3k | } |
2656 | | |
2657 | | // do frame decode |
2658 | 40.3k | s->mb_intra = 1; |
2659 | 40.3k | s->first_slice_line = 1; |
2660 | 40.3k | s->mb_x = 0; |
2661 | 40.3k | s->mb_y = s->start_mb_y; |
2662 | 40.3k | if (s->start_mb_y) { |
2663 | 3.19k | memset(&s->coded_block[(2 * s->mb_y - 1) * s->b8_stride - 2], 0, |
2664 | 3.19k | (1 + s->b8_stride) * sizeof(*s->coded_block)); |
2665 | 3.19k | } |
2666 | 428k | for (; s->mb_y < s->end_mb_y; s->mb_y++) { |
2667 | 424k | s->mb_x = 0; |
2668 | 424k | init_block_index(v); |
2669 | 2.32M | for (;s->mb_x < s->mb_width; s->mb_x++) { |
2670 | 1.93M | mquant = v->pq; |
2671 | 1.93M | update_block_index(s); |
2672 | 1.93M | s->bdsp.clear_blocks(v->block[v->cur_blk_idx][0]); |
2673 | 1.93M | mb_pos = s->mb_x + s->mb_y * s->mb_stride; |
2674 | 1.93M | s->cur_pic.mb_type[mb_pos + v->mb_off] = MB_TYPE_INTRA; |
2675 | 9.67M | for (int i = 0; i < 4; i++) { |
2676 | 7.73M | s->cur_pic.motion_val[1][s->block_index[i] + v->blocks_off][0] = 0; |
2677 | 7.73M | s->cur_pic.motion_val[1][s->block_index[i] + v->blocks_off][1] = 0; |
2678 | 7.73M | } |
2679 | | |
2680 | | // do actual MB decoding and displaying |
2681 | 1.93M | if (v->fieldtx_is_raw) |
2682 | 906k | v->fieldtx_plane[mb_pos] = get_bits1(gb); |
2683 | 1.93M | if (get_bits_left(gb) <= 1) { |
2684 | 1.35k | ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); |
2685 | 1.35k | return 0; |
2686 | 1.35k | } |
2687 | | |
2688 | 1.93M | cbp = get_vlc2(gb, ff_msmp4_mb_i_vlc, |
2689 | 1.93M | MSMP4_MB_INTRA_VLC_BITS, 2); |
2690 | 1.93M | if (v->acpred_is_raw) |
2691 | 1.48M | v->s.ac_pred = get_bits1(gb); |
2692 | 446k | else |
2693 | 446k | v->s.ac_pred = v->acpred_plane[mb_pos]; |
2694 | | |
2695 | 1.93M | if (v->condover == CONDOVER_SELECT && v->overflg_is_raw) |
2696 | 7.48k | v->over_flags_plane[mb_pos] = get_bits1(gb); |
2697 | | |
2698 | 1.93M | GET_MQUANT(); |
2699 | | |
2700 | 1.93M | s->cur_pic.qscale_table[mb_pos] = mquant; |
2701 | | /* Set DC scale - y and c use the same so we only set y */ |
2702 | 1.93M | s->y_dc_scale = ff_wmv3_dc_scale_table[FFABS(mquant)]; |
2703 | | |
2704 | 13.5M | for (k = 0; k < 6; k++) { |
2705 | 11.6M | v->mb_type[s->block_index[k]] = 1; |
2706 | | |
2707 | 11.6M | val = ((cbp >> (5 - k)) & 1); |
2708 | | |
2709 | 11.6M | if (k < 4) |
2710 | 7.73M | val = vc1_coded_block_pred(&v->s, k, val); |
2711 | 11.6M | cbp |= val << (5 - k); |
2712 | | |
2713 | 11.6M | v->a_avail = !s->first_slice_line || (k == 2 || k == 3); |
2714 | 11.6M | v->c_avail = !!s->mb_x || (k == 1 || k == 3); |
2715 | | |
2716 | 11.6M | vc1_decode_i_block_adv(v, v->block[v->cur_blk_idx][block_map[k]], k, val, |
2717 | 11.6M | (k < 4) ? v->codingset : v->codingset2, mquant); |
2718 | | |
2719 | 11.6M | if (CONFIG_GRAY && k > 3 && (s->avctx->flags & AV_CODEC_FLAG_GRAY)) |
2720 | 0 | continue; |
2721 | 11.6M | v->vc1dsp.vc1_inv_trans_8x8(v->block[v->cur_blk_idx][block_map[k]]); |
2722 | 11.6M | } |
2723 | | |
2724 | 1.93M | if (v->overlap && (v->pq >= 9 || v->condover != CONDOVER_NONE)) |
2725 | 994k | ff_vc1_i_overlap_filter(v); |
2726 | 1.93M | vc1_put_blocks_clamped(v, 1); |
2727 | 1.93M | if (v->loop_filter) |
2728 | 719k | ff_vc1_i_loop_filter(v); |
2729 | | |
2730 | 1.93M | if (get_bits_left(gb) < 0) { |
2731 | | // TODO: may need modification to handle slice coding |
2732 | 34.4k | ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); |
2733 | 34.4k | av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i\n", |
2734 | 34.4k | get_bits_count(gb), gb->size_in_bits); |
2735 | 34.4k | return 0; |
2736 | 34.4k | } |
2737 | 1.89M | inc_blk_idx(v->topleft_blk_idx); |
2738 | 1.89M | inc_blk_idx(v->top_blk_idx); |
2739 | 1.89M | inc_blk_idx(v->left_blk_idx); |
2740 | 1.89M | inc_blk_idx(v->cur_blk_idx); |
2741 | 1.89M | } |
2742 | 388k | s->first_slice_line = 0; |
2743 | 388k | } |
2744 | | |
2745 | 4.54k | ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1, |
2746 | 4.54k | (s->end_mb_y << v->field_mode) - 1, ER_MB_END); |
2747 | 4.54k | return 0; |
2748 | 40.3k | } |
2749 | | |
2750 | | static void vc1_decode_p_blocks(VC1Context *v) |
2751 | 282k | { |
2752 | 282k | MpegEncContext *s = &v->s; |
2753 | 282k | int apply_loop_filter; |
2754 | 282k | int ret; |
2755 | | |
2756 | | /* select coding mode used for VLC tables selection */ |
2757 | 282k | switch (v->c_ac_table_index) { |
2758 | 191k | case 0: |
2759 | 191k | v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA; |
2760 | 191k | break; |
2761 | 34.6k | case 1: |
2762 | 34.6k | v->codingset = CS_HIGH_MOT_INTRA; |
2763 | 34.6k | break; |
2764 | 56.8k | case 2: |
2765 | 56.8k | v->codingset = CS_MID_RATE_INTRA; |
2766 | 56.8k | break; |
2767 | 282k | } |
2768 | | |
2769 | 282k | switch (v->c_ac_table_index) { |
2770 | 191k | case 0: |
2771 | 191k | v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER; |
2772 | 191k | break; |
2773 | 34.6k | case 1: |
2774 | 34.6k | v->codingset2 = CS_HIGH_MOT_INTER; |
2775 | 34.6k | break; |
2776 | 56.8k | case 2: |
2777 | 56.8k | v->codingset2 = CS_MID_RATE_INTER; |
2778 | 56.8k | break; |
2779 | 282k | } |
2780 | | |
2781 | 282k | apply_loop_filter = v->loop_filter && !(s->avctx->skip_loop_filter >= AVDISCARD_NONKEY); |
2782 | 282k | s->first_slice_line = 1; |
2783 | 282k | memset(v->cbp_base, 0, sizeof(v->cbp_base[0]) * 3 * s->mb_stride); |
2784 | 2.28M | for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { |
2785 | 2.20M | s->mb_x = 0; |
2786 | 2.20M | init_block_index(v); |
2787 | 32.3M | for (; s->mb_x < s->mb_width; s->mb_x++) { |
2788 | 30.3M | update_block_index(s); |
2789 | | |
2790 | 30.3M | if (v->fcm == ILACE_FIELD || (v->fcm == PROGRESSIVE && v->mv_type_is_raw) || v->skip_is_raw) |
2791 | 18.6M | if (get_bits_left(&v->gb) <= 1) { |
2792 | 30.1k | ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); |
2793 | 30.1k | return; |
2794 | 30.1k | } |
2795 | | |
2796 | 30.2M | if (v->fcm == ILACE_FIELD) { |
2797 | 1.79M | ret = vc1_decode_p_mb_intfi(v); |
2798 | 1.79M | if (apply_loop_filter) |
2799 | 1.65M | ff_vc1_p_loop_filter(v); |
2800 | 28.4M | } else if (v->fcm == ILACE_FRAME) { |
2801 | 13.2M | ret = vc1_decode_p_mb_intfr(v); |
2802 | 13.2M | if (apply_loop_filter) |
2803 | 3.33M | ff_vc1_p_intfr_loop_filter(v); |
2804 | 15.2M | } else { |
2805 | 15.2M | ret = vc1_decode_p_mb(v); |
2806 | 15.2M | if (apply_loop_filter) |
2807 | 10.1M | ff_vc1_p_loop_filter(v); |
2808 | 15.2M | } |
2809 | 30.2M | if (ret < 0 || get_bits_left(&v->gb) < 0 || get_bits_count(&v->gb) < 0) { |
2810 | | // TODO: may need modification to handle slice coding |
2811 | 172k | ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); |
2812 | 172k | av_log(s->avctx, AV_LOG_ERROR, "Error or Bits overconsumption: %i > %i at %ix%i\n", |
2813 | 172k | get_bits_count(&v->gb), v->gb.size_in_bits, s->mb_x, s->mb_y); |
2814 | 172k | return; |
2815 | 172k | } |
2816 | 30.1M | inc_blk_idx(v->topleft_blk_idx); |
2817 | 30.1M | inc_blk_idx(v->top_blk_idx); |
2818 | 30.1M | inc_blk_idx(v->left_blk_idx); |
2819 | 30.1M | inc_blk_idx(v->cur_blk_idx); |
2820 | 30.1M | } |
2821 | 1.99M | memmove(v->cbp_base, |
2822 | 1.99M | v->cbp - s->mb_stride, |
2823 | 1.99M | sizeof(v->cbp_base[0]) * 2 * s->mb_stride); |
2824 | 1.99M | memmove(v->ttblk_base, |
2825 | 1.99M | v->ttblk - s->mb_stride, |
2826 | 1.99M | sizeof(v->ttblk_base[0]) * 2 * s->mb_stride); |
2827 | 1.99M | memmove(v->is_intra_base, |
2828 | 1.99M | v->is_intra - s->mb_stride, |
2829 | 1.99M | sizeof(v->is_intra_base[0]) * 2 * s->mb_stride); |
2830 | 1.99M | memmove(v->luma_mv_base, |
2831 | 1.99M | v->luma_mv - s->mb_stride, |
2832 | 1.99M | sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride); |
2833 | 1.99M | s->first_slice_line = 0; |
2834 | 1.99M | } |
2835 | 80.0k | ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1, |
2836 | 80.0k | (s->end_mb_y << v->field_mode) - 1, ER_MB_END); |
2837 | 80.0k | } |
2838 | | |
2839 | | static void vc1_decode_b_blocks(VC1Context *v) |
2840 | 119k | { |
2841 | 119k | MpegEncContext *s = &v->s; |
2842 | | |
2843 | | /* select coding mode used for VLC tables selection */ |
2844 | 119k | switch (v->c_ac_table_index) { |
2845 | 69.3k | case 0: |
2846 | 69.3k | v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA; |
2847 | 69.3k | break; |
2848 | 23.7k | case 1: |
2849 | 23.7k | v->codingset = CS_HIGH_MOT_INTRA; |
2850 | 23.7k | break; |
2851 | 26.5k | case 2: |
2852 | 26.5k | v->codingset = CS_MID_RATE_INTRA; |
2853 | 26.5k | break; |
2854 | 119k | } |
2855 | | |
2856 | 119k | switch (v->c_ac_table_index) { |
2857 | 69.3k | case 0: |
2858 | 69.3k | v->codingset2 = (v->pqindex <= 8) ? CS_HIGH_RATE_INTER : CS_LOW_MOT_INTER; |
2859 | 69.3k | break; |
2860 | 23.7k | case 1: |
2861 | 23.7k | v->codingset2 = CS_HIGH_MOT_INTER; |
2862 | 23.7k | break; |
2863 | 26.5k | case 2: |
2864 | 26.5k | v->codingset2 = CS_MID_RATE_INTER; |
2865 | 26.5k | break; |
2866 | 119k | } |
2867 | | |
2868 | 119k | s->first_slice_line = 1; |
2869 | 1.23M | for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { |
2870 | 1.21M | s->mb_x = 0; |
2871 | 1.21M | init_block_index(v); |
2872 | 24.4M | for (; s->mb_x < s->mb_width; s->mb_x++) { |
2873 | 23.3M | update_block_index(s); |
2874 | | |
2875 | 23.3M | if (v->fcm == ILACE_FIELD || v->skip_is_raw || v->dmb_is_raw) |
2876 | 12.2M | if (get_bits_left(&v->gb) <= 1) { |
2877 | 13.7k | ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); |
2878 | 13.7k | return; |
2879 | 13.7k | } |
2880 | | |
2881 | 23.3M | if (v->fcm == ILACE_FIELD) { |
2882 | 1.32M | vc1_decode_b_mb_intfi(v); |
2883 | 1.32M | if (v->loop_filter) |
2884 | 519k | ff_vc1_b_intfi_loop_filter(v); |
2885 | 21.9M | } else if (v->fcm == ILACE_FRAME) { |
2886 | 12.8M | vc1_decode_b_mb_intfr(v); |
2887 | 12.8M | if (v->loop_filter) |
2888 | 5.66M | ff_vc1_p_intfr_loop_filter(v); |
2889 | 12.8M | } else { |
2890 | 9.09M | vc1_decode_b_mb(v); |
2891 | 9.09M | if (v->loop_filter) |
2892 | 4.26M | ff_vc1_i_loop_filter(v); |
2893 | 9.09M | } |
2894 | 23.3M | if (get_bits_left(&v->gb) < 0 || get_bits_count(&v->gb) < 0) { |
2895 | | // TODO: may need modification to handle slice coding |
2896 | 77.3k | ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_x, s->mb_y, ER_MB_ERROR); |
2897 | 77.3k | av_log(s->avctx, AV_LOG_ERROR, "Bits overconsumption: %i > %i at %ix%i\n", |
2898 | 77.3k | get_bits_count(&v->gb), v->gb.size_in_bits, s->mb_x, s->mb_y); |
2899 | 77.3k | return; |
2900 | 77.3k | } |
2901 | 23.3M | } |
2902 | 1.11M | memmove(v->cbp_base, |
2903 | 1.11M | v->cbp - s->mb_stride, |
2904 | 1.11M | sizeof(v->cbp_base[0]) * 2 * s->mb_stride); |
2905 | 1.11M | memmove(v->ttblk_base, |
2906 | 1.11M | v->ttblk - s->mb_stride, |
2907 | 1.11M | sizeof(v->ttblk_base[0]) * 2 * s->mb_stride); |
2908 | 1.11M | memmove(v->is_intra_base, |
2909 | 1.11M | v->is_intra - s->mb_stride, |
2910 | 1.11M | sizeof(v->is_intra_base[0]) * 2 * s->mb_stride); |
2911 | 1.11M | s->first_slice_line = 0; |
2912 | 1.11M | } |
2913 | 28.5k | ff_er_add_slice(&s->er, 0, s->start_mb_y << v->field_mode, s->mb_width - 1, |
2914 | 28.5k | (s->end_mb_y << v->field_mode) - 1, ER_MB_END); |
2915 | 28.5k | } |
2916 | | |
2917 | | static void vc1_decode_skip_blocks(VC1Context *v) |
2918 | 10.5k | { |
2919 | 10.5k | MpegEncContext *s = &v->s; |
2920 | | |
2921 | 10.5k | if (!v->s.last_pic.data[0]) |
2922 | 585 | return; |
2923 | | |
2924 | 9.91k | ff_er_add_slice(&s->er, 0, s->start_mb_y, s->mb_width - 1, s->end_mb_y - 1, ER_MB_END); |
2925 | 9.91k | s->first_slice_line = 1; |
2926 | 751k | for (s->mb_y = s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) { |
2927 | 741k | s->mb_x = 0; |
2928 | 741k | init_block_index(v); |
2929 | 741k | update_block_index(s); |
2930 | 741k | memcpy(s->dest[0], s->last_pic.data[0] + s->mb_y * 16 * s->linesize, s->linesize * 16); |
2931 | 741k | memcpy(s->dest[1], s->last_pic.data[1] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8); |
2932 | 741k | memcpy(s->dest[2], s->last_pic.data[2] + s->mb_y * 8 * s->uvlinesize, s->uvlinesize * 8); |
2933 | 741k | s->first_slice_line = 0; |
2934 | 741k | } |
2935 | 9.91k | } |
2936 | | |
2937 | | void ff_vc1_decode_blocks(VC1Context *v) |
2938 | 845k | { |
2939 | | |
2940 | 845k | v->esc3_level_length = 0; |
2941 | 845k | if (v->x8_type) { |
2942 | 64.3k | ff_intrax8_decode_picture(&v->x8, v->s.cur_pic.ptr, |
2943 | 64.3k | &v->gb, &v->s.mb_x, &v->s.mb_y, |
2944 | 64.3k | 2 * v->pq + v->halfpq, v->pq * !v->pquantizer, |
2945 | 64.3k | v->loop_filter, v->s.low_delay); |
2946 | | |
2947 | 64.3k | ff_er_add_slice(&v->s.er, 0, 0, |
2948 | 64.3k | (v->s.mb_x >> 1) - 1, (v->s.mb_y >> 1) - 1, |
2949 | 64.3k | ER_MB_END); |
2950 | 781k | } else { |
2951 | 781k | v->cur_blk_idx = 0; |
2952 | 781k | v->left_blk_idx = -1; |
2953 | 781k | v->topleft_blk_idx = 1; |
2954 | 781k | v->top_blk_idx = 2; |
2955 | 781k | switch (v->s.pict_type) { |
2956 | 351k | case AV_PICTURE_TYPE_I: |
2957 | 351k | if (v->profile == PROFILE_ADVANCED) |
2958 | 40.1k | vc1_decode_i_blocks_adv(v); |
2959 | 311k | else |
2960 | 311k | vc1_decode_i_blocks(v); |
2961 | 351k | break; |
2962 | 293k | case AV_PICTURE_TYPE_P: |
2963 | 293k | if (v->p_frame_skipped) |
2964 | 10.5k | vc1_decode_skip_blocks(v); |
2965 | 282k | else |
2966 | 282k | vc1_decode_p_blocks(v); |
2967 | 293k | break; |
2968 | 137k | case AV_PICTURE_TYPE_B: |
2969 | 137k | if (v->bi_type) { |
2970 | 17.4k | if (v->profile == PROFILE_ADVANCED) |
2971 | 5.04k | vc1_decode_i_blocks_adv(v); |
2972 | 12.4k | else |
2973 | 12.4k | vc1_decode_i_blocks(v); |
2974 | 17.4k | } else |
2975 | 119k | vc1_decode_b_blocks(v); |
2976 | 137k | break; |
2977 | 781k | } |
2978 | 781k | } |
2979 | 845k | } |