Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * RV60 decoder | ||
3 | * Copyright (c) 2007 Mike Melanson, Konstantin Shishkov | ||
4 | * Copyright (C) 2023 Peter Ross | ||
5 | * | ||
6 | * This file is part of FFmpeg. | ||
7 | * | ||
8 | * FFmpeg is free software; you can redistribute it and/or | ||
9 | * modify it under the terms of the GNU Lesser General Public | ||
10 | * License as published by the Free Software Foundation; either | ||
11 | * version 2.1 of the License, or (at your option) any later version. | ||
12 | * | ||
13 | * FFmpeg is distributed in the hope that it will be useful, | ||
14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
16 | * Lesser General Public License for more details. | ||
17 | * | ||
18 | * You should have received a copy of the GNU Lesser General Public | ||
19 | * License along with FFmpeg; if not, write to the Free Software | ||
20 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
21 | */ | ||
22 | |||
23 | #include "avcodec.h" | ||
24 | #include "codec_internal.h" | ||
25 | #include "decode.h" | ||
26 | #include "get_bits.h" | ||
27 | #include "golomb.h" | ||
28 | #include "libavutil/mem.h" | ||
29 | #include "rv60data.h" | ||
30 | #include "rv60dsp.h" | ||
31 | #include "rv60vlcs.h" | ||
32 | #include "threadprogress.h" | ||
33 | #include "unary.h" | ||
34 | #include "videodsp.h" | ||
35 | |||
36 | #include "libavutil/attributes.h" | ||
37 | |||
38 | static const int8_t frame_types[4] = {AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, AV_PICTURE_TYPE_NONE}; | ||
39 | |||
40 | enum CUType { | ||
41 | CU_INTRA = 0, | ||
42 | CU_INTER_MV, | ||
43 | CU_SKIP, | ||
44 | CU_INTER | ||
45 | }; | ||
46 | |||
47 | enum PUType { | ||
48 | PU_FULL = 0, | ||
49 | PU_N2HOR, | ||
50 | PU_N2VER, | ||
51 | PU_QUARTERS, | ||
52 | PU_N4HOR, | ||
53 | PU_N34HOR, | ||
54 | PU_N4VER, | ||
55 | PU_N34VER | ||
56 | }; | ||
57 | |||
58 | enum IntraMode { | ||
59 | INTRAMODE_INDEX = 0, | ||
60 | INTRAMODE_DC64, | ||
61 | INTRAMODE_PLANE64, | ||
62 | INTRAMODE_MODE | ||
63 | }; | ||
64 | |||
65 | enum MVRefEnum { | ||
66 | MVREF_NONE = 0, | ||
67 | MVREF_REF0, | ||
68 | MVREF_REF1, | ||
69 | MVREF_BREF, | ||
70 | MVREF_REF0ANDBREF, | ||
71 | MVREF_SKIP0, | ||
72 | MVREF_SKIP1, | ||
73 | MVREF_SKIP2, | ||
74 | MVREF_SKIP3 | ||
75 | }; | ||
76 | |||
77 | static const uint8_t skip_mv_ref[4] = {MVREF_SKIP0, MVREF_SKIP1, MVREF_SKIP2, MVREF_SKIP3}; | ||
78 | |||
79 | enum { | ||
80 | TRANSFORM_NONE = 0, | ||
81 | TRANSFORM_16X16, | ||
82 | TRANSFORM_8X8, | ||
83 | TRANSFORM_4X4 | ||
84 | }; | ||
85 | |||
86 | static const VLCElem * cbp8_vlc[7][4]; | ||
87 | static const VLCElem * cbp16_vlc[7][4][4]; | ||
88 | |||
89 | typedef struct { | ||
90 | const VLCElem * l0[2]; | ||
91 | const VLCElem * l12[2]; | ||
92 | const VLCElem * l3[2]; | ||
93 | const VLCElem * esc; | ||
94 | } CoeffVLCs; | ||
95 | |||
96 | static CoeffVLCs intra_coeff_vlc[5]; | ||
97 | static CoeffVLCs inter_coeff_vlc[7]; | ||
98 | |||
99 | #define MAX_VLC_SIZE 864 | ||
100 | static VLCElem table_data[129148]; | ||
101 | |||
102 | /* 32-bit version of rv34_gen_vlc */ | ||
103 | 392 | static const VLCElem * gen_vlc(const uint8_t * bits, int size, VLCInitState * state) | |
104 | { | ||
105 | 392 | int counts[17] = {0}; | |
106 | uint32_t codes[18]; | ||
107 | uint32_t cw[MAX_VLC_SIZE]; | ||
108 | |||
109 |
2/2✓ Branch 0 taken 66944 times.
✓ Branch 1 taken 392 times.
|
67336 | for (int i = 0; i < size; i++) |
110 | 66944 | counts[bits[i]]++; | |
111 | |||
112 | 392 | codes[0] = counts[0] = 0; | |
113 |
2/2✓ Branch 0 taken 6664 times.
✓ Branch 1 taken 392 times.
|
7056 | for (int i = 0; i < 17; i++) |
114 | 6664 | codes[i+1] = (codes[i] + counts[i]) << 1; | |
115 | |||
116 |
2/2✓ Branch 0 taken 66944 times.
✓ Branch 1 taken 392 times.
|
67336 | for (int i = 0; i < size; i++) |
117 | 66944 | cw[i] = codes[bits[i]]++; | |
118 | |||
119 | 392 | return ff_vlc_init_tables(state, 9, size, | |
120 | bits, 1, 1, | ||
121 | cw, 4, 4, 0); | ||
122 | } | ||
123 | |||
124 | 4 | static void build_coeff_vlc(const CoeffLens * lens, CoeffVLCs * vlc, int count, VLCInitState * state) | |
125 | { | ||
126 |
2/2✓ Branch 0 taken 24 times.
✓ Branch 1 taken 4 times.
|
28 | for (int i = 0; i < count; i++) { |
127 |
2/2✓ Branch 0 taken 48 times.
✓ Branch 1 taken 24 times.
|
72 | for (int j = 0; j < 2; j++) { |
128 | 48 | vlc[i].l0[j] = gen_vlc(lens[i].l0[j], 864, state); | |
129 | 48 | vlc[i].l12[j] = gen_vlc(lens[i].l12[j], 108, state); | |
130 | 48 | vlc[i].l3[j] = gen_vlc(lens[i].l3[j], 108, state); | |
131 | } | ||
132 | 24 | vlc[i].esc = gen_vlc(lens[i].esc, 32, state); | |
133 | } | ||
134 | 4 | } | |
135 | |||
136 | 2 | static av_cold void rv60_init_static_data(void) | |
137 | { | ||
138 | 2 | VLCInitState state = VLC_INIT_STATE(table_data); | |
139 | |||
140 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 2 times.
|
16 | for (int i = 0; i < 7; i++) |
141 |
2/2✓ Branch 0 taken 56 times.
✓ Branch 1 taken 14 times.
|
70 | for (int j = 0; j < 4; j++) |
142 | 56 | cbp16_vlc[i][0][j] = cbp8_vlc[i][j] = gen_vlc(rv60_cbp8_lens[i][j], 64, &state); | |
143 | |||
144 |
2/2✓ Branch 0 taken 14 times.
✓ Branch 1 taken 2 times.
|
16 | for (int i = 0; i < 7; i++) |
145 |
2/2✓ Branch 0 taken 42 times.
✓ Branch 1 taken 14 times.
|
56 | for (int j = 0; j < 3; j++) |
146 |
2/2✓ Branch 0 taken 168 times.
✓ Branch 1 taken 42 times.
|
210 | for (int k = 0; k < 4; k++) |
147 | 168 | cbp16_vlc[i][j + 1][k] = gen_vlc(rv60_cbp16_lens[i][j][k], 64, &state); | |
148 | |||
149 | 2 | build_coeff_vlc(rv60_intra_lens, intra_coeff_vlc, 5, &state); | |
150 | 2 | build_coeff_vlc(rv60_inter_lens, inter_coeff_vlc, 7, &state); | |
151 | 2 | } | |
152 | |||
153 | typedef struct { | ||
154 | int sign; | ||
155 | int size; | ||
156 | const uint8_t * data; | ||
157 | int data_size; | ||
158 | } Slice; | ||
159 | |||
160 | typedef struct { | ||
161 | int cu_split_pos; | ||
162 | uint8_t cu_split[1+4+16+64]; | ||
163 | |||
164 | uint8_t coded_blk[64]; | ||
165 | |||
166 | uint8_t avg_buffer[64*64 + 32*32*2]; | ||
167 | uint8_t * avg_data[3]; | ||
168 | int avg_linesize[3]; | ||
169 | } ThreadContext; | ||
170 | |||
171 | typedef struct { | ||
172 | int16_t x; | ||
173 | int16_t y; | ||
174 | } MV; | ||
175 | |||
176 | typedef struct { | ||
177 | enum MVRefEnum mvref; | ||
178 | MV f_mv; | ||
179 | MV b_mv; | ||
180 | } MVInfo; | ||
181 | |||
182 | typedef struct { | ||
183 | enum IntraMode imode; | ||
184 | MVInfo mv; | ||
185 | } BlockInfo; | ||
186 | |||
187 | typedef struct { | ||
188 | enum CUType cu_type; | ||
189 | enum PUType pu_type; | ||
190 | } PUInfo; | ||
191 | |||
192 | typedef struct RV60Context { | ||
193 | AVCodecContext * avctx; | ||
194 | VideoDSPContext vdsp; | ||
195 | |||
196 | #define CUR_PIC 0 | ||
197 | #define LAST_PIC 1 | ||
198 | #define NEXT_PIC 2 | ||
199 | AVFrame *last_frame[3]; | ||
200 | |||
201 | int pict_type; | ||
202 | int qp; | ||
203 | int osvquant; | ||
204 | int ts; | ||
205 | int two_f_refs; | ||
206 | int qp_off_type; | ||
207 | int deblock; | ||
208 | int deblock_chroma; | ||
209 | int awidth; | ||
210 | int aheight; | ||
211 | int cu_width; | ||
212 | int cu_height; | ||
213 | |||
214 | Slice * slice; | ||
215 | |||
216 | int pu_stride; | ||
217 | PUInfo * pu_info; | ||
218 | |||
219 | int blk_stride; | ||
220 | BlockInfo * blk_info; | ||
221 | |||
222 | int dblk_stride; | ||
223 | uint8_t * left_str; | ||
224 | uint8_t * top_str; | ||
225 | |||
226 | uint64_t ref_pts[2], ts_scale; | ||
227 | uint32_t ref_ts[2]; | ||
228 | |||
229 | struct ThreadProgress *progress; | ||
230 | unsigned nb_progress; | ||
231 | } RV60Context; | ||
232 | |||
233 | 39 | static int progress_init(RV60Context *s, unsigned count) | |
234 | { | ||
235 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 37 times.
|
39 | if (s->nb_progress < count) { |
236 | 2 | void *tmp = av_realloc_array(s->progress, count, sizeof(*s->progress)); | |
237 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (!tmp) |
238 | ✗ | return AVERROR(ENOMEM); | |
239 | 2 | s->progress = tmp; | |
240 | 2 | memset(s->progress + s->nb_progress, 0, (count - s->nb_progress) * sizeof(*s->progress)); | |
241 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 2 times.
|
12 | for (int i = s->nb_progress; i < count; i++) { |
242 | 10 | int ret = ff_thread_progress_init(&s->progress[i], 1); | |
243 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 10 times.
|
10 | if (ret < 0) |
244 | ✗ | return ret; | |
245 | 10 | s->nb_progress = i + 1; | |
246 | } | ||
247 | } | ||
248 | |||
249 |
2/2✓ Branch 0 taken 102 times.
✓ Branch 1 taken 39 times.
|
141 | for (int i = 0; i < count; i++) |
250 | 102 | ff_thread_progress_reset(&s->progress[i]); | |
251 | |||
252 | 39 | return 0; | |
253 | } | ||
254 | |||
255 | 4 | static av_cold int rv60_decode_init(AVCodecContext * avctx) | |
256 | { | ||
257 | static AVOnce init_static_once = AV_ONCE_INIT; | ||
258 | 4 | RV60Context *s = avctx->priv_data; | |
259 | |||
260 | 4 | s->avctx = avctx; | |
261 | |||
262 | 4 | ff_videodsp_init(&s->vdsp, 8); | |
263 | |||
264 | 4 | avctx->pix_fmt = AV_PIX_FMT_YUV420P; | |
265 | |||
266 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 4 times.
|
16 | for (int i = 0; i < 3; i++) { |
267 | 12 | s->last_frame[i] = av_frame_alloc(); | |
268 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12 times.
|
12 | if (!s->last_frame[i]) |
269 | ✗ | return AVERROR(ENOMEM); | |
270 | } | ||
271 | |||
272 | 4 | ff_thread_once(&init_static_once, rv60_init_static_data); | |
273 | |||
274 | 4 | return 0; | |
275 | } | ||
276 | |||
277 | 39 | static int update_dimensions_clear_info(RV60Context *s, int width, int height) | |
278 | { | ||
279 | int ret; | ||
280 | |||
281 |
2/4✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 39 times.
|
39 | if (width != s->avctx->width || height != s->avctx->height) { |
282 | |||
283 | ✗ | av_log(s->avctx, AV_LOG_INFO, "changing dimensions to %dx%d\n", width, height); | |
284 | |||
285 | ✗ | for (int i = 0; i < 3; i++) | |
286 | ✗ | av_frame_unref(s->last_frame[i]); | |
287 | |||
288 | ✗ | if ((ret = ff_set_dimensions(s->avctx, width, height)) < 0) | |
289 | ✗ | return ret; | |
290 | |||
291 | ✗ | if (s->avctx->width <= 64 || s->avctx->height <= 64) | |
292 | ✗ | av_log(s->avctx, AV_LOG_WARNING, "unable to faithfully reproduce emulated edges; expect visual artefacts\n"); | |
293 | } | ||
294 | |||
295 | 39 | s->awidth = FFALIGN(width, 16); | |
296 | 39 | s->aheight = FFALIGN(height, 16); | |
297 | |||
298 | 39 | s->cu_width = (width + 63) >> 6; | |
299 | 39 | s->cu_height = (height + 63) >> 6; | |
300 | |||
301 | 39 | s->pu_stride = s->cu_width << 3; | |
302 | 39 | s->blk_stride = s->cu_width << 4; | |
303 | |||
304 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = av_reallocp_array(&s->slice, s->cu_height, sizeof(s->slice[0]))) < 0) |
305 | ✗ | return ret; | |
306 | |||
307 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = av_reallocp_array(&s->pu_info, s->pu_stride * (s->cu_height << 3), sizeof(s->pu_info[0]))) < 0) |
308 | ✗ | return ret; | |
309 | |||
310 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = av_reallocp_array(&s->blk_info, s->blk_stride * (s->cu_height << 4), sizeof(s->blk_info[0]))) < 0) |
311 | ✗ | return ret; | |
312 | |||
313 | 39 | memset(s->pu_info, 0, s->pu_stride * (s->cu_height << 3) * sizeof(s->pu_info[0])); | |
314 | |||
315 |
2/2✓ Branch 0 taken 1632 times.
✓ Branch 1 taken 39 times.
|
1671 | for (int j = 0; j < s->cu_height << 4; j++) |
316 |
2/2✓ Branch 0 taken 101376 times.
✓ Branch 1 taken 1632 times.
|
103008 | for (int i = 0; i < s->cu_width << 4; i++) |
317 | 101376 | s->blk_info[j*s->blk_stride + i].mv.mvref = MVREF_NONE; | |
318 | |||
319 |
1/2✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
|
39 | if (s->deblock) { |
320 | int size; | ||
321 | |||
322 | 39 | s->dblk_stride = s->awidth >> 2; | |
323 | |||
324 | 39 | size = s->dblk_stride * (s->aheight >> 2); | |
325 | |||
326 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = av_reallocp_array(&s->top_str, size, sizeof(s->top_str[0]))) < 0) |
327 | ✗ | return ret; | |
328 | |||
329 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = av_reallocp_array(&s->left_str, size, sizeof(s->left_str[0]))) < 0) |
330 | ✗ | return ret; | |
331 | |||
332 | 39 | memset(s->top_str, 0, size); | |
333 | 39 | memset(s->left_str, 0, size); | |
334 | } | ||
335 | |||
336 | 39 | return 0; | |
337 | } | ||
338 | |||
339 | 4039 | static int read_code012(GetBitContext * gb) | |
340 | { | ||
341 |
2/2✓ Branch 1 taken 2755 times.
✓ Branch 2 taken 1284 times.
|
4039 | if (!get_bits1(gb)) |
342 | 2755 | return 0; | |
343 | 1284 | return get_bits1(gb) + 1; | |
344 | } | ||
345 | |||
346 | 39 | static int read_frame_header(RV60Context *s, GetBitContext *gb, int * width, int * height) | |
347 | { | ||
348 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if (get_bits(gb, 2) != 3) |
349 | ✗ | return AVERROR_INVALIDDATA; | |
350 | |||
351 | 39 | skip_bits(gb, 2); | |
352 | 39 | skip_bits(gb, 4); | |
353 | |||
354 | 39 | s->pict_type = frame_types[get_bits(gb, 2)]; | |
355 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (s->pict_type == AV_PICTURE_TYPE_NONE) |
356 | ✗ | return AVERROR_INVALIDDATA; | |
357 | |||
358 | 39 | s->qp = get_bits(gb, 6); | |
359 | 39 | skip_bits1(gb); | |
360 | 39 | skip_bits(gb, 2); | |
361 | 39 | s->osvquant = get_bits(gb, 2); | |
362 | 39 | skip_bits1(gb); | |
363 | 39 | skip_bits(gb, 2); | |
364 | 39 | s->ts = get_bits(gb, 24); | |
365 | 39 | *width = (get_bits(gb, 11) + 1) * 4; | |
366 | 39 | *height = get_bits(gb, 11) * 4; | |
367 | 39 | skip_bits1(gb); | |
368 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 37 times.
|
39 | if (s->pict_type == AV_PICTURE_TYPE_I) { |
369 | 2 | s->two_f_refs = 0; | |
370 | } else { | ||
371 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 37 times.
|
37 | if (get_bits1(gb)) |
372 | ✗ | skip_bits(gb, 3); | |
373 | 37 | s->two_f_refs = get_bits1(gb); | |
374 | } | ||
375 | 39 | read_code012(gb); | |
376 | 39 | read_code012(gb); | |
377 | 39 | s->qp_off_type = read_code012(gb); | |
378 | 39 | s->deblock = get_bits1(gb); | |
379 |
2/4✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 39 times.
✗ Branch 4 not taken.
|
39 | s->deblock_chroma = s->deblock && !get_bits1(gb); |
380 | |||
381 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if (get_bits1(gb)) { |
382 | ✗ | int count = get_bits(gb, 2); | |
383 | ✗ | if (count) { | |
384 | ✗ | skip_bits(gb, 2); | |
385 | ✗ | for (int i = 0; i < count; i++) | |
386 | ✗ | for (int j = 0; j < 2 << i; j++) | |
387 | ✗ | skip_bits(gb, 8); | |
388 | } | ||
389 | } | ||
390 | |||
391 | 39 | return 0; | |
392 | } | ||
393 | |||
394 | 39 | static int read_slice_sizes(RV60Context *s, GetBitContext *gb) | |
395 | { | ||
396 | 39 | int nbits = get_bits(gb, 5) + 1; | |
397 | int last_size; | ||
398 | |||
399 |
2/2✓ Branch 0 taken 102 times.
✓ Branch 1 taken 39 times.
|
141 | for (int i = 0; i < s->cu_height; i++) |
400 | 102 | s->slice[i].sign = get_bits1(gb); | |
401 | |||
402 | 39 | s->slice[0].size = last_size = get_bits_long(gb, nbits); | |
403 | |||
404 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (last_size < 0) |
405 | ✗ | return AVERROR_INVALIDDATA; | |
406 | |||
407 |
2/2✓ Branch 0 taken 63 times.
✓ Branch 1 taken 39 times.
|
102 | for (int i = 1; i < s->cu_height; i++) { |
408 | 63 | int diff = get_bits_long(gb, nbits); | |
409 |
2/2✓ Branch 0 taken 8 times.
✓ Branch 1 taken 55 times.
|
63 | if (s->slice[i].sign) |
410 | 8 | last_size += diff; | |
411 | else | ||
412 | 55 | last_size -= diff; | |
413 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 63 times.
|
63 | if (last_size <= 0) |
414 | ✗ | return AVERROR_INVALIDDATA; | |
415 | 63 | s->slice[i].size = last_size; | |
416 | } | ||
417 | |||
418 | 39 | align_get_bits(gb); | |
419 | 39 | return 0; | |
420 | } | ||
421 | |||
422 | 4447 | static int read_intra_mode(GetBitContext * gb, int * param) | |
423 | { | ||
424 |
2/2✓ Branch 1 taken 3922 times.
✓ Branch 2 taken 525 times.
|
4447 | if (get_bits1(gb)) { |
425 | 3922 | *param = read_code012(gb); | |
426 | 3922 | return INTRAMODE_INDEX; | |
427 | } else { | ||
428 | 525 | *param = get_bits(gb, 5); | |
429 | 525 | return INTRAMODE_MODE; | |
430 | } | ||
431 | } | ||
432 | |||
433 | 15476 | static int has_top_block(const RV60Context * s, int xpos, int ypos, int dx, int dy, int size) | |
434 | { | ||
435 |
4/4✓ Branch 0 taken 15315 times.
✓ Branch 1 taken 161 times.
✓ Branch 2 taken 14998 times.
✓ Branch 3 taken 317 times.
|
15476 | return ypos + dy && xpos + dx + size <= s->awidth; |
436 | } | ||
437 | |||
438 | 13316 | static int has_left_block(const RV60Context * s, int xpos, int ypos, int dx, int dy, int size) | |
439 | { | ||
440 |
4/4✓ Branch 0 taken 13232 times.
✓ Branch 1 taken 84 times.
✓ Branch 2 taken 13080 times.
✓ Branch 3 taken 152 times.
|
13316 | return xpos + dx && ypos + dy + size <= s->aheight; |
441 | } | ||
442 | |||
443 | 8848 | static int has_top_right_block(const RV60Context * s, int xpos, int ypos, int dx, int dy, int size) | |
444 | { | ||
445 |
2/2✓ Branch 1 taken 8603 times.
✓ Branch 2 taken 245 times.
|
8848 | if (has_top_block(s, xpos, ypos, dx, dy, size * 2)) { |
446 | 8603 | int cxpos = ((xpos + dx) & 63) >> ff_log2(size); | |
447 | 8603 | int cypos = ((ypos + dy) & 63) >> ff_log2(size); | |
448 | 8603 | return !(rv60_avail_mask[cxpos] & cypos); | |
449 | } | ||
450 | 245 | return 0; | |
451 | } | ||
452 | |||
453 | 8869 | static int has_left_down_block(const RV60Context * s, int xpos, int ypos, int dx, int dy, int size) | |
454 | { | ||
455 |
2/2✓ Branch 1 taken 8717 times.
✓ Branch 2 taken 152 times.
|
8869 | if (has_left_block(s, xpos, ypos, dx, dy, size * 2)) { |
456 | 8717 | int cxpos = (~(xpos + dx) & 63) >> ff_log2(size); | |
457 | 8717 | int cypos = (~(ypos + dy) & 63) >> ff_log2(size); | |
458 | 8717 | return rv60_avail_mask[cxpos] & cypos; | |
459 | } | ||
460 | 152 | return 0; | |
461 | } | ||
462 | |||
463 | typedef struct { | ||
464 | uint8_t t[129]; | ||
465 | uint8_t l[129]; | ||
466 | int has_t; | ||
467 | int has_tr; | ||
468 | int has_l; | ||
469 | int has_ld; | ||
470 | } IntraPredContext; | ||
471 | |||
472 | typedef struct { | ||
473 | int xpos; | ||
474 | int ypos; | ||
475 | int pu_pos; | ||
476 | int blk_pos; | ||
477 | |||
478 | enum CUType cu_type; | ||
479 | enum PUType pu_type; | ||
480 | enum IntraMode imode[4]; | ||
481 | int imode_param[4]; | ||
482 | MVInfo mv[4]; | ||
483 | |||
484 | IntraPredContext ipred; | ||
485 | } CUContext; | ||
486 | |||
487 | 9033 | static void ipred_init(IntraPredContext * i) | |
488 | { | ||
489 | 9033 | memset(i->t, 0x80, sizeof(i->t)); | |
490 | 9033 | memset(i->l, 0x80, sizeof(i->l)); | |
491 | 9033 | i->has_t = i->has_tr = i->has_l = i->has_ld = 0; | |
492 | 9033 | } | |
493 | |||
494 | 9033 | static void populate_ipred(const RV60Context * s, CUContext * cu, const uint8_t * src, int stride, int xoff, int yoff, int size, int is_luma) | |
495 | { | ||
496 |
2/2✓ Branch 0 taken 4447 times.
✓ Branch 1 taken 4586 times.
|
9033 | if (is_luma) |
497 | 4447 | src += (cu->ypos + yoff) * stride + cu->xpos + xoff; | |
498 | else | ||
499 | 4586 | src += (cu->ypos >> 1) * stride + (cu->xpos >> 1); | |
500 | |||
501 | 9033 | ipred_init(&cu->ipred); | |
502 | |||
503 |
2/2✓ Branch 0 taken 8848 times.
✓ Branch 1 taken 185 times.
|
9033 | if (cu->ypos + yoff > 0) { |
504 | 8848 | cu->ipred.has_t = 1; | |
505 | |||
506 | 8848 | memcpy(cu->ipred.t + 1, src - stride, size); | |
507 | |||
508 |
6/6✓ Branch 0 taken 4370 times.
✓ Branch 1 taken 4478 times.
✓ Branch 3 taken 1529 times.
✓ Branch 4 taken 2841 times.
✓ Branch 5 taken 4478 times.
✓ Branch 6 taken 1529 times.
|
8848 | if ((is_luma && has_top_right_block(s, cu->xpos, cu->ypos, xoff, yoff, size)) || |
509 |
2/2✓ Branch 1 taken 2856 times.
✓ Branch 2 taken 1622 times.
|
4478 | (!is_luma && has_top_right_block(s, cu->xpos, cu->ypos, 0, 0, size << 1))) { |
510 | 5697 | cu->ipred.has_tr = 1; | |
511 | 5697 | memcpy(cu->ipred.t + size + 1, src - stride + size, size); | |
512 | } else | ||
513 | 3151 | memset(cu->ipred.t + size + 1, cu->ipred.t[size], size); | |
514 | |||
515 |
2/2✓ Branch 0 taken 8690 times.
✓ Branch 1 taken 158 times.
|
8848 | if (cu->xpos + xoff > 0) |
516 | 8690 | cu->ipred.t[0] = src[-stride - 1]; | |
517 | } | ||
518 | |||
519 |
2/2✓ Branch 0 taken 8869 times.
✓ Branch 1 taken 164 times.
|
9033 | if (cu->xpos + xoff > 0) { |
520 | 8869 | cu->ipred.has_l = 1; | |
521 | |||
522 |
2/2✓ Branch 0 taken 54160 times.
✓ Branch 1 taken 8869 times.
|
63029 | for (int y = 0; y < size; y++) |
523 | 54160 | cu->ipred.l[y + 1] = src[y*stride - 1]; | |
524 | |||
525 |
6/6✓ Branch 0 taken 4385 times.
✓ Branch 1 taken 4484 times.
✓ Branch 3 taken 2994 times.
✓ Branch 4 taken 1391 times.
✓ Branch 5 taken 4484 times.
✓ Branch 6 taken 2994 times.
|
8869 | if ((is_luma && has_left_down_block(s, cu->xpos, cu->ypos, xoff, yoff, size)) || |
526 |
2/2✓ Branch 1 taken 1368 times.
✓ Branch 2 taken 3116 times.
|
4484 | (!is_luma && has_left_down_block(s, cu->xpos, cu->ypos, 0, 0, size << 1))) { |
527 | 2759 | cu->ipred.has_ld = 1; | |
528 |
2/2✓ Branch 0 taken 17032 times.
✓ Branch 1 taken 2759 times.
|
19791 | for (int y = size; y < size * 2; y++) |
529 | 17032 | cu->ipred.l[y + 1] = src[y*stride - 1]; | |
530 | } else | ||
531 | 6110 | memset(cu->ipred.l + size + 1, cu->ipred.l[size], size); | |
532 | |||
533 |
2/2✓ Branch 0 taken 8690 times.
✓ Branch 1 taken 179 times.
|
8869 | if (cu->ypos + yoff > 0) |
534 | 8690 | cu->ipred.l[0] = src[-stride - 1]; | |
535 | } | ||
536 | 9033 | } | |
537 | |||
538 | 1492 | static void pred_plane(const IntraPredContext * p, uint8_t * dst, int stride, int size) | |
539 | { | ||
540 | 1492 | int lastl = p->l[size + 1]; | |
541 | 1492 | int lastt = p->t[size + 1]; | |
542 | int tmp1[64], tmp2[64]; | ||
543 | int top_ref[64], left_ref[64]; | ||
544 | int shift; | ||
545 | |||
546 |
2/2✓ Branch 0 taken 6656 times.
✓ Branch 1 taken 1492 times.
|
8148 | for (int i = 0; i < size; i++) { |
547 | 6656 | tmp1[i] = lastl - p->t[i + 1]; | |
548 | 6656 | tmp2[i] = lastt - p->l[i + 1]; | |
549 | } | ||
550 | |||
551 | 1492 | shift = ff_log2(size) + 1; | |
552 |
2/2✓ Branch 0 taken 6656 times.
✓ Branch 1 taken 1492 times.
|
8148 | for (int i = 0; i < size; i++) { |
553 | 6656 | top_ref[i] = p->t[i + 1] << (shift - 1); | |
554 | 6656 | left_ref[i] = p->l[i + 1] << (shift - 1); | |
555 | } | ||
556 | |||
557 |
2/2✓ Branch 0 taken 6656 times.
✓ Branch 1 taken 1492 times.
|
8148 | for (int y = 0; y < size; y++) { |
558 | 6656 | int add = tmp2[y]; | |
559 | 6656 | int sum = left_ref[y] + size; | |
560 |
2/2✓ Branch 0 taken 34816 times.
✓ Branch 1 taken 6656 times.
|
41472 | for (int x = 0; x < size; x++) { |
561 | 34816 | int v = tmp1[x] + top_ref[x]; | |
562 | 34816 | sum += add; | |
563 | 34816 | top_ref[x] = v; | |
564 | 34816 | dst[y*stride + x] = (sum + v) >> shift; | |
565 | } | ||
566 | } | ||
567 | 1492 | } | |
568 | |||
569 | 5606 | static void pred_dc(const IntraPredContext * p, uint8_t * dst, int stride, int size, int filter) | |
570 | { | ||
571 | int dc; | ||
572 | |||
573 |
3/4✓ Branch 0 taken 129 times.
✓ Branch 1 taken 5477 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 129 times.
|
5606 | if (!p->has_t && !p->has_l) |
574 | ✗ | dc = 0x80; | |
575 | else { | ||
576 | 5606 | int sum = 0; | |
577 |
2/2✓ Branch 0 taken 5477 times.
✓ Branch 1 taken 129 times.
|
5606 | if (p->has_t) |
578 |
2/2✓ Branch 0 taken 37568 times.
✓ Branch 1 taken 5477 times.
|
43045 | for (int x = 0; x < size; x++) |
579 | 37568 | sum += p->t[x + 1]; | |
580 |
2/2✓ Branch 0 taken 5458 times.
✓ Branch 1 taken 148 times.
|
5606 | if (p->has_l) |
581 |
2/2✓ Branch 0 taken 37304 times.
✓ Branch 1 taken 5458 times.
|
42762 | for (int y = 0; y < size; y++) |
582 | 37304 | sum += p->l[y + 1]; | |
583 |
4/4✓ Branch 0 taken 5477 times.
✓ Branch 1 taken 129 times.
✓ Branch 2 taken 5329 times.
✓ Branch 3 taken 148 times.
|
5606 | if (p->has_t && p->has_l) |
584 | 5329 | dc = (sum + size) / (size * 2); | |
585 | else | ||
586 | 277 | dc = (sum + size / 2) / size; | |
587 | } | ||
588 | |||
589 |
2/2✓ Branch 0 taken 38516 times.
✓ Branch 1 taken 5606 times.
|
44122 | for (int y = 0; y < size; y++) |
590 | 38516 | memset(dst + y*stride, dc, size); | |
591 | |||
592 |
6/6✓ Branch 0 taken 2478 times.
✓ Branch 1 taken 3128 times.
✓ Branch 2 taken 2427 times.
✓ Branch 3 taken 51 times.
✓ Branch 4 taken 2373 times.
✓ Branch 5 taken 54 times.
|
5606 | if (filter && p->has_t && p->has_l) { |
593 | 2373 | dst[0] = (p->t[1] + p->l[1] + 2 * dst[0] + 2) >> 2; | |
594 |
2/2✓ Branch 0 taken 16911 times.
✓ Branch 1 taken 2373 times.
|
19284 | for (int x = 1; x < size; x++) |
595 | 16911 | dst[x] = (p->t[x + 1] + 3 * dst[x] + 2) >> 2; | |
596 |
2/2✓ Branch 0 taken 16911 times.
✓ Branch 1 taken 2373 times.
|
19284 | for (int y = 1; y < size; y++) |
597 | 16911 | dst[y*stride] = (p->l[y + 1] + 3 * dst[y*stride] + 2) >> 2; | |
598 | } | ||
599 | 5606 | } | |
600 | |||
601 | 1762 | static void filter_weak(uint8_t * dst, const uint8_t * src, int size) | |
602 | { | ||
603 | 1762 | dst[0] = src[0]; | |
604 |
2/2✓ Branch 0 taken 6530 times.
✓ Branch 1 taken 1762 times.
|
8292 | for (int i = 1; i < size - 1; i++) |
605 | 6530 | dst[i] = (src[i - 1] + 2*src[i] + src[i + 1] + 2) >> 2; | |
606 | 1762 | dst[size - 1] = src[size - 1]; | |
607 | 1762 | } | |
608 | |||
609 | ✗ | static void filter_bilin32(uint8_t * dst, int v0, int v1, int size) | |
610 | { | ||
611 | ✗ | int diff = v1 - v0; | |
612 | ✗ | int sum = (v0 << 5) + (1 << (5 - 1)); | |
613 | ✗ | for (int i = 0; i < size; i++) { | |
614 | ✗ | dst[i] = sum >> 5; | |
615 | ✗ | sum += diff; | |
616 | } | ||
617 | ✗ | } | |
618 | |||
619 | 355 | static void pred_hor_angle(uint8_t * dst, int stride, int size, int weight, const uint8_t * src) | |
620 | { | ||
621 | 355 | int sum = 0; | |
622 |
2/2✓ Branch 0 taken 1420 times.
✓ Branch 1 taken 355 times.
|
1775 | for (int x = 0; x < size; x++) { |
623 | int off, frac; | ||
624 | 1420 | sum += weight; | |
625 | 1420 | off = (sum >> 5) + 32; | |
626 | 1420 | frac = sum & 0x1F; | |
627 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1420 times.
|
1420 | if (!frac) |
628 | ✗ | for (int y = 0; y < size; y++) | |
629 | ✗ | dst[y*stride + x] = src[off + y]; | |
630 | else { | ||
631 |
2/2✓ Branch 0 taken 5680 times.
✓ Branch 1 taken 1420 times.
|
7100 | for (int y = 0; y < size; y++) { |
632 | 5680 | int a = src[off + y]; | |
633 | 5680 | int b = src[off + y + 1]; | |
634 | 5680 | dst[y*stride + x] = ((32 - frac) * a + frac * b + 16) >> 5; | |
635 | } | ||
636 | } | ||
637 | } | ||
638 | 355 | } | |
639 | |||
640 | 351 | static void pred_ver_angle(uint8_t * dst, int stride, int size, int weight, const uint8_t * src) | |
641 | { | ||
642 | 351 | int sum = 0; | |
643 |
2/2✓ Branch 0 taken 1516 times.
✓ Branch 1 taken 351 times.
|
1867 | for (int y = 0; y < size; y++) { |
644 | int off, frac; | ||
645 | 1516 | sum += weight; | |
646 | 1516 | off = (sum >> 5) + 32; | |
647 | 1516 | frac = sum & 0x1F; | |
648 |
2/2✓ Branch 0 taken 208 times.
✓ Branch 1 taken 1308 times.
|
1516 | if (!frac) |
649 | 208 | memcpy(dst + y*stride, src + off, size); | |
650 | else { | ||
651 |
2/2✓ Branch 0 taken 5232 times.
✓ Branch 1 taken 1308 times.
|
6540 | for (int x = 0; x < size; x++) { |
652 | 5232 | int a = src[off + x]; | |
653 | 5232 | int b = src[off + x + 1]; | |
654 | 5232 | dst[y*stride + x] = ((32 - frac) * a + frac * b + 16) >> 5; | |
655 | } | ||
656 | } | ||
657 | } | ||
658 | 351 | } | |
659 | |||
660 | 9033 | static int pred_angle(const IntraPredContext * p, uint8_t * dst, int stride, int size, int imode, int filter) | |
661 | { | ||
662 | uint8_t filtered1[96], filtered2[96]; | ||
663 | |||
664 |
2/2✓ Branch 0 taken 1492 times.
✓ Branch 1 taken 7541 times.
|
9033 | if (!imode) { |
665 | 1492 | pred_plane(p, dst, stride, size); | |
666 |
2/2✓ Branch 0 taken 5606 times.
✓ Branch 1 taken 1935 times.
|
7541 | } else if (imode == 1) { |
667 | 5606 | pred_dc(p, dst, stride, size, filter); | |
668 |
2/2✓ Branch 0 taken 323 times.
✓ Branch 1 taken 1612 times.
|
1935 | } else if (imode <= 9) { |
669 | 323 | int ang_weight = rv60_ipred_angle[10 - imode]; | |
670 | 323 | int add_size = (size * ang_weight + 31) >> 5; | |
671 |
1/2✓ Branch 0 taken 323 times.
✗ Branch 1 not taken.
|
323 | if (size <= 16) { |
672 | 323 | filter_weak(filtered1 + 32, &p->l[1], size + add_size); | |
673 | } else { | ||
674 | ✗ | filter_bilin32(filtered1 + 32, p->l[1], p->l[33], 32); | |
675 | ✗ | filter_bilin32(filtered1 + 64, p->l[32], p->l[64], add_size); | |
676 | } | ||
677 | 323 | pred_hor_angle(dst, stride, size, ang_weight, filtered1); | |
678 |
2/2✓ Branch 0 taken 357 times.
✓ Branch 1 taken 1255 times.
|
1612 | } else if (imode == 10) { |
679 |
1/2✓ Branch 0 taken 357 times.
✗ Branch 1 not taken.
|
357 | if (size <= 16) |
680 | 357 | filter_weak(filtered1 + 32, &p->l[1], size); | |
681 | else | ||
682 | ✗ | filter_bilin32(filtered1 + 32, p->l[1], p->l[33], 32); | |
683 |
2/2✓ Branch 0 taken 2232 times.
✓ Branch 1 taken 357 times.
|
2589 | for (int y = 0; y < size; y++) |
684 |
2/2✓ Branch 0 taken 18336 times.
✓ Branch 1 taken 2232 times.
|
20568 | for (int x = 0; x < size; x++) |
685 | 18336 | dst[y*stride + x] = filtered1[32 + y]; | |
686 |
2/2✓ Branch 0 taken 165 times.
✓ Branch 1 taken 192 times.
|
357 | if (filter) { |
687 | 165 | int tl = p->t[0]; | |
688 |
2/2✓ Branch 0 taken 1216 times.
✓ Branch 1 taken 165 times.
|
1381 | for (int x = 0; x < size; x++) |
689 | 1216 | dst[x] = av_clip_uint8(dst[x] + ((p->t[x + 1] - tl) >> 1)); | |
690 | } | ||
691 |
2/2✓ Branch 0 taken 32 times.
✓ Branch 1 taken 1223 times.
|
1255 | } else if (imode <= 17) { |
692 | 32 | int ang_weight = rv60_ipred_angle[imode - 10]; | |
693 | 32 | int inv_angle = rv60_ipred_inv_angle[imode - 10]; | |
694 | 32 | int add_size = (size * ang_weight + 31) >> 5; | |
695 |
1/2✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
|
32 | if (size <= 16) { |
696 | 32 | memcpy(filtered1 + 32 - 1, p->l, size + 1); | |
697 | 32 | memcpy(filtered2 + 32 - 1, p->t, size + 1); | |
698 | } else { | ||
699 | ✗ | filtered1[32 - 1] = p->l[0]; | |
700 | ✗ | filter_bilin32(filtered1 + 32, p->l[0], p->l[32], 32); | |
701 | ✗ | filtered2[32 - 1] = p->t[0]; | |
702 | ✗ | filter_bilin32(filtered2 + 32, p->t[0], p->t[32], 32); | |
703 | } | ||
704 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 22 times.
|
32 | if (add_size > 1) { |
705 | 10 | int sum = 0x80; | |
706 |
2/2✓ Branch 0 taken 18 times.
✓ Branch 1 taken 10 times.
|
28 | for (int i = 1; i < add_size; i++) { |
707 | 18 | sum += inv_angle; | |
708 | 18 | filtered1[32 - 1 - i] = filtered2[32 - 1 + (sum >> 8)]; | |
709 | } | ||
710 | } | ||
711 | 32 | pred_hor_angle(dst, stride, size, -ang_weight, filtered1); | |
712 |
2/2✓ Branch 0 taken 141 times.
✓ Branch 1 taken 1082 times.
|
1223 | } else if (imode <= 25) { |
713 | 141 | int ang_weight = rv60_ipred_angle[26 - imode]; | |
714 | 141 | int inv_angle = rv60_ipred_inv_angle[26 - imode]; | |
715 | 141 | int add_size = (size * ang_weight + 31) >> 5; | |
716 |
1/2✓ Branch 0 taken 141 times.
✗ Branch 1 not taken.
|
141 | if (size <= 16) { |
717 | 141 | memcpy(filtered1 + 32 - 1, p->t, size + 1); | |
718 | 141 | memcpy(filtered2 + 32 - 1, p->l, size + 1); | |
719 | } else { | ||
720 | ✗ | filtered1[32 - 1] = p->t[0]; | |
721 | ✗ | filter_bilin32(filtered1 + 32, p->t[0], p->t[32], 32); | |
722 | ✗ | filtered2[32 - 1] = p->l[0]; | |
723 | ✗ | filter_bilin32(filtered2 + 32, p->l[0], p->l[32], 32); | |
724 | } | ||
725 |
2/2✓ Branch 0 taken 65 times.
✓ Branch 1 taken 76 times.
|
141 | if (add_size > 1) { |
726 | 65 | int sum = 0x80; | |
727 |
2/2✓ Branch 0 taken 242 times.
✓ Branch 1 taken 65 times.
|
307 | for (int i = 1; i < add_size; i++) { |
728 | 242 | sum += inv_angle; | |
729 | 242 | filtered1[32 - 1 - i] = filtered2[32 - 1 + (sum >> 8)]; | |
730 | } | ||
731 | } | ||
732 | 141 | pred_ver_angle(dst, stride, size, -ang_weight, filtered1); | |
733 |
2/2✓ Branch 0 taken 872 times.
✓ Branch 1 taken 210 times.
|
1082 | } else if (imode == 26) { |
734 |
1/2✓ Branch 0 taken 872 times.
✗ Branch 1 not taken.
|
872 | if (size <= 16) |
735 | 872 | filter_weak(&filtered1[32], &p->t[1], size); | |
736 | else | ||
737 | ✗ | filter_bilin32(filtered1 + 32, p->t[1], p->t[33], 32); | |
738 |
2/2✓ Branch 0 taken 5100 times.
✓ Branch 1 taken 872 times.
|
5972 | for (int i = 0; i < size; i++) |
739 | 5100 | memcpy(dst + i*stride, filtered1 + 32, size); | |
740 |
2/2✓ Branch 0 taken 396 times.
✓ Branch 1 taken 476 times.
|
872 | if (filter) { |
741 | 396 | int tl = p->l[0]; | |
742 |
2/2✓ Branch 0 taken 2844 times.
✓ Branch 1 taken 396 times.
|
3240 | for (int y = 0; y < size; y++) |
743 | 2844 | dst[y*stride] = av_clip_uint8(dst[y*stride] + ((p->l[y+1] - tl) >> 1)); | |
744 | } | ||
745 |
1/2✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
|
210 | } else if (imode <= 34) { |
746 | 210 | int ang_weight = rv60_ipred_angle[imode - 26]; | |
747 | 210 | int add_size = (size * ang_weight + 31) >> 5; | |
748 |
1/2✓ Branch 0 taken 210 times.
✗ Branch 1 not taken.
|
210 | if (size <= 16) |
749 | 210 | filter_weak(&filtered1[32], &p->t[1], size + add_size); | |
750 | else { | ||
751 | ✗ | filter_bilin32(filtered1 + 32, p->t[1], p->t[33], 32); | |
752 | ✗ | filter_bilin32(filtered1 + 64, p->t[32], p->t[64], add_size); | |
753 | } | ||
754 | 210 | pred_ver_angle(dst, stride, size, ang_weight, filtered1); | |
755 | } else | ||
756 | ✗ | return AVERROR_INVALIDDATA; | |
757 | 9033 | return 0; | |
758 | } | ||
759 | |||
760 | 12986 | static int pu_is_intra(const PUInfo * pu) | |
761 | { | ||
762 | 12986 | return pu->cu_type == CU_INTRA; | |
763 | } | ||
764 | |||
765 | 1355 | static int ipm_compar(const void * a, const void * b) | |
766 | { | ||
767 | 1355 | return *(const enum IntraMode *)a - *(const enum IntraMode *)b; | |
768 | } | ||
769 | |||
770 | #define MK_UNIQUELIST(name, type, max_size) \ | ||
771 | typedef struct { \ | ||
772 | type list[max_size]; \ | ||
773 | int size; \ | ||
774 | } unique_list_##name; \ | ||
775 | \ | ||
776 | static void unique_list_##name##_init(unique_list_##name * s) \ | ||
777 | { \ | ||
778 | memset(s->list, 0, sizeof(s->list)); \ | ||
779 | s->size = 0; \ | ||
780 | } \ | ||
781 | \ | ||
782 | static void unique_list_##name##_add(unique_list_##name * s, type cand) \ | ||
783 | { \ | ||
784 | if (s->size == max_size) \ | ||
785 | return; \ | ||
786 | \ | ||
787 | for (int i = 0; i < s->size; i++) { \ | ||
788 | if (!memcmp(&s->list[i], &cand, sizeof(type))) { \ | ||
789 | return; \ | ||
790 | } \ | ||
791 | } \ | ||
792 | s->list[s->size++] = cand; \ | ||
793 | } | ||
794 | |||
795 |
6/6✓ Branch 0 taken 16662 times.
✓ Branch 1 taken 20926 times.
✓ Branch 2 taken 7585 times.
✓ Branch 3 taken 14982 times.
✓ Branch 4 taken 22567 times.
✓ Branch 5 taken 13341 times.
|
114034 | MK_UNIQUELIST(intramode, enum IntraMode, 3) |
796 |
6/6✓ Branch 0 taken 58 times.
✓ Branch 1 taken 8788 times.
✓ Branch 2 taken 5422 times.
✓ Branch 3 taken 3400 times.
✓ Branch 4 taken 8822 times.
✓ Branch 5 taken 3366 times.
|
28116 | MK_UNIQUELIST(mvinfo, MVInfo, 4) |
797 | |||
798 | 4447 | static int reconstruct_intra(const RV60Context * s, const CUContext * cu, int size, int sub) | |
799 | { | ||
800 | int blk_pos, tl_x, tl_y; | ||
801 | unique_list_intramode ipm_cand; | ||
802 | |||
803 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4447 times.
|
4447 | if (cu->imode[0] == INTRAMODE_DC64) |
804 | ✗ | return 1; | |
805 | |||
806 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4447 times.
|
4447 | if (cu->imode[0] == INTRAMODE_PLANE64) |
807 | ✗ | return 0; | |
808 | |||
809 | 4447 | unique_list_intramode_init(&ipm_cand); | |
810 | |||
811 |
2/2✓ Branch 1 taken 4324 times.
✓ Branch 2 taken 123 times.
|
4447 | if (has_top_block(s, cu->xpos, cu->ypos, (sub & 1) * 4, 0, size)) { |
812 | 4324 | const PUInfo * pu = &s->pu_info[cu->pu_pos - s->pu_stride]; | |
813 |
2/2✓ Branch 1 taken 3612 times.
✓ Branch 2 taken 712 times.
|
4324 | if (pu_is_intra(pu)) |
814 | 3612 | unique_list_intramode_add(&ipm_cand, s->blk_info[cu->blk_pos - s->blk_stride + (sub & 1)].imode); | |
815 | } | ||
816 | |||
817 | 4447 | blk_pos = cu->blk_pos + (sub >> 1) * s->blk_stride + (sub & 1); | |
818 | |||
819 |
2/2✓ Branch 1 taken 4363 times.
✓ Branch 2 taken 84 times.
|
4447 | if (has_left_block(s, cu->xpos, cu->ypos, 0, (sub & 2) * 2, size)) { |
820 | 4363 | const PUInfo * pu = &s->pu_info[cu->pu_pos - 1]; | |
821 |
2/2✓ Branch 1 taken 3678 times.
✓ Branch 2 taken 685 times.
|
4363 | if (pu_is_intra(pu)) |
822 | 3678 | unique_list_intramode_add(&ipm_cand, s->blk_info[blk_pos - 1 - (sub & 1)].imode); | |
823 | } | ||
824 | |||
825 |
2/2✓ Branch 0 taken 3011 times.
✓ Branch 1 taken 1436 times.
|
4447 | tl_x = !(sub & 2) ? (cu->xpos + (sub & 1) * 4) : cu->xpos; |
826 | 4447 | tl_y = cu->ypos + (sub & 2) * 4; | |
827 |
4/4✓ Branch 0 taken 4374 times.
✓ Branch 1 taken 73 times.
✓ Branch 2 taken 4299 times.
✓ Branch 3 taken 75 times.
|
4447 | if (tl_x > 0 && tl_y > 0) { |
828 | const PUInfo * pu; | ||
829 |
3/3✓ Branch 0 taken 2190 times.
✓ Branch 1 taken 695 times.
✓ Branch 2 taken 1414 times.
|
4299 | switch (sub) { |
830 | 2190 | case 0: pu = &s->pu_info[cu->pu_pos - s->pu_stride - 1]; break; | |
831 | 695 | case 1: pu = &s->pu_info[cu->pu_pos - s->pu_stride]; break; | |
832 | 1414 | default: pu = &s->pu_info[cu->pu_pos - 1]; | |
833 | } | ||
834 |
2/2✓ Branch 1 taken 3616 times.
✓ Branch 2 taken 683 times.
|
4299 | if (pu_is_intra(pu)) { |
835 |
2/2✓ Branch 0 taken 3046 times.
✓ Branch 1 taken 570 times.
|
3616 | if (sub != 3) |
836 | 3046 | unique_list_intramode_add(&ipm_cand, s->blk_info[blk_pos - s->blk_stride - 1].imode); | |
837 | else | ||
838 | 570 | unique_list_intramode_add(&ipm_cand, s->blk_info[blk_pos - s->blk_stride - 2].imode); | |
839 | } | ||
840 | } | ||
841 | |||
842 |
2/2✓ Branch 0 taken 26682 times.
✓ Branch 1 taken 4447 times.
|
31129 | for (int i = 0; i < FF_ARRAY_ELEMS(rv60_candidate_intra_angles); i++) |
843 | 26682 | unique_list_intramode_add(&ipm_cand, rv60_candidate_intra_angles[i]); | |
844 | |||
845 |
2/2✓ Branch 0 taken 3922 times.
✓ Branch 1 taken 525 times.
|
4447 | if (cu->imode[sub] == INTRAMODE_INDEX) |
846 | 3922 | return ipm_cand.list[cu->imode_param[sub]]; | |
847 | |||
848 |
1/2✓ Branch 0 taken 525 times.
✗ Branch 1 not taken.
|
525 | if (cu->imode[sub] == INTRAMODE_MODE) { |
849 | 525 | enum IntraMode imode = cu->imode_param[sub]; | |
850 | 525 | qsort(ipm_cand.list, 3, sizeof(ipm_cand.list[0]), ipm_compar); | |
851 |
2/2✓ Branch 0 taken 1575 times.
✓ Branch 1 taken 525 times.
|
2100 | for (int i = 0; i < 3; i++) |
852 |
2/2✓ Branch 0 taken 1175 times.
✓ Branch 1 taken 400 times.
|
1575 | if (imode >= ipm_cand.list[i]) |
853 | 1175 | imode++; | |
854 | 525 | return imode; | |
855 | } | ||
856 | |||
857 | ✗ | av_assert0(0); // should never reach here | |
858 | return 0; | ||
859 | } | ||
860 | |||
861 | 1812 | static int get_skip_mv_index(enum MVRefEnum mvref) | |
862 | { | ||
863 |
4/4✓ Branch 0 taken 287 times.
✓ Branch 1 taken 61 times.
✓ Branch 2 taken 15 times.
✓ Branch 3 taken 1449 times.
|
1812 | switch (mvref) { |
864 | 287 | case MVREF_SKIP1: return 1; | |
865 | 61 | case MVREF_SKIP2: return 2; | |
866 | 15 | case MVREF_SKIP3: return 3; | |
867 | 1449 | default: return 0; | |
868 | } | ||
869 | } | ||
870 | |||
871 | 10767 | static void add_if_valid(unique_list_mvinfo * skip_cand, const MVInfo * mvi) | |
872 | { | ||
873 |
2/2✓ Branch 0 taken 8846 times.
✓ Branch 1 taken 1921 times.
|
10767 | if (mvi->mvref != MVREF_NONE) |
874 | 8846 | unique_list_mvinfo_add(skip_cand, *mvi); | |
875 | 10767 | } | |
876 | |||
877 | 1812 | static void fill_mv_skip_cand(RV60Context * s, const CUContext * cu, unique_list_mvinfo * skip_cand, int size) | |
878 | { | ||
879 | 1812 | int mv_size = size >> 2; | |
880 | |||
881 |
2/2✓ Branch 0 taken 1649 times.
✓ Branch 1 taken 163 times.
|
1812 | if (cu->xpos) |
882 | 1649 | add_if_valid(skip_cand, &s->blk_info[cu->blk_pos - 1].mv); | |
883 |
2/2✓ Branch 0 taken 1562 times.
✓ Branch 1 taken 250 times.
|
1812 | if (cu->ypos) |
884 | 1562 | add_if_valid(skip_cand, &s->blk_info[cu->blk_pos - s->blk_stride].mv); | |
885 |
4/4✓ Branch 0 taken 1562 times.
✓ Branch 1 taken 250 times.
✓ Branch 2 taken 1418 times.
✓ Branch 3 taken 144 times.
|
1812 | if (cu->ypos && cu->xpos + size < s->awidth) |
886 | 1418 | add_if_valid(skip_cand, &s->blk_info[cu->blk_pos - s->blk_stride + mv_size].mv); | |
887 |
4/4✓ Branch 0 taken 1649 times.
✓ Branch 1 taken 163 times.
✓ Branch 2 taken 1503 times.
✓ Branch 3 taken 146 times.
|
1812 | if (cu->xpos && cu->ypos + size < s->aheight) |
888 | 1503 | add_if_valid(skip_cand, &s->blk_info[cu->blk_pos + s->blk_stride * mv_size - 1].mv); | |
889 |
2/2✓ Branch 0 taken 1649 times.
✓ Branch 1 taken 163 times.
|
1812 | if (cu->xpos) |
890 | 1649 | add_if_valid(skip_cand, &s->blk_info[cu->blk_pos + s->blk_stride * (mv_size - 1) - 1].mv); | |
891 |
2/2✓ Branch 0 taken 1562 times.
✓ Branch 1 taken 250 times.
|
1812 | if (cu->ypos) |
892 | 1562 | add_if_valid(skip_cand, &s->blk_info[cu->blk_pos - s->blk_stride + mv_size - 1].mv); | |
893 |
4/4✓ Branch 0 taken 1649 times.
✓ Branch 1 taken 163 times.
✓ Branch 2 taken 1424 times.
✓ Branch 3 taken 225 times.
|
1812 | if (cu->xpos && cu->ypos) |
894 | 1424 | add_if_valid(skip_cand, &s->blk_info[cu->blk_pos - s->blk_stride - 1].mv); | |
895 | |||
896 |
2/2✓ Branch 0 taken 3882 times.
✓ Branch 1 taken 1812 times.
|
5694 | for (int i = skip_cand->size; i < 4; i++) |
897 | 3882 | skip_cand->list[i] = (MVInfo){.mvref=MVREF_REF0,.f_mv={0,0},.b_mv={0,0}}; | |
898 | 1812 | } | |
899 | |||
900 | typedef struct { | ||
901 | int w, h; | ||
902 | } Dimensions; | ||
903 | |||
904 | 5808 | static void get_mv_dimensions(Dimensions * dim, enum PUType pu_type, int part_no, int size) | |
905 | { | ||
906 | 5808 | int mv_size = size >> 2; | |
907 |
4/9✓ Branch 0 taken 2920 times.
✓ Branch 1 taken 380 times.
✓ Branch 2 taken 356 times.
✓ Branch 3 taken 2152 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
|
5808 | switch (pu_type) { |
908 | 2920 | case PU_FULL: | |
909 | 2920 | dim->w = dim->h = mv_size; | |
910 | 2920 | break; | |
911 | 380 | case PU_N2HOR: | |
912 | 380 | dim->w = mv_size; | |
913 | 380 | dim->h = mv_size >> 1; | |
914 | 380 | break; | |
915 | 356 | case PU_N2VER: | |
916 | 356 | dim->w = mv_size >> 1; | |
917 | 356 | dim->h = mv_size; | |
918 | 356 | break; | |
919 | 2152 | case PU_QUARTERS: | |
920 | 2152 | dim->w = dim->h = mv_size >> 1; | |
921 | 2152 | break; | |
922 | ✗ | case PU_N4HOR: | |
923 | ✗ | dim->w = mv_size; | |
924 | ✗ | dim->h = !part_no ? (mv_size >> 2) : ((3 * mv_size) >> 2); | |
925 | ✗ | break; | |
926 | ✗ | case PU_N34HOR: | |
927 | ✗ | dim->w = mv_size; | |
928 | ✗ | dim->h = !part_no ? ((3 * mv_size) >> 2) : (mv_size >> 2); | |
929 | ✗ | break; | |
930 | ✗ | case PU_N4VER: | |
931 | ✗ | dim->w = !part_no ? (mv_size >> 2) : ((3 * mv_size) >> 2); | |
932 | ✗ | dim->h = mv_size; | |
933 | ✗ | break; | |
934 | ✗ | case PU_N34VER: | |
935 | ✗ | dim->w = !part_no ? ((3 * mv_size) >> 2) : (mv_size >> 2); | |
936 | ✗ | dim->h = mv_size; | |
937 | ✗ | break; | |
938 | } | ||
939 | 5808 | } | |
940 | |||
941 | 3656 | static int has_hor_split(enum PUType pu_type) | |
942 | { | ||
943 |
5/8✓ Branch 0 taken 3276 times.
✓ Branch 1 taken 380 times.
✓ Branch 2 taken 3276 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3276 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 3276 times.
|
3656 | return pu_type == PU_N2HOR || pu_type == PU_N4HOR || pu_type == PU_N34HOR || pu_type == PU_QUARTERS; |
944 | } | ||
945 | |||
946 | 3276 | static int has_ver_split(enum PUType pu_type) | |
947 | { | ||
948 |
5/8✓ Branch 0 taken 2920 times.
✓ Branch 1 taken 356 times.
✓ Branch 2 taken 2920 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 2920 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 2920 times.
|
3276 | return pu_type == PU_N2VER || pu_type == PU_N4VER || pu_type == PU_N34VER || pu_type == PU_QUARTERS; |
949 | } | ||
950 | |||
951 | 4833 | static int pu_type_num_parts(enum PUType pu_type) | |
952 | { | ||
953 |
3/3✓ Branch 0 taken 3474 times.
✓ Branch 1 taken 807 times.
✓ Branch 2 taken 552 times.
|
4833 | switch (pu_type) { |
954 | 3474 | case PU_FULL: return 1; | |
955 | 807 | case PU_QUARTERS: return 4; | |
956 | 552 | default: return 2; | |
957 | } | ||
958 | } | ||
959 | |||
960 | 5808 | static void get_next_mv(const RV60Context * s, const Dimensions * dim, enum PUType pu_type, int part_no, int * mv_pos, int * mv_x, int * mv_y) | |
961 | { | ||
962 |
2/2✓ Branch 0 taken 2152 times.
✓ Branch 1 taken 3656 times.
|
5808 | if (pu_type == PU_QUARTERS) { |
963 |
2/2✓ Branch 0 taken 1614 times.
✓ Branch 1 taken 538 times.
|
2152 | if (part_no != 1) { |
964 | 1614 | *mv_pos += dim->w; | |
965 | 1614 | *mv_x += dim->w; | |
966 | } else { | ||
967 | 538 | *mv_pos += dim->h*s->blk_stride - dim->w; | |
968 | 538 | *mv_x -= dim->w; | |
969 | 538 | *mv_y += dim->h; | |
970 | } | ||
971 |
2/2✓ Branch 1 taken 380 times.
✓ Branch 2 taken 3276 times.
|
3656 | } else if (has_hor_split(pu_type)) { |
972 | 380 | *mv_pos += dim->h * s->blk_stride; | |
973 | 380 | *mv_y += dim->h; | |
974 |
2/2✓ Branch 1 taken 356 times.
✓ Branch 2 taken 2920 times.
|
3276 | } else if (has_ver_split(pu_type)) { |
975 | 356 | *mv_pos += dim->w; | |
976 | 356 | *mv_x += dim->w; | |
977 | } | ||
978 | 5808 | } | |
979 | |||
980 | 2915 | static int mv_is_ref0(enum MVRefEnum mvref) | |
981 | { | ||
982 |
4/4✓ Branch 0 taken 2314 times.
✓ Branch 1 taken 601 times.
✓ Branch 2 taken 309 times.
✓ Branch 3 taken 2005 times.
|
2915 | return mvref == MVREF_REF0 || mvref == MVREF_REF0ANDBREF; |
983 | } | ||
984 | |||
985 | 24675 | static int mv_is_forward(enum MVRefEnum mvref) | |
986 | { | ||
987 |
6/6✓ Branch 0 taken 5209 times.
✓ Branch 1 taken 19466 times.
✓ Branch 2 taken 4975 times.
✓ Branch 3 taken 234 times.
✓ Branch 4 taken 1207 times.
✓ Branch 5 taken 3768 times.
|
24675 | return mvref == MVREF_REF0 || mvref == MVREF_REF1 || mvref == MVREF_REF0ANDBREF; |
988 | } | ||
989 | |||
990 | 27282 | static int mv_is_backward(enum MVRefEnum mvref) | |
991 | { | ||
992 |
4/4✓ Branch 0 taken 22417 times.
✓ Branch 1 taken 4865 times.
✓ Branch 2 taken 1686 times.
✓ Branch 3 taken 20731 times.
|
27282 | return mvref == MVREF_BREF || mvref == MVREF_REF0ANDBREF; |
993 | } | ||
994 | |||
995 | 4408 | static int mvinfo_matches_forward(const MVInfo * a, const MVInfo * b) | |
996 | { | ||
997 |
6/6✓ Branch 0 taken 2314 times.
✓ Branch 1 taken 2094 times.
✓ Branch 3 taken 601 times.
✓ Branch 4 taken 1713 times.
✓ Branch 6 taken 309 times.
✓ Branch 7 taken 292 times.
|
4408 | return a->mvref == b->mvref || (mv_is_ref0(a->mvref) && mv_is_ref0(b->mvref)); |
998 | } | ||
999 | |||
1000 | 1819 | static int mvinfo_matches_backward(const MVInfo * a, const MVInfo * b) | |
1001 | { | ||
1002 |
3/4✓ Branch 1 taken 788 times.
✓ Branch 2 taken 1031 times.
✓ Branch 4 taken 788 times.
✗ Branch 5 not taken.
|
1819 | return mv_is_backward(a->mvref) && mv_is_backward(b->mvref); |
1003 | } | ||
1004 | |||
1005 | 24452 | static int mvinfo_is_deblock_cand(const MVInfo * a, const MVInfo * b) | |
1006 | { | ||
1007 | int diff; | ||
1008 | |||
1009 |
2/2✓ Branch 0 taken 1775 times.
✓ Branch 1 taken 22677 times.
|
24452 | if (a->mvref != b->mvref) |
1010 | 1775 | return 1; | |
1011 | |||
1012 | 22677 | diff = 0; | |
1013 |
2/2✓ Branch 1 taken 19370 times.
✓ Branch 2 taken 3307 times.
|
22677 | if (mv_is_forward(a->mvref)) { |
1014 | 19370 | int dx = a->f_mv.x - b->f_mv.x; | |
1015 | 19370 | int dy = a->f_mv.y - b->f_mv.y; | |
1016 | 19370 | diff += FFABS(dx) + FFABS(dy); | |
1017 | } | ||
1018 |
2/2✓ Branch 1 taken 4331 times.
✓ Branch 2 taken 18346 times.
|
22677 | if (mv_is_backward(a->mvref)) { |
1019 | 4331 | int dx = a->b_mv.x - b->b_mv.x; | |
1020 | 4331 | int dy = a->b_mv.y - b->b_mv.y; | |
1021 | 4331 | diff += FFABS(dx) + FFABS(dy); | |
1022 | } | ||
1023 | 22677 | return diff > 4; | |
1024 | } | ||
1025 | |||
1026 | 367 | static void mv_pred(MV * ret, MV a, MV b, MV c) | |
1027 | { | ||
1028 | #define MEDIAN(x) \ | ||
1029 | if (a.x < b.x) \ | ||
1030 | if (b.x < c.x) \ | ||
1031 | ret->x = b.x; \ | ||
1032 | else \ | ||
1033 | ret->x = a.x < c.x ? c.x : a.x; \ | ||
1034 | else \ | ||
1035 | if (b.x < c.x) \ | ||
1036 | ret->x = a.x < c.x ? a.x : c.x; \ | ||
1037 | else \ | ||
1038 | ret->x = b.x; \ | ||
1039 | |||
1040 |
6/6✓ Branch 0 taken 43 times.
✓ Branch 1 taken 324 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 42 times.
✓ Branch 4 taken 21 times.
✓ Branch 5 taken 303 times.
|
367 | MEDIAN(x) |
1041 |
6/6✓ Branch 0 taken 52 times.
✓ Branch 1 taken 315 times.
✓ Branch 2 taken 3 times.
✓ Branch 3 taken 49 times.
✓ Branch 4 taken 22 times.
✓ Branch 5 taken 293 times.
|
367 | MEDIAN(y) |
1042 | 367 | } | |
1043 | |||
1044 | 1998 | static void predict_mv(const RV60Context * s, MVInfo * dst, int mv_x, int mv_y, int mv_w, const MVInfo * src) | |
1045 | { | ||
1046 | 1998 | int mv_pos = mv_y * s->blk_stride + mv_x; | |
1047 | MV f_mv, b_mv; | ||
1048 | |||
1049 | 1998 | dst->mvref = src->mvref; | |
1050 | |||
1051 |
2/2✓ Branch 1 taken 1537 times.
✓ Branch 2 taken 461 times.
|
1998 | if (mv_is_forward(src->mvref)) { |
1052 | 1537 | MV cand[3] = {0}; | |
1053 | 1537 | int cand_size = 0; | |
1054 |
2/2✓ Branch 0 taken 1426 times.
✓ Branch 1 taken 111 times.
|
1537 | if (mv_x > 0) { |
1055 | 1426 | const MVInfo * mv = &s->blk_info[mv_pos - 1].mv; | |
1056 |
2/2✓ Branch 1 taken 906 times.
✓ Branch 2 taken 520 times.
|
1426 | if (mvinfo_matches_forward(mv, src)) |
1057 | 906 | cand[cand_size++] = mv->f_mv; | |
1058 | } | ||
1059 |
2/2✓ Branch 0 taken 1515 times.
✓ Branch 1 taken 22 times.
|
1537 | if (mv_y > 0) { |
1060 | 1515 | const MVInfo * mv = &s->blk_info[mv_pos - s->blk_stride].mv; | |
1061 |
2/2✓ Branch 1 taken 936 times.
✓ Branch 2 taken 579 times.
|
1515 | if (mvinfo_matches_forward(mv, src)) |
1062 | 936 | cand[cand_size++] = mv->f_mv; | |
1063 | } | ||
1064 |
2/2✓ Branch 1 taken 1467 times.
✓ Branch 2 taken 70 times.
|
1537 | if (has_top_block(s, mv_x << 2, mv_y << 2, mv_w << 2, 0, 4)) { |
1065 | 1467 | const MVInfo * mv = &s->blk_info[mv_pos - s->blk_stride + mv_w].mv; | |
1066 |
2/2✓ Branch 1 taken 561 times.
✓ Branch 2 taken 906 times.
|
1467 | if (mvinfo_matches_forward(mv, src)) |
1067 | 561 | cand[cand_size++] = mv->f_mv; | |
1068 | } | ||
1069 | |||
1070 |
4/4✓ Branch 0 taken 481 times.
✓ Branch 1 taken 523 times.
✓ Branch 2 taken 292 times.
✓ Branch 3 taken 241 times.
|
1537 | switch (cand_size) { |
1071 | 481 | case 1: | |
1072 | 481 | f_mv.x = cand[0].x; | |
1073 | 481 | f_mv.y = cand[0].y; | |
1074 | 481 | break; | |
1075 | 523 | case 2: | |
1076 | 523 | f_mv.x = (cand[0].x + cand[1].x) >> 1; | |
1077 | 523 | f_mv.y = (cand[0].y + cand[1].y) >> 1; | |
1078 | 523 | break; | |
1079 | 292 | case 3: | |
1080 | 292 | mv_pred(&f_mv, cand[0], cand[1], cand[2]); | |
1081 | 292 | break; | |
1082 | 241 | default: | |
1083 | 241 | f_mv = (MV){0,0}; | |
1084 | 241 | break; | |
1085 | } | ||
1086 | } else { | ||
1087 | 461 | f_mv = (MV){0,0}; | |
1088 | } | ||
1089 | |||
1090 | 1998 | dst->f_mv.x = src->f_mv.x + f_mv.x; | |
1091 | 1998 | dst->f_mv.y = src->f_mv.y + f_mv.y; | |
1092 | |||
1093 |
2/2✓ Branch 1 taken 644 times.
✓ Branch 2 taken 1354 times.
|
1998 | if (mv_is_backward(src->mvref)) { |
1094 | 644 | MV cand[3] = {0}; | |
1095 | 644 | int cand_size = 0; | |
1096 |
2/2✓ Branch 0 taken 587 times.
✓ Branch 1 taken 57 times.
|
644 | if (mv_x > 0) { |
1097 | 587 | const MVInfo * mv = &s->blk_info[mv_pos - 1].mv; | |
1098 |
2/2✓ Branch 1 taken 296 times.
✓ Branch 2 taken 291 times.
|
587 | if (mvinfo_matches_backward(mv, src)) |
1099 | 296 | cand[cand_size++] = mv->b_mv; | |
1100 | } | ||
1101 |
2/2✓ Branch 0 taken 628 times.
✓ Branch 1 taken 16 times.
|
644 | if (mv_y > 0) { |
1102 | 628 | const MVInfo * mv = &s->blk_info[mv_pos - s->blk_stride].mv; | |
1103 |
2/2✓ Branch 1 taken 297 times.
✓ Branch 2 taken 331 times.
|
628 | if (mvinfo_matches_backward(mv, src)) |
1104 | 297 | cand[cand_size++] = mv->b_mv; | |
1105 | } | ||
1106 |
2/2✓ Branch 1 taken 604 times.
✓ Branch 2 taken 40 times.
|
644 | if (has_top_block(s, mv_x << 2, mv_y << 2, mv_w << 2, 0, 4)) { |
1107 | 604 | const MVInfo * mv = &s->blk_info[mv_pos - s->blk_stride + mv_w].mv; | |
1108 |
2/2✓ Branch 1 taken 195 times.
✓ Branch 2 taken 409 times.
|
604 | if (mvinfo_matches_backward(mv, src)) |
1109 | 195 | cand[cand_size++] = mv->b_mv; | |
1110 | } | ||
1111 | |||
1112 |
4/4✓ Branch 0 taken 219 times.
✓ Branch 1 taken 172 times.
✓ Branch 2 taken 75 times.
✓ Branch 3 taken 178 times.
|
644 | switch (cand_size) { |
1113 | 219 | case 1: | |
1114 | 219 | b_mv.x = cand[0].x; | |
1115 | 219 | b_mv.y = cand[0].y; | |
1116 | 219 | break; | |
1117 | 172 | case 2: | |
1118 | 172 | b_mv.x = (cand[0].x + cand[1].x) >> 1; | |
1119 | 172 | b_mv.y = (cand[0].y + cand[1].y) >> 1; | |
1120 | 172 | break; | |
1121 | 75 | case 3: | |
1122 | 75 | mv_pred(&b_mv, cand[0], cand[1], cand[2]); | |
1123 | 75 | break; | |
1124 | 178 | default: | |
1125 | 178 | b_mv = (MV){0,0}; | |
1126 | 178 | break; | |
1127 | } | ||
1128 | } else { | ||
1129 | 1354 | b_mv = (MV){0,0}; | |
1130 | } | ||
1131 | |||
1132 | 1998 | dst->b_mv.x = src->b_mv.x + b_mv.x; | |
1133 | 1998 | dst->b_mv.y = src->b_mv.y + b_mv.y; | |
1134 | 1998 | } | |
1135 | |||
1136 | 5112 | static void reconstruct(RV60Context * s, const CUContext * cu, int size) | |
1137 | { | ||
1138 | 5112 | int pu_size = size >> 3; | |
1139 | PUInfo pui; | ||
1140 | int imode, mv_x, mv_y, mv_pos, count, mv_size; | ||
1141 | unique_list_mvinfo skip_cand; | ||
1142 | Dimensions dim; | ||
1143 | MVInfo mv; | ||
1144 | |||
1145 | 5112 | pui.cu_type = cu->cu_type; | |
1146 | 5112 | pui.pu_type = cu->pu_type; | |
1147 | |||
1148 |
4/4✓ Branch 0 taken 2293 times.
✓ Branch 1 taken 2819 times.
✓ Branch 2 taken 718 times.
✓ Branch 3 taken 1575 times.
|
5112 | if (cu->cu_type == CU_INTRA && cu->pu_type == PU_QUARTERS) { |
1149 | 718 | s->pu_info[cu->pu_pos] = pui; | |
1150 |
2/2✓ Branch 0 taken 1436 times.
✓ Branch 1 taken 718 times.
|
2154 | for (int y = 0; y < 2; y++) |
1151 |
2/2✓ Branch 0 taken 2872 times.
✓ Branch 1 taken 1436 times.
|
4308 | for (int x = 0; x < 2; x++) |
1152 | 2872 | s->blk_info[cu->blk_pos + y*s->blk_stride + x].imode = | |
1153 | 2872 | reconstruct_intra(s, cu, 4, y*2 + x); | |
1154 | 718 | return; | |
1155 | } | ||
1156 | |||
1157 |
3/3✓ Branch 0 taken 1575 times.
✓ Branch 1 taken 1007 times.
✓ Branch 2 taken 1812 times.
|
4394 | switch (cu->cu_type) { |
1158 | 1575 | case CU_INTRA: | |
1159 | 1575 | imode = reconstruct_intra(s, cu, size, 0); | |
1160 |
2/2✓ Branch 0 taken 4776 times.
✓ Branch 1 taken 1575 times.
|
6351 | for (int y = 0; y < size >> 2; y++) |
1161 |
2/2✓ Branch 0 taken 16056 times.
✓ Branch 1 taken 4776 times.
|
20832 | for (int x = 0; x < size >> 2; x++) |
1162 | 16056 | s->blk_info[cu->blk_pos + y*s->blk_stride + x].imode = imode; | |
1163 | 1575 | break; | |
1164 | 1007 | case CU_INTER_MV: | |
1165 | 1007 | mv_x = cu->xpos >> 2; | |
1166 | 1007 | mv_y = cu->ypos >> 2; | |
1167 | 1007 | mv_pos = cu->blk_pos; | |
1168 | 1007 | count = pu_type_num_parts(cu->pu_type); | |
1169 |
2/2✓ Branch 0 taken 1998 times.
✓ Branch 1 taken 1007 times.
|
3005 | for (int part_no = 0; part_no < count; part_no++) { |
1170 | MVInfo mv; | ||
1171 | 1998 | get_mv_dimensions(&dim, cu->pu_type, part_no, size); | |
1172 | 1998 | predict_mv(s, &mv, mv_x, mv_y, dim.w, &cu->mv[part_no]); | |
1173 |
2/2✓ Branch 0 taken 3456 times.
✓ Branch 1 taken 1998 times.
|
5454 | for (int y = 0; y < dim.h; y++) |
1174 |
2/2✓ Branch 0 taken 6908 times.
✓ Branch 1 taken 3456 times.
|
10364 | for (int x = 0; x < dim.w; x++) |
1175 | 6908 | s->blk_info[mv_pos + y*s->blk_stride + x].mv = mv; | |
1176 | 1998 | get_next_mv(s, &dim, cu->pu_type, part_no, &mv_pos, &mv_x, &mv_y); | |
1177 | } | ||
1178 | 1007 | break; | |
1179 | 1812 | default: | |
1180 | 1812 | unique_list_mvinfo_init(&skip_cand); | |
1181 | 1812 | fill_mv_skip_cand(s, cu, &skip_cand, size); | |
1182 | 1812 | mv = skip_cand.list[get_skip_mv_index(cu->mv[0].mvref)]; | |
1183 | 1812 | mv_size = size >> 2; | |
1184 |
2/2✓ Branch 0 taken 7506 times.
✓ Branch 1 taken 1812 times.
|
9318 | for (int y = 0; y < mv_size; y++) |
1185 |
2/2✓ Branch 0 taken 53700 times.
✓ Branch 1 taken 7506 times.
|
61206 | for (int x = 0; x < mv_size; x++) |
1186 | 53700 | s->blk_info[cu->blk_pos + y*s->blk_stride + x].mv = mv; | |
1187 | } | ||
1188 | |||
1189 |
2/2✓ Branch 0 taken 7372 times.
✓ Branch 1 taken 4394 times.
|
11766 | for (int y = 0; y < pu_size; y++) |
1190 |
2/2✓ Branch 0 taken 19166 times.
✓ Branch 1 taken 7372 times.
|
26538 | for (int x = 0; x < pu_size; x++) |
1191 | 19166 | s->pu_info[cu->pu_pos + y*s->pu_stride + x] = pui; | |
1192 | } | ||
1193 | |||
1194 | 2181 | static void read_mv(GetBitContext * gb, MV * mv) | |
1195 | { | ||
1196 | 2181 | mv->x = get_interleaved_se_golomb(gb); | |
1197 | 2181 | mv->y = get_interleaved_se_golomb(gb); | |
1198 | 2181 | } | |
1199 | |||
1200 | 1998 | static void read_mv_info(RV60Context *s, GetBitContext * gb, MVInfo * mvinfo, int size, enum PUType pu_type) | |
1201 | { | ||
1202 |
2/2✓ Branch 0 taken 866 times.
✓ Branch 1 taken 1132 times.
|
1998 | if (s->pict_type != AV_PICTURE_TYPE_B) { |
1203 |
3/4✓ Branch 0 taken 866 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 192 times.
✓ Branch 4 taken 674 times.
|
866 | if (s->two_f_refs && get_bits1(gb)) |
1204 | 192 | mvinfo->mvref = MVREF_REF1; | |
1205 | else | ||
1206 | 674 | mvinfo->mvref = MVREF_REF0; | |
1207 | 866 | read_mv(gb, &mvinfo->f_mv); | |
1208 | 866 | mvinfo->b_mv.x = mvinfo->b_mv.y = 0; | |
1209 | } else { | ||
1210 |
7/8✓ Branch 0 taken 817 times.
✓ Branch 1 taken 315 times.
✓ Branch 2 taken 817 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 291 times.
✓ Branch 5 taken 526 times.
✓ Branch 7 taken 423 times.
✓ Branch 8 taken 183 times.
|
1132 | if ((size <= 8 && (size != 8 || pu_type != PU_FULL)) || get_bits1(gb)) { |
1211 |
2/2✓ Branch 1 taken 488 times.
✓ Branch 2 taken 461 times.
|
1898 | if (!get_bits1(gb)) { |
1212 | 488 | mvinfo->mvref = MVREF_REF0; | |
1213 | 488 | read_mv(gb, &mvinfo->f_mv); | |
1214 | 488 | mvinfo->b_mv.x = mvinfo->b_mv.y = 0; | |
1215 | } else { | ||
1216 | 461 | mvinfo->mvref = MVREF_BREF; | |
1217 | 461 | mvinfo->f_mv.x = mvinfo->f_mv.y = 0; | |
1218 | 461 | read_mv(gb, &mvinfo->b_mv); | |
1219 | } | ||
1220 | } else { | ||
1221 | 183 | mvinfo->mvref = MVREF_REF0ANDBREF; | |
1222 | 183 | read_mv(gb, &mvinfo->f_mv); | |
1223 | 183 | read_mv(gb, &mvinfo->b_mv); | |
1224 | } | ||
1225 | } | ||
1226 | 1998 | } | |
1227 | |||
1228 | #define FILTER1(src, src_stride, src_y_ofs, step) \ | ||
1229 | ( (src)[(y + src_y_ofs)*(src_stride) + x - 2*step] \ | ||
1230 | - 5 * (src)[(y + src_y_ofs)*(src_stride) + x - 1*step] \ | ||
1231 | +52 * (src)[(y + src_y_ofs)*(src_stride) + x ] \ | ||
1232 | +20 * (src)[(y + src_y_ofs)*(src_stride) + x + 1*step] \ | ||
1233 | - 5 * (src)[(y + src_y_ofs)*(src_stride) + x + 2*step] \ | ||
1234 | + (src)[(y + src_y_ofs)*(src_stride) + x + 3*step] + 32) >> 6 | ||
1235 | |||
1236 | #define FILTER2(src, src_stride, src_y_ofs, step) \ | ||
1237 | ( (src)[(y + src_y_ofs)*(src_stride) + x - 2*step] \ | ||
1238 | - 5 * (src)[(y + src_y_ofs)*(src_stride) + x - 1*step] \ | ||
1239 | +20 * (src)[(y + src_y_ofs)*(src_stride) + x ] \ | ||
1240 | +20 * (src)[(y + src_y_ofs)*(src_stride) + x + 1*step] \ | ||
1241 | - 5 * (src)[(y + src_y_ofs)*(src_stride) + x + 2*step] \ | ||
1242 | + (src)[(y + src_y_ofs)*(src_stride) + x + 3*step] + 16) >> 5 | ||
1243 | |||
1244 | #define FILTER3(src, src_stride, src_y_ofs, step) \ | ||
1245 | ( (src)[(y + src_y_ofs)*(src_stride) + x - 2*step] \ | ||
1246 | - 5 * (src)[(y + src_y_ofs)*(src_stride) + x - 1*step] \ | ||
1247 | +20 * (src)[(y + src_y_ofs)*(src_stride) + x ] \ | ||
1248 | +52 * (src)[(y + src_y_ofs)*(src_stride) + x + 1*step] \ | ||
1249 | - 5 * (src)[(y + src_y_ofs)*(src_stride) + x + 2*step] \ | ||
1250 | + (src)[(y + src_y_ofs)*(src_stride) + x + 3*step] + 32) >> 6 | ||
1251 | |||
1252 | #define FILTER_CASE(idx, dst, dst_stride, filter, w, h) \ | ||
1253 | case idx: \ | ||
1254 | for (int y = 0; y < h; y++) \ | ||
1255 | for (int x = 0; x < w; x++) \ | ||
1256 | (dst)[y*dst_stride + x] = av_clip_uint8(filter); \ | ||
1257 | break; | ||
1258 | |||
1259 | #define FILTER_BLOCK(dst, dst_stride, src, src_stride, src_y_ofs, w, h, cond, step) \ | ||
1260 | switch (cond) { \ | ||
1261 | FILTER_CASE(1, dst, dst_stride, FILTER1(src, src_stride, src_y_ofs, step), w, h) \ | ||
1262 | FILTER_CASE(2, dst, dst_stride, FILTER2(src, src_stride, src_y_ofs, step), w, h) \ | ||
1263 | FILTER_CASE(3, dst, dst_stride, FILTER3(src, src_stride, src_y_ofs, step), w, h) \ | ||
1264 | } | ||
1265 | |||
1266 | 4117 | static void luma_mc(uint8_t * dst, int dst_stride, const uint8_t * src, int src_stride, int w, int h, int cx, int cy) | |
1267 | { | ||
1268 |
2/4✓ Branch 0 taken 4117 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 4117 times.
✗ Branch 3 not taken.
|
4117 | if (!cx && !cy) { |
1269 |
2/2✓ Branch 0 taken 47344 times.
✓ Branch 1 taken 4117 times.
|
51461 | for (int y = 0; y < h; y++) |
1270 | 47344 | memcpy(dst + y*dst_stride, src + y*src_stride, w); | |
1271 | ✗ | } else if (!cy) { | |
1272 | ✗ | FILTER_BLOCK(dst, dst_stride, src, src_stride, 0, w, h, cx, 1) | |
1273 | ✗ | } else if (!cx) { | |
1274 | ✗ | FILTER_BLOCK(dst, dst_stride, src, src_stride, 0, w, h, cy, src_stride) | |
1275 | ✗ | } else if (cx != 3 || cy != 3) { | |
1276 | uint8_t tmp[70 * 64]; | ||
1277 | ✗ | FILTER_BLOCK(tmp, 64, src - src_stride * 2, src_stride, 0, w, h + 5, cx, 1) | |
1278 | ✗ | FILTER_BLOCK(dst, dst_stride, tmp + 2*64, 64, 0, w, h, cy, 64) | |
1279 | } else { | ||
1280 | ✗ | for (int j = 0; j < h; j++) | |
1281 | ✗ | for (int i = 0; i < w; i++) | |
1282 | ✗ | dst[j*dst_stride + i] = ( | |
1283 | ✗ | src[j*src_stride + i] + | |
1284 | ✗ | src[j*src_stride + i + 1] + | |
1285 | ✗ | src[(j + 1)*src_stride + i] + | |
1286 | ✗ | src[(j + 1)*src_stride + i + 1] + 2) >> 2; | |
1287 | } | ||
1288 | 4117 | } | |
1289 | |||
1290 | 8234 | static void chroma_mc(uint8_t * dst, int dst_stride, const uint8_t * src, int src_stride, int w, int h, int x, int y) | |
1291 | { | ||
1292 |
4/4✓ Branch 0 taken 7822 times.
✓ Branch 1 taken 412 times.
✓ Branch 2 taken 7440 times.
✓ Branch 3 taken 382 times.
|
8234 | if (!x && !y) { |
1293 |
2/2✓ Branch 0 taken 44208 times.
✓ Branch 1 taken 7440 times.
|
51648 | for (int j = 0; j < h; j++) |
1294 | 44208 | memcpy(dst + j*dst_stride, src + j*src_stride, w); | |
1295 |
4/4✓ Branch 0 taken 412 times.
✓ Branch 1 taken 382 times.
✓ Branch 2 taken 82 times.
✓ Branch 3 taken 330 times.
|
876 | } else if (x > 0 && y > 0) { |
1296 | int a, b, c, d; | ||
1297 | |||
1298 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 82 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
82 | if (x == 3 && y == 3) |
1299 | ✗ | y = 2; //reproduce bug in rv60 decoder. tested with realplayer version 18.1.7.344 and 22.0.0.321 | |
1300 | |||
1301 | 82 | a = (4 - x) * (4 - y); | |
1302 | 82 | b = x * (4 - y); | |
1303 | 82 | c = (4 - x) * y; | |
1304 | 82 | d = x * y; | |
1305 |
2/2✓ Branch 0 taken 300 times.
✓ Branch 1 taken 82 times.
|
382 | for (int j = 0; j < h; j++) |
1306 |
2/2✓ Branch 0 taken 1104 times.
✓ Branch 1 taken 300 times.
|
1404 | for (int i = 0; i < w; i++) |
1307 | 1104 | dst[j*dst_stride + i] = | |
1308 | 1104 | (a * src[j*src_stride + i] + | |
1309 | 1104 | b * src[j*src_stride + i + 1] + | |
1310 | 1104 | c * src[(j + 1)*src_stride + i] + | |
1311 | 1104 | d * src[(j + 1)*src_stride + i + 1] + 8) >> 4; | |
1312 | } else { | ||
1313 | 712 | int a = (4 - x) * (4 - y); | |
1314 | 712 | int e = x * (4 - y) + (4 - x) * y; | |
1315 |
2/2✓ Branch 0 taken 382 times.
✓ Branch 1 taken 330 times.
|
712 | int step = y > 0 ? src_stride : 1; |
1316 |
2/2✓ Branch 0 taken 2836 times.
✓ Branch 1 taken 712 times.
|
3548 | for (int j = 0; j < h; j++) |
1317 |
2/2✓ Branch 0 taken 14512 times.
✓ Branch 1 taken 2836 times.
|
17348 | for (int i = 0; i < w; i++) |
1318 | 14512 | dst[j*dst_stride + i] = | |
1319 | 14512 | (a * src[j*src_stride + i] + | |
1320 | 14512 | e * src[j*src_stride + i + step] + 8) >> 4; | |
1321 | } | ||
1322 | 8234 | } | |
1323 | |||
1324 | 12351 | static int check_pos(int x, int y, int cw, int ch, int w, int h, int dx, int dy, int e0, int e1, int e2, int e3) | |
1325 | { | ||
1326 | 12351 | int x2 = x + dx; | |
1327 | 12351 | int y2 = y + dy; | |
1328 |
7/8✓ Branch 0 taken 12318 times.
✓ Branch 1 taken 33 times.
✓ Branch 2 taken 11770 times.
✓ Branch 3 taken 548 times.
✓ Branch 4 taken 11770 times.
✗ Branch 5 not taken.
✓ Branch 6 taken 11351 times.
✓ Branch 7 taken 419 times.
|
12351 | return x2 - e0 >= 0 && x2 + cw + e1 <= w && y2 - e2 >= 0 && y2 + ch + e3 <= h; |
1329 | } | ||
1330 | |||
1331 | 4117 | static void mc(RV60Context * s, uint8_t * frame_data[3], int frame_linesize[3], const AVFrame * ref, int x, int y, int w, int h, MV mv, int avg) | |
1332 | { | ||
1333 | { | ||
1334 |
2/2✓ Branch 0 taken 3810 times.
✓ Branch 1 taken 307 times.
|
4117 | int off = !avg ? y * frame_linesize[0] + x : 0; |
1335 | 4117 | int fw = s->awidth; | |
1336 | 4117 | int fh = s->aheight; | |
1337 | 4117 | int dx = mv.x >> 2; | |
1338 | 4117 | int cx = mv.x & 3; | |
1339 | 4117 | int dy = mv.y >> 2; | |
1340 | 4117 | int cy = mv.y & 3; | |
1341 | |||
1342 |
2/2✓ Branch 1 taken 4041 times.
✓ Branch 2 taken 76 times.
|
4117 | if (check_pos(x, y, w, h, fw, fh, dx, dy, rv60_edge1[cx], rv60_edge2[cx], rv60_edge1[cy], rv60_edge2[cy])) { |
1343 | 4041 | luma_mc( | |
1344 | 4041 | frame_data[0] + off, | |
1345 | frame_linesize[0], | ||
1346 | 4041 | ref->data[0] + (y + dy) * ref->linesize[0] + x + dx, | |
1347 | 4041 | ref->linesize[0], | |
1348 | w, h, cx, cy); | ||
1349 | } else { | ||
1350 | uint8_t buf[70*70]; | ||
1351 | 76 | int xoff = x + dx - 2; | |
1352 | 76 | int yoff = y + dy - 2; | |
1353 | 76 | s->vdsp.emulated_edge_mc(buf, | |
1354 | 76 | ref->data[0] + yoff * ref->linesize[0] + xoff, | |
1355 | 76 | 70, ref->linesize[0], | |
1356 | w + 5, h + 5, | ||
1357 | xoff, yoff, | ||
1358 | fw, fh); | ||
1359 | |||
1360 | 76 | luma_mc(frame_data[0] + off, frame_linesize[0], | |
1361 | buf + 70 * 2 + 2, 70, w, h, cx, cy); | ||
1362 | } | ||
1363 | } | ||
1364 | { | ||
1365 | 4117 | int fw = s->awidth >> 1; | |
1366 | 4117 | int fh = s->aheight >> 1; | |
1367 | 4117 | int mvx = mv.x / 2; | |
1368 | 4117 | int mvy = mv.y / 2; | |
1369 | 4117 | int dx = mvx >> 2; | |
1370 | 4117 | int cx = mvx & 3; | |
1371 | 4117 | int dy = mvy >> 2; | |
1372 | 4117 | int cy = mvy & 3; | |
1373 | 4117 | int cw = w >> 1; | |
1374 | 4117 | int ch = h >> 1; | |
1375 | |||
1376 |
2/2✓ Branch 0 taken 8234 times.
✓ Branch 1 taken 4117 times.
|
12351 | for (int plane = 1; plane < 3; plane++) { |
1377 |
2/2✓ Branch 0 taken 7620 times.
✓ Branch 1 taken 614 times.
|
8234 | int off = !avg ? (y >> 1) * frame_linesize[plane] + (x >> 1) : 0; |
1378 |
2/2✓ Branch 1 taken 7310 times.
✓ Branch 2 taken 924 times.
|
8234 | if (check_pos(x >> 1, y >> 1, cw, ch, fw, fh, dx, dy, 0, 1, 0, 1)) { |
1379 | 7310 | chroma_mc( | |
1380 | 7310 | frame_data[plane] + off, | |
1381 | 7310 | frame_linesize[plane], | |
1382 | 7310 | ref->data[plane] + ((y >> 1) + dy) * ref->linesize[plane] + (x >> 1) + dx, | |
1383 | 7310 | ref->linesize[plane], | |
1384 | cw, ch, cx, cy); | ||
1385 | } else { | ||
1386 | uint8_t buf[40*40]; | ||
1387 | 924 | s->vdsp.emulated_edge_mc(buf, | |
1388 | 924 | ref->data[plane] + ((y >> 1) + dy) * ref->linesize[plane] + (x >> 1) + dx, | |
1389 | 924 | 40, ref->linesize[plane], | |
1390 | cw + 1, ch + 1, | ||
1391 | 924 | (x >> 1) + dx, (y >> 1) + dy, | |
1392 | fw, fh); | ||
1393 | 924 | chroma_mc(frame_data[plane] + off, frame_linesize[plane], buf, 40, cw, ch, cx, cy); | |
1394 | } | ||
1395 | } | ||
1396 | } | ||
1397 | 4117 | } | |
1398 | |||
1399 | 921 | static void avg_plane(uint8_t * dst, int dst_stride, const uint8_t * src, int src_stride, int w, int h) | |
1400 | { | ||
1401 |
2/2✓ Branch 0 taken 6992 times.
✓ Branch 1 taken 921 times.
|
7913 | for (int j = 0; j < h; j++) |
1402 |
2/2✓ Branch 0 taken 94944 times.
✓ Branch 1 taken 6992 times.
|
101936 | for (int i = 0; i < w; i++) |
1403 | 94944 | dst[j*dst_stride + i] = (dst[j*dst_stride + i] + src[j*src_stride + i]) >> 1; | |
1404 | 921 | } | |
1405 | |||
1406 | 307 | static void avg(AVFrame * frame, uint8_t * prev_frame_data[3], int prev_frame_linesize[3], int x, int y, int w, int h) | |
1407 | { | ||
1408 |
2/2✓ Branch 0 taken 921 times.
✓ Branch 1 taken 307 times.
|
1228 | for (int plane = 0; plane < 3; plane++) { |
1409 | 921 | int shift = !plane ? 0 : 1; | |
1410 | 921 | avg_plane(frame->data[plane] + (y >> shift) * frame->linesize[plane] + (x >> shift), frame->linesize[plane], | |
1411 | 921 | prev_frame_data[plane], prev_frame_linesize[plane], | |
1412 | w >> shift, h >> shift); | ||
1413 | } | ||
1414 | 307 | } | |
1415 | |||
1416 | 2253 | static int get_c4x4_set(int qp, int is_intra) | |
1417 | { | ||
1418 |
2/2✓ Branch 0 taken 1166 times.
✓ Branch 1 taken 1087 times.
|
2253 | if (is_intra) |
1419 | 1166 | return rv60_qp_to_idx[qp + 32]; | |
1420 | else | ||
1421 | 1087 | return rv60_qp_to_idx[qp]; | |
1422 | } | ||
1423 | |||
1424 | 137688 | static int quant(int v, int q) | |
1425 | { | ||
1426 | 137688 | return (v * q + 8) >> 4; | |
1427 | } | ||
1428 | |||
1429 | 137688 | static int decode_coeff(GetBitContext * gb, const CoeffVLCs * vlcs, int inval, int val) | |
1430 | { | ||
1431 | int esc_sym; | ||
1432 | |||
1433 |
2/2✓ Branch 0 taken 73186 times.
✓ Branch 1 taken 64502 times.
|
137688 | if (inval != val) |
1434 |
4/4✓ Branch 0 taken 30539 times.
✓ Branch 1 taken 42647 times.
✓ Branch 3 taken 15512 times.
✓ Branch 4 taken 15027 times.
|
73186 | return inval && get_bits1(gb) ? -inval : inval; |
1435 | |||
1436 | 64502 | esc_sym = get_vlc2(gb, vlcs->esc, 9, 2); | |
1437 |
2/2✓ Branch 0 taken 2214 times.
✓ Branch 1 taken 62288 times.
|
64502 | if (esc_sym > 23) { |
1438 | 2214 | int esc_bits = esc_sym - 23; | |
1439 | 2214 | val += (1 << esc_bits) + get_bits(gb, esc_bits) + 22; | |
1440 | } else | ||
1441 | 62288 | val += esc_sym; | |
1442 | |||
1443 |
2/2✓ Branch 1 taken 32044 times.
✓ Branch 2 taken 32458 times.
|
64502 | return get_bits1(gb) ? -val : val; |
1444 | } | ||
1445 | |||
1446 | 4396 | static void decode_2x2_dc(GetBitContext * gb, const CoeffVLCs * vlcs, int16_t * coeffs, int stride, int block2, int dsc, int q_dc, int q_ac) | |
1447 | { | ||
1448 | const uint8_t * lx; | ||
1449 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4396 times.
|
4396 | if (!dsc) |
1450 | ✗ | return; | |
1451 | |||
1452 | 4396 | lx = rv60_dsc_to_lx[dsc - 1]; | |
1453 | |||
1454 | 4396 | coeffs[0] = quant(decode_coeff(gb, vlcs, lx[0], 3), q_dc); | |
1455 |
1/2✓ Branch 0 taken 4396 times.
✗ Branch 1 not taken.
|
4396 | if (!block2) { |
1456 | 4396 | coeffs[1] = quant(decode_coeff(gb, vlcs, lx[1], 2), q_ac); | |
1457 | 4396 | coeffs[stride] = quant(decode_coeff(gb, vlcs, lx[2], 2), q_ac); | |
1458 | } else { | ||
1459 | ✗ | coeffs[stride] = quant(decode_coeff(gb, vlcs, lx[1], 2), q_ac); | |
1460 | ✗ | coeffs[1] = quant(decode_coeff(gb, vlcs, lx[2], 2), q_ac); | |
1461 | } | ||
1462 | 4396 | coeffs[stride + 1] = quant(decode_coeff(gb, vlcs, lx[3], 2), q_ac); | |
1463 | } | ||
1464 | |||
1465 | 30026 | static void decode_2x2(GetBitContext * gb, const CoeffVLCs * vlcs, int16_t * coeffs, int stride, int block2, int dsc, int q_ac) | |
1466 | { | ||
1467 | const uint8_t * lx; | ||
1468 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 30026 times.
|
30026 | if (!dsc) |
1469 | ✗ | return; | |
1470 | |||
1471 | 30026 | lx = rv60_dsc_to_lx[dsc - 1]; | |
1472 | |||
1473 | 30026 | coeffs[0] = quant(decode_coeff(gb, vlcs, lx[0], 3), q_ac); | |
1474 |
2/2✓ Branch 0 taken 22293 times.
✓ Branch 1 taken 7733 times.
|
30026 | if (!block2) { |
1475 | 22293 | coeffs[1] = quant(decode_coeff(gb, vlcs, lx[1], 2), q_ac); | |
1476 | 22293 | coeffs[stride] = quant(decode_coeff(gb, vlcs, lx[2], 2), q_ac); | |
1477 | } else { | ||
1478 | 7733 | coeffs[stride] = quant(decode_coeff(gb, vlcs, lx[1], 2), q_ac); | |
1479 | 7733 | coeffs[1] = quant(decode_coeff(gb, vlcs, lx[2], 2), q_ac); | |
1480 | } | ||
1481 | 30026 | coeffs[stride + 1] = quant(decode_coeff(gb, vlcs, lx[3], 2), q_ac); | |
1482 | } | ||
1483 | |||
1484 | 4548 | static void decode_4x4_block_dc(GetBitContext * gb, const CoeffVLCs * vlcs, int is_luma, int16_t * coeffs, int stride, int q_dc, int q_ac) | |
1485 | { | ||
1486 | 4548 | int sym0 = get_vlc2(gb, vlcs->l0[!is_luma], 9, 2); | |
1487 | 4548 | int grp0 = sym0 >> 3; | |
1488 | |||
1489 |
2/2✓ Branch 0 taken 4396 times.
✓ Branch 1 taken 152 times.
|
4548 | if (grp0) |
1490 | 4396 | decode_2x2_dc(gb, vlcs, coeffs, stride, 0, grp0, q_dc, q_ac); | |
1491 | |||
1492 |
2/2✓ Branch 0 taken 3242 times.
✓ Branch 1 taken 1306 times.
|
4548 | if (sym0 & 4) { |
1493 | 3242 | int grp = get_vlc2(gb, vlcs->l12[!is_luma], 9, 2); | |
1494 | 3242 | decode_2x2(gb, vlcs, coeffs + 2, stride, 0, grp, q_ac); | |
1495 | } | ||
1496 |
2/2✓ Branch 0 taken 2779 times.
✓ Branch 1 taken 1769 times.
|
4548 | if (sym0 & 2) { |
1497 | 2779 | int grp = get_vlc2(gb, vlcs->l12[!is_luma], 9, 2); | |
1498 | 2779 | decode_2x2(gb, vlcs, coeffs + 2*stride, stride, 1, grp, q_ac); | |
1499 | } | ||
1500 |
2/2✓ Branch 0 taken 2478 times.
✓ Branch 1 taken 2070 times.
|
4548 | if (sym0 & 1) { |
1501 | 2478 | int grp = get_vlc2(gb, vlcs->l3[!is_luma], 9, 2); | |
1502 | 2478 | decode_2x2(gb, vlcs, coeffs + 2*stride + 2, stride, 0, grp, q_ac); | |
1503 | } | ||
1504 | 4548 | } | |
1505 | |||
1506 | 7219 | static void decode_4x4_block(GetBitContext * gb, const CoeffVLCs * vlcs, int is_luma, int16_t * coeffs, int stride, int q_ac) | |
1507 | { | ||
1508 | 7219 | int sym0 = get_vlc2(gb, vlcs->l0[!is_luma], 9, 2); | |
1509 | 7219 | int grp0 = (sym0 >> 3); | |
1510 | |||
1511 |
2/2✓ Branch 0 taken 6761 times.
✓ Branch 1 taken 458 times.
|
7219 | if (grp0) |
1512 | 6761 | decode_2x2(gb, vlcs, coeffs, stride, 0, grp0, q_ac); | |
1513 | |||
1514 |
2/2✓ Branch 0 taken 5569 times.
✓ Branch 1 taken 1650 times.
|
7219 | if (sym0 & 4) { |
1515 | 5569 | int grp = get_vlc2(gb, vlcs->l12[!is_luma], 9, 2); | |
1516 | 5569 | decode_2x2(gb, vlcs, coeffs + 2, stride, 0, grp, q_ac); | |
1517 | } | ||
1518 |
2/2✓ Branch 0 taken 4954 times.
✓ Branch 1 taken 2265 times.
|
7219 | if (sym0 & 2) { |
1519 | 4954 | int grp = get_vlc2(gb, vlcs->l12[!is_luma], 9, 2); | |
1520 | 4954 | decode_2x2(gb, vlcs, coeffs + 2*stride, stride, 1, grp, q_ac); | |
1521 | } | ||
1522 |
2/2✓ Branch 0 taken 4243 times.
✓ Branch 1 taken 2976 times.
|
7219 | if (sym0 & 1) { |
1523 | 4243 | int grp = get_vlc2(gb, vlcs->l3[!is_luma], 9, 2); | |
1524 | 4243 | decode_2x2(gb, vlcs, coeffs + 2*stride + 2, stride, 0, grp, q_ac); | |
1525 | } | ||
1526 | 7219 | } | |
1527 | |||
1528 | 139 | static void decode_cu_4x4in16x16(GetBitContext * gb, int is_intra, int qp, int sel_qp, int16_t * y_coeffs, int16_t * u_coeffs, int16_t * v_coeffs, int cbp) | |
1529 | { | ||
1530 | 139 | int cb_set = get_c4x4_set(sel_qp, is_intra); | |
1531 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 139 times.
|
139 | const CoeffVLCs * vlc = is_intra ? &intra_coeff_vlc[cb_set] : &inter_coeff_vlc[cb_set]; |
1532 | 139 | int q_y = rv60_quants_b[qp]; | |
1533 | 139 | int q_c_dc = rv60_quants_b[rv60_chroma_quant_dc[qp]]; | |
1534 | 139 | int q_c_ac = rv60_quants_b[rv60_chroma_quant_ac[qp]]; | |
1535 | |||
1536 | 139 | memset(y_coeffs, 0, sizeof(y_coeffs[0])*256); | |
1537 |
2/2✓ Branch 0 taken 2224 times.
✓ Branch 1 taken 139 times.
|
2363 | for (int i = 0; i < 16; i++) |
1538 |
2/2✓ Branch 0 taken 979 times.
✓ Branch 1 taken 1245 times.
|
2224 | if ((cbp >> i) & 1) |
1539 | 979 | decode_4x4_block(gb, vlc, 1, y_coeffs + i * 16 , 4, q_y); | |
1540 | |||
1541 | 139 | memset(u_coeffs, 0, sizeof(u_coeffs[0])*64); | |
1542 |
2/2✓ Branch 0 taken 556 times.
✓ Branch 1 taken 139 times.
|
695 | for (int i = 0; i < 4; i++) |
1543 |
2/2✓ Branch 0 taken 341 times.
✓ Branch 1 taken 215 times.
|
556 | if ((cbp >> (16 + i)) & 1) |
1544 | 341 | decode_4x4_block_dc(gb, vlc, 0, u_coeffs + i * 16, 4, q_c_dc, q_c_ac); | |
1545 | |||
1546 | 139 | memset(v_coeffs, 0, sizeof(v_coeffs[0])*64); | |
1547 |
2/2✓ Branch 0 taken 556 times.
✓ Branch 1 taken 139 times.
|
695 | for (int i = 0; i < 4; i++) |
1548 |
2/2✓ Branch 0 taken 335 times.
✓ Branch 1 taken 221 times.
|
556 | if ((cbp >> (20 + i)) & 1) |
1549 | 335 | decode_4x4_block_dc(gb, vlc, 0, v_coeffs + i * 16, 4, q_c_dc, q_c_ac); | |
1550 | 139 | } | |
1551 | |||
1552 | 2387 | static int decode_cbp8(GetBitContext * gb, int subset, int qp) | |
1553 | { | ||
1554 | 2387 | int cb_set = rv60_qp_to_idx[qp]; | |
1555 | 2387 | return get_vlc2(gb, cbp8_vlc[cb_set][subset], 9, 2); | |
1556 | } | ||
1557 | |||
1558 | 1901 | static void decode_cu_8x8(GetBitContext * gb, int is_intra, int qp, int sel_qp, int16_t * y_coeffs, int16_t * u_coeffs, int16_t * v_coeffs, int ccbp, int mode4x4) | |
1559 | { | ||
1560 | 1901 | int cb_set = get_c4x4_set(sel_qp, is_intra); | |
1561 |
2/2✓ Branch 0 taken 1070 times.
✓ Branch 1 taken 831 times.
|
1901 | const CoeffVLCs * vlc = is_intra ? &intra_coeff_vlc[cb_set] : &inter_coeff_vlc[cb_set]; |
1562 | 1901 | int q_y = rv60_quants_b[qp]; | |
1563 | 1901 | int q_c_dc = rv60_quants_b[rv60_chroma_quant_dc[qp]]; | |
1564 | 1901 | int q_c_ac = rv60_quants_b[rv60_chroma_quant_ac[qp]]; | |
1565 | |||
1566 | 1901 | memset(y_coeffs, 0, sizeof(y_coeffs[0])*64); | |
1567 |
2/2✓ Branch 0 taken 7604 times.
✓ Branch 1 taken 1901 times.
|
9505 | for (int i = 0; i < 4; i++) { |
1568 |
2/2✓ Branch 0 taken 4514 times.
✓ Branch 1 taken 3090 times.
|
7604 | if ((ccbp >> i) & 1) { |
1569 | int offset, stride; | ||
1570 |
2/2✓ Branch 0 taken 2468 times.
✓ Branch 1 taken 2046 times.
|
4514 | if (mode4x4) { |
1571 | 2468 | offset = i*16; | |
1572 | 2468 | stride = 4; | |
1573 | } else { | ||
1574 | 2046 | offset = (i & 1) * 4 + (i & 2) * 2 * 8; | |
1575 | 2046 | stride = 8; | |
1576 | } | ||
1577 | 4514 | decode_4x4_block(gb, vlc, 1, y_coeffs + offset, stride, q_y); | |
1578 | } | ||
1579 | } | ||
1580 | |||
1581 |
2/2✓ Branch 0 taken 1741 times.
✓ Branch 1 taken 160 times.
|
1901 | if ((ccbp >> 4) & 1) { |
1582 | 1741 | memset(u_coeffs, 0, sizeof(u_coeffs[0])*16); | |
1583 | 1741 | decode_4x4_block_dc(gb, vlc, 0, u_coeffs, 4, q_c_dc, q_c_ac); | |
1584 | } | ||
1585 | |||
1586 |
2/2✓ Branch 0 taken 1778 times.
✓ Branch 1 taken 123 times.
|
1901 | if ((ccbp >> 5) & 1) { |
1587 | 1778 | memset(v_coeffs, 0, sizeof(u_coeffs[0])*16); | |
1588 | 1778 | decode_4x4_block_dc(gb, vlc, 0, v_coeffs, 4, q_c_dc, q_c_ac); | |
1589 | } | ||
1590 | 1901 | } | |
1591 | |||
1592 | 213 | static void decode_cu_16x16(GetBitContext * gb, int is_intra, int qp, int sel_qp, int16_t * y_coeffs, int16_t * u_coeffs, int16_t * v_coeffs, int ccbp) | |
1593 | { | ||
1594 | 213 | int cb_set = get_c4x4_set(sel_qp, is_intra); | |
1595 |
2/2✓ Branch 0 taken 96 times.
✓ Branch 1 taken 117 times.
|
213 | const CoeffVLCs * vlc = is_intra ? &intra_coeff_vlc[cb_set] : &inter_coeff_vlc[cb_set]; |
1596 | 213 | int q_y = rv60_quants_b[qp]; | |
1597 | 213 | int q_c_dc = rv60_quants_b[rv60_chroma_quant_dc[qp]]; | |
1598 | 213 | int q_c_ac = rv60_quants_b[rv60_chroma_quant_ac[qp]]; | |
1599 | |||
1600 | 213 | memset(y_coeffs, 0, sizeof(y_coeffs[0])*256); | |
1601 |
2/2✓ Branch 0 taken 3408 times.
✓ Branch 1 taken 213 times.
|
3621 | for (int i = 0; i < 16; i++) |
1602 |
2/2✓ Branch 0 taken 1230 times.
✓ Branch 1 taken 2178 times.
|
3408 | if ((ccbp >> i) & 1) { |
1603 | 1230 | int off = (i & 3) * 4 + (i >> 2) * 4 * 16; | |
1604 | 1230 | decode_4x4_block(gb, vlc, 1, y_coeffs + off, 16, q_y); | |
1605 | } | ||
1606 | |||
1607 | 213 | memset(u_coeffs, 0, sizeof(u_coeffs[0])*64); | |
1608 |
2/2✓ Branch 0 taken 852 times.
✓ Branch 1 taken 213 times.
|
1065 | for (int i = 0; i < 4; i++) |
1609 |
2/2✓ Branch 0 taken 428 times.
✓ Branch 1 taken 424 times.
|
852 | if ((ccbp >> (16 + i)) & 1) { |
1610 | 428 | int off = (i & 1) * 4 + (i & 2) * 2 * 8; | |
1611 |
2/2✓ Branch 0 taken 161 times.
✓ Branch 1 taken 267 times.
|
428 | if (!i) |
1612 | 161 | decode_4x4_block_dc(gb, vlc, 0, u_coeffs + off, 8, q_c_dc, q_c_ac); | |
1613 | else | ||
1614 | 267 | decode_4x4_block(gb, vlc, 0, u_coeffs + off, 8, q_c_ac); | |
1615 | } | ||
1616 | |||
1617 | 213 | memset(v_coeffs, 0, sizeof(v_coeffs[0])*64); | |
1618 |
2/2✓ Branch 0 taken 852 times.
✓ Branch 1 taken 213 times.
|
1065 | for (int i = 0; i < 4; i++) |
1619 |
2/2✓ Branch 0 taken 421 times.
✓ Branch 1 taken 431 times.
|
852 | if ((ccbp >> (20 + i)) & 1) { |
1620 | 421 | int off = (i & 1) * 4 + (i & 2) * 2 * 8; | |
1621 |
2/2✓ Branch 0 taken 192 times.
✓ Branch 1 taken 229 times.
|
421 | if (!i) |
1622 | 192 | decode_4x4_block_dc(gb, vlc, 0, v_coeffs + off, 8, q_c_dc, q_c_ac); | |
1623 | else | ||
1624 | 229 | decode_4x4_block(gb, vlc, 0, v_coeffs + off, 8, q_c_ac); | |
1625 | } | ||
1626 | 213 | } | |
1627 | |||
1628 | 352 | static int decode_super_cbp(GetBitContext * gb, const VLCElem * vlc[4]) | |
1629 | { | ||
1630 | 352 | int sym0 = get_vlc2(gb, vlc[0], 9, 2); | |
1631 | 352 | int sym1 = get_vlc2(gb, vlc[1], 9, 2); | |
1632 | 352 | int sym2 = get_vlc2(gb, vlc[2], 9, 2); | |
1633 | 352 | int sym3 = get_vlc2(gb, vlc[3], 9, 2); | |
1634 | return 0 | ||
1635 | 352 | + ((sym0 & 0x03) << 0) | |
1636 | 352 | + ((sym0 & 0x0C) << 2) | |
1637 | 352 | + ((sym0 & 0x10) << 12) | |
1638 | 352 | + ((sym0 & 0x20) << 15) | |
1639 | 352 | + ((sym1 & 0x03) << 2) | |
1640 | 352 | + ((sym1 & 0x0C) << 4) | |
1641 | 352 | + ((sym1 & 0x10) << 13) | |
1642 | 352 | + ((sym1 & 0x20) << 16) | |
1643 | 352 | + ((sym2 & 0x03) << 8) | |
1644 | 352 | + ((sym2 & 0x0C) << 10) | |
1645 | 352 | + ((sym2 & 0x10) << 14) | |
1646 | 352 | + ((sym2 & 0x20) << 17) | |
1647 | 352 | + ((sym3 & 0x03) << 10) | |
1648 | 352 | + ((sym3 & 0x0C) << 12) | |
1649 | 352 | + ((sym3 & 0x10) << 15) | |
1650 | 352 | + ((sym3 & 0x20) << 18); | |
1651 | } | ||
1652 | |||
1653 | 352 | static int decode_cbp16(GetBitContext * gb, int subset, int qp) | |
1654 | { | ||
1655 | 352 | int cb_set = rv60_qp_to_idx[qp]; | |
1656 | 352 | return decode_super_cbp(gb, cbp16_vlc[cb_set][subset]); | |
1657 | } | ||
1658 | |||
1659 | 7524 | static int decode_cu_r(RV60Context * s, AVFrame * frame, ThreadContext * thread, GetBitContext * gb, int xpos, int ypos, int log_size, int qp, int sel_qp) | |
1660 | { | ||
1661 | 7524 | int size = 1 << log_size; | |
1662 | int split, ret, ttype, count, is_intra, cu_pos, subset, cbp8, imode, split_i4x4, num_clusters, cl_cbp, super_cbp, mv_x, mv_y, mv_pos; | ||
1663 | int16_t y_coeffs[16*16], u_coeffs[8*8], v_coeffs[8*8]; | ||
1664 | CUContext cu; | ||
1665 | |||
1666 |
4/4✓ Branch 0 taken 7174 times.
✓ Branch 1 taken 350 times.
✓ Branch 2 taken 280 times.
✓ Branch 3 taken 6894 times.
|
7524 | if (xpos >= s->awidth || ypos >= s->aheight) |
1667 | 630 | return 0; | |
1668 | |||
1669 |
8/8✓ Branch 0 taken 6719 times.
✓ Branch 1 taken 175 times.
✓ Branch 2 taken 6614 times.
✓ Branch 3 taken 105 times.
✓ Branch 4 taken 3462 times.
✓ Branch 5 taken 3152 times.
✓ Branch 7 taken 1502 times.
✓ Branch 8 taken 1960 times.
|
6894 | split = xpos + size > s->awidth || ypos + size > s->aheight || (size > 8 && get_bits1(gb)); |
1670 | 6894 | thread->cu_split[thread->cu_split_pos++] = split; | |
1671 |
2/2✓ Branch 0 taken 1782 times.
✓ Branch 1 taken 5112 times.
|
6894 | if (split) { |
1672 | 1782 | size >>= 1; | |
1673 | 1782 | log_size -= 1; | |
1674 |
2/4✓ Branch 1 taken 1782 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1782 times.
✗ Branch 4 not taken.
|
3564 | if ((ret = decode_cu_r(s, frame, thread, gb, xpos, ypos, log_size, qp, sel_qp)) < 0 || |
1675 |
1/2✓ Branch 1 taken 1782 times.
✗ Branch 2 not taken.
|
3564 | (ret = decode_cu_r(s, frame, thread, gb, xpos + size, ypos, log_size, qp, sel_qp)) < 0 || |
1676 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1782 times.
|
3564 | (ret = decode_cu_r(s, frame, thread, gb, xpos, ypos + size, log_size, qp, sel_qp)) < 0 || |
1677 | 1782 | (ret = decode_cu_r(s, frame, thread, gb, xpos + size, ypos + size, log_size, qp, sel_qp)) < 0) | |
1678 | ✗ | return ret; | |
1679 | 1782 | return 0; | |
1680 | } | ||
1681 | |||
1682 | 5112 | cu.xpos = xpos; | |
1683 | 5112 | cu.ypos = ypos; | |
1684 | 5112 | cu.pu_pos = (xpos >> 3) + (ypos >> 3) * s->pu_stride; | |
1685 | 5112 | cu.blk_pos = (xpos >> 2) + (ypos >> 2) * s->blk_stride; | |
1686 |
2/2✓ Branch 0 taken 3163 times.
✓ Branch 1 taken 1949 times.
|
5112 | cu.cu_type = s->pict_type != AV_PICTURE_TYPE_I ? get_bits(gb, 2) : CU_INTRA; |
1687 | |||
1688 |
3/3✓ Branch 0 taken 2293 times.
✓ Branch 1 taken 1007 times.
✓ Branch 2 taken 1812 times.
|
5112 | switch (cu.cu_type) { |
1689 | 2293 | case CU_INTRA: | |
1690 |
4/4✓ Branch 0 taken 1480 times.
✓ Branch 1 taken 813 times.
✓ Branch 3 taken 718 times.
✓ Branch 4 taken 762 times.
|
2293 | cu.pu_type = size == 8 && get_bits1(gb) ? PU_QUARTERS : PU_FULL; |
1691 |
2/2✓ Branch 0 taken 718 times.
✓ Branch 1 taken 1575 times.
|
2293 | if (cu.pu_type == PU_QUARTERS) |
1692 |
2/2✓ Branch 0 taken 2872 times.
✓ Branch 1 taken 718 times.
|
3590 | for (int i = 0; i < 4; i++) |
1693 | 2872 | cu.imode[i] = read_intra_mode(gb, &cu.imode_param[i]); | |
1694 |
1/2✓ Branch 0 taken 1575 times.
✗ Branch 1 not taken.
|
1575 | else if (size <= 32) |
1695 | 1575 | cu.imode[0] = read_intra_mode(gb, &cu.imode_param[0]); | |
1696 | else | ||
1697 | ✗ | cu.imode[0] = get_bits1(gb) ? INTRAMODE_PLANE64 : INTRAMODE_DC64; | |
1698 | 2293 | break; | |
1699 | 1007 | case CU_INTER_MV: | |
1700 |
2/2✓ Branch 0 taken 799 times.
✓ Branch 1 taken 208 times.
|
1007 | cu.pu_type = get_bits(gb, size == 8 ? 2 : 3); |
1701 | 1007 | count = pu_type_num_parts(cu.pu_type); | |
1702 |
2/2✓ Branch 0 taken 1998 times.
✓ Branch 1 taken 1007 times.
|
3005 | for (int i = 0; i < count; i++) |
1703 | 1998 | read_mv_info(s, gb, &cu.mv[i], size, cu.pu_type); | |
1704 | 1007 | break; | |
1705 | 1812 | default: | |
1706 | 1812 | cu.pu_type = PU_FULL; | |
1707 | 1812 | cu.mv[0].mvref = skip_mv_ref[get_unary(gb, 0, 3)]; | |
1708 | 1812 | break; | |
1709 | } | ||
1710 | |||
1711 | 5112 | reconstruct(s, &cu, size); | |
1712 | |||
1713 |
6/6✓ Branch 0 taken 2293 times.
✓ Branch 1 taken 2819 times.
✓ Branch 2 taken 1480 times.
✓ Branch 3 taken 813 times.
✓ Branch 4 taken 718 times.
✓ Branch 5 taken 762 times.
|
5112 | split_i4x4 = cu.cu_type == CU_INTRA && size == 8 && cu.pu_type == PU_QUARTERS; |
1714 | |||
1715 |
2/2✓ Branch 0 taken 2293 times.
✓ Branch 1 taken 2819 times.
|
5112 | switch (cu.cu_type) { |
1716 | 2293 | case CU_INTRA: | |
1717 | 2293 | imode = s->blk_info[cu.blk_pos].imode; | |
1718 |
2/2✓ Branch 0 taken 1575 times.
✓ Branch 1 taken 718 times.
|
2293 | if (!split_i4x4) { |
1719 | 1575 | int off = ypos * frame->linesize[0] + xpos; | |
1720 | 1575 | populate_ipred(s, &cu, frame->data[0], frame->linesize[0], 0, 0, size, 1); | |
1721 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1575 times.
|
1575 | if (pred_angle(&cu.ipred, frame->data[0] + off, frame->linesize[0], size, imode, 1) < 0) |
1722 | ✗ | return AVERROR_INVALIDDATA; | |
1723 | } | ||
1724 |
2/2✓ Branch 0 taken 4586 times.
✓ Branch 1 taken 2293 times.
|
6879 | for (int plane = 1; plane < 3; plane++) { |
1725 | 4586 | int off = (ypos >> 1) * frame->linesize[plane] + (xpos >> 1); | |
1726 | 4586 | populate_ipred(s, &cu, frame->data[plane], frame->linesize[plane], 0, 0, size >> 1, 0); | |
1727 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 4586 times.
|
4586 | if (pred_angle(&cu.ipred, frame->data[plane] + off, frame->linesize[plane], size >> 1, imode, 0) < 0) |
1728 | ✗ | return AVERROR_INVALIDDATA; | |
1729 | } | ||
1730 | 2293 | break; | |
1731 | 2819 | default: | |
1732 | 2819 | mv_x = xpos >> 2; | |
1733 | 2819 | mv_y = ypos >> 2; | |
1734 | 2819 | mv_pos = mv_y * s->blk_stride + mv_x; | |
1735 | 2819 | count = pu_type_num_parts(cu.pu_type); | |
1736 |
2/2✓ Branch 0 taken 3810 times.
✓ Branch 1 taken 2819 times.
|
6629 | for (int part_no = 0; part_no < count; part_no++) { |
1737 | MVInfo mv; | ||
1738 | Dimensions dim; | ||
1739 | int bw, bh, bx, by; | ||
1740 | |||
1741 | 3810 | mv = s->blk_info[mv_pos].mv; | |
1742 | 3810 | get_mv_dimensions(&dim, cu.pu_type, part_no, size); | |
1743 | 3810 | bw = dim.w << 2; | |
1744 | 3810 | bh = dim.h << 2; | |
1745 | 3810 | bx = mv_x << 2; | |
1746 | 3810 | by = mv_y << 2; | |
1747 | |||
1748 |
2/2✓ Branch 0 taken 2725 times.
✓ Branch 1 taken 1085 times.
|
3810 | if (!(mv.mvref & 2)) { |
1749 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2725 times.
|
2725 | if (!s->last_frame[LAST_PIC]->data[0]) { |
1750 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "missing reference frame\n"); | |
1751 | ✗ | return AVERROR_INVALIDDATA; | |
1752 | } | ||
1753 | } | ||
1754 |
2/2✓ Branch 0 taken 1392 times.
✓ Branch 1 taken 2418 times.
|
3810 | if (mv.mvref & 6) { |
1755 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1392 times.
|
1392 | if (!s->last_frame[NEXT_PIC]->data[0]) { |
1756 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "missing reference frame\n"); | |
1757 | ✗ | return AVERROR_INVALIDDATA; | |
1758 | } | ||
1759 | } | ||
1760 | |||
1761 |
4/5✓ Branch 0 taken 2418 times.
✓ Branch 1 taken 207 times.
✓ Branch 2 taken 878 times.
✓ Branch 3 taken 307 times.
✗ Branch 4 not taken.
|
3810 | switch (mv.mvref) { |
1762 | 2418 | case MVREF_REF0: | |
1763 | 2418 | mc(s, frame->data, frame->linesize, s->last_frame[LAST_PIC], bx, by, bw, bh, mv.f_mv, 0); | |
1764 | 2418 | break; | |
1765 | 207 | case MVREF_REF1: | |
1766 | 207 | mc(s, frame->data, frame->linesize, s->last_frame[NEXT_PIC], bx, by, bw, bh, mv.f_mv, 0); | |
1767 | 207 | break; | |
1768 | 878 | case MVREF_BREF: | |
1769 | 878 | mc(s, frame->data, frame->linesize, s->last_frame[NEXT_PIC], bx, by, bw, bh, mv.b_mv, 0); | |
1770 | 878 | break; | |
1771 | 307 | case MVREF_REF0ANDBREF: | |
1772 | 307 | mc(s, frame->data, frame->linesize, s->last_frame[LAST_PIC], bx, by, bw, bh, mv.f_mv, 0); | |
1773 | 307 | mc(s, thread->avg_data, thread->avg_linesize, s->last_frame[NEXT_PIC], bx, by, bw, bh, mv.b_mv, 1); | |
1774 | 307 | avg(frame, thread->avg_data, thread->avg_linesize, bx, by, bw, bh); | |
1775 | 307 | break; | |
1776 | ✗ | default: | |
1777 | ✗ | av_assert0(0); //should never reach here | |
1778 | } | ||
1779 | 3810 | get_next_mv(s, &dim, cu.pu_type, part_no, &mv_pos, &mv_x, &mv_y); | |
1780 | } | ||
1781 | 2819 | break; | |
1782 | } | ||
1783 | |||
1784 |
2/2✓ Branch 0 taken 1639 times.
✓ Branch 1 taken 3473 times.
|
5112 | if (cu.cu_type == CU_SKIP) |
1785 | 1639 | ttype = TRANSFORM_NONE; | |
1786 |
2/2✓ Branch 0 taken 28 times.
✓ Branch 1 taken 3445 times.
|
3473 | else if (size >= 32) |
1787 | 28 | ttype = TRANSFORM_16X16; | |
1788 |
2/2✓ Branch 0 taken 1058 times.
✓ Branch 1 taken 2387 times.
|
3445 | else if (size == 16) |
1789 |
4/4✓ Branch 0 taken 245 times.
✓ Branch 1 taken 813 times.
✓ Branch 2 taken 97 times.
✓ Branch 3 taken 148 times.
|
1058 | ttype = cu.cu_type == CU_INTRA || cu.pu_type == PU_FULL ? TRANSFORM_16X16 : TRANSFORM_4X4; |
1790 | else | ||
1791 |
2/2✓ Branch 0 taken 1370 times.
✓ Branch 1 taken 1017 times.
|
2387 | ttype = cu.pu_type == PU_FULL ? TRANSFORM_8X8 : TRANSFORM_4X4; |
1792 | |||
1793 | 5112 | is_intra = cu.cu_type == CU_INTRA; | |
1794 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5112 times.
|
5112 | if (qp >= 32) |
1795 | ✗ | return AVERROR_INVALIDDATA; | |
1796 | 5112 | cu_pos = ((xpos & 63) >> 3) + ((ypos & 63) >> 3) * 8; | |
1797 | |||
1798 |
4/4✓ Branch 0 taken 1165 times.
✓ Branch 1 taken 1370 times.
✓ Branch 2 taken 938 times.
✓ Branch 3 taken 1639 times.
|
5112 | switch (ttype) { |
1799 | 1165 | case TRANSFORM_4X4: | |
1800 |
2/2✓ Branch 0 taken 718 times.
✓ Branch 1 taken 447 times.
|
1165 | subset = is_intra ? 0 : 2; |
1801 |
2/2✓ Branch 0 taken 148 times.
✓ Branch 1 taken 1017 times.
|
1165 | if (size == 16) { |
1802 |
2/2✓ Branch 1 taken 139 times.
✓ Branch 2 taken 9 times.
|
148 | int cbp16 = get_bits1(gb) ? decode_cbp16(gb, subset, sel_qp) : 0; |
1803 |
2/2✓ Branch 0 taken 139 times.
✓ Branch 1 taken 9 times.
|
148 | if (cbp16) { |
1804 | 139 | decode_cu_4x4in16x16(gb, is_intra, qp, sel_qp, y_coeffs, u_coeffs, v_coeffs, cbp16); | |
1805 |
2/2✓ Branch 0 taken 556 times.
✓ Branch 1 taken 139 times.
|
695 | for (int y = 0; y < 4; y++) |
1806 |
2/2✓ Branch 0 taken 2224 times.
✓ Branch 1 taken 556 times.
|
2780 | for (int x = 0; x < 4; x++) { |
1807 | 2224 | int i = y*4 + x; | |
1808 |
2/2✓ Branch 0 taken 979 times.
✓ Branch 1 taken 1245 times.
|
2224 | if ((cbp16 >> i) & 1) { |
1809 | 979 | int off = (ypos + y * 4)*frame->linesize[0] + xpos + x * 4; | |
1810 | 979 | ff_rv60_idct4x4_add(y_coeffs + i*16, frame->data[0] + off, frame->linesize[0]); | |
1811 | 979 | thread->coded_blk[cu_pos + (y/2)*8 + (x/2)] = 1; | |
1812 | } | ||
1813 | } | ||
1814 |
2/2✓ Branch 0 taken 278 times.
✓ Branch 1 taken 139 times.
|
417 | for (int y = 0; y < 2; y++) |
1815 |
2/2✓ Branch 0 taken 556 times.
✓ Branch 1 taken 278 times.
|
834 | for (int x = 0; x < 2; x++) { |
1816 | 556 | int i = y * 2 + x; | |
1817 | 556 | int xoff = (xpos >> 1) + x * 4; | |
1818 | 556 | int yoff = (ypos >> 1) + y * 4; | |
1819 |
2/2✓ Branch 0 taken 341 times.
✓ Branch 1 taken 215 times.
|
556 | if ((cbp16 >> (16 + i)) & 1) { |
1820 | 341 | int off = yoff * frame->linesize[1] + xoff; | |
1821 | 341 | ff_rv60_idct4x4_add(u_coeffs + i * 16, frame->data[1] + off, frame->linesize[1]); | |
1822 | 341 | thread->coded_blk[cu_pos + y*8 + x] = 1; | |
1823 | } | ||
1824 |
2/2✓ Branch 0 taken 335 times.
✓ Branch 1 taken 221 times.
|
556 | if ((cbp16 >> (20 + i)) & 1) { |
1825 | 335 | int off = yoff * frame->linesize[2] + xoff; | |
1826 | 335 | ff_rv60_idct4x4_add(v_coeffs + i * 16, frame->data[2] + off, frame->linesize[2]); | |
1827 | 335 | thread->coded_blk[cu_pos + y*8 + x] = 1; | |
1828 | } | ||
1829 | } | ||
1830 | } | ||
1831 | } else { | ||
1832 | 1017 | cbp8 = decode_cbp8(gb, subset, sel_qp); | |
1833 |
2/2✓ Branch 0 taken 967 times.
✓ Branch 1 taken 50 times.
|
1017 | if (cbp8) { |
1834 | 967 | thread->coded_blk[cu_pos] = 1; | |
1835 | 967 | decode_cu_8x8(gb, is_intra, qp, sel_qp, y_coeffs, u_coeffs, v_coeffs, cbp8, 1); | |
1836 | } | ||
1837 |
2/2✓ Branch 0 taken 4068 times.
✓ Branch 1 taken 1017 times.
|
5085 | for (int i = 0; i < 4; i++) { |
1838 | 4068 | int xoff = (i & 1) << 2; | |
1839 | 4068 | int yoff = (i & 2) << 1; | |
1840 |
2/2✓ Branch 0 taken 2872 times.
✓ Branch 1 taken 1196 times.
|
4068 | if (split_i4x4) { |
1841 | 2872 | int off = (ypos + yoff) * frame->linesize[0] + xpos + xoff; | |
1842 | 2872 | int imode = s->blk_info[cu.blk_pos + (i >> 1) * s->blk_stride + (i & 1)].imode; | |
1843 | 2872 | populate_ipred(s, &cu, frame->data[0], frame->linesize[0], xoff, yoff, 4, 1); | |
1844 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 2872 times.
|
2872 | if (pred_angle(&cu.ipred, frame->data[0] + off, frame->linesize[0], 4, imode, 1) < 0) |
1845 | ✗ | return AVERROR_INVALIDDATA; | |
1846 | } | ||
1847 |
2/2✓ Branch 0 taken 2468 times.
✓ Branch 1 taken 1600 times.
|
4068 | if ((cbp8 >> i) & 1) { |
1848 | 2468 | int off = (ypos + yoff) * frame->linesize[0] + xpos + xoff; | |
1849 | 2468 | ff_rv60_idct4x4_add(y_coeffs + i * 16, frame->data[0] + off, frame->linesize[0]); | |
1850 | } | ||
1851 | } | ||
1852 |
2/2✓ Branch 0 taken 935 times.
✓ Branch 1 taken 82 times.
|
1017 | if ((cbp8 >> 4) & 1) { |
1853 | 935 | int off = (ypos >> 1) * frame->linesize[1] + (xpos >> 1); | |
1854 | 935 | ff_rv60_idct4x4_add(u_coeffs, frame->data[1] + off, frame->linesize[1]); | |
1855 | } | ||
1856 |
2/2✓ Branch 0 taken 936 times.
✓ Branch 1 taken 81 times.
|
1017 | if ((cbp8 >> 5) & 1) { |
1857 | 936 | int off = (ypos >> 1) * frame->linesize[2] + (xpos >> 1); | |
1858 | 936 | ff_rv60_idct4x4_add(v_coeffs, frame->data[2] + off, frame->linesize[2]); | |
1859 | } | ||
1860 | } | ||
1861 | 1165 | break; | |
1862 | 1370 | case TRANSFORM_8X8: | |
1863 |
2/2✓ Branch 0 taken 762 times.
✓ Branch 1 taken 608 times.
|
1370 | subset = is_intra ? 1 : 3; |
1864 | 1370 | cbp8 = decode_cbp8(gb, subset, sel_qp); | |
1865 |
2/2✓ Branch 0 taken 934 times.
✓ Branch 1 taken 436 times.
|
1370 | if (cbp8) { |
1866 | 934 | thread->coded_blk[cu_pos] = 1; | |
1867 | 934 | decode_cu_8x8(gb, is_intra, qp, sel_qp, y_coeffs, u_coeffs, v_coeffs, cbp8, 0); | |
1868 |
2/2✓ Branch 0 taken 851 times.
✓ Branch 1 taken 83 times.
|
934 | if (cbp8 & 0xF) { |
1869 | 851 | int off = ypos * frame->linesize[0] + xpos; | |
1870 | 851 | ff_rv60_idct8x8_add(y_coeffs, frame->data[0] + off, frame->linesize[0]); | |
1871 | } | ||
1872 |
2/2✓ Branch 0 taken 806 times.
✓ Branch 1 taken 128 times.
|
934 | if ((cbp8 >> 4) & 1) { |
1873 | 806 | int off = (ypos >> 1) * frame->linesize[1] + (xpos >> 1); | |
1874 | 806 | ff_rv60_idct4x4_add(u_coeffs, frame->data[1] + off, frame->linesize[1]); | |
1875 | } | ||
1876 |
2/2✓ Branch 0 taken 842 times.
✓ Branch 1 taken 92 times.
|
934 | if ((cbp8 >> 5) & 1) { |
1877 | 842 | int off = (ypos >> 1) * frame->linesize[2] + (xpos >> 1); | |
1878 | 842 | ff_rv60_idct4x4_add(v_coeffs, frame->data[2] + off, frame->linesize[2]); | |
1879 | } | ||
1880 | } | ||
1881 | 1370 | break; | |
1882 | 938 | case TRANSFORM_16X16: | |
1883 |
2/2✓ Branch 0 taken 813 times.
✓ Branch 1 taken 125 times.
|
938 | subset = is_intra ? 1 : 3; |
1884 | 938 | num_clusters = size >> 4; | |
1885 | 938 | cl_cbp = get_bits(gb, num_clusters * num_clusters); | |
1886 |
2/2✓ Branch 0 taken 966 times.
✓ Branch 1 taken 938 times.
|
1904 | for (int y = 0; y < num_clusters; y++) { |
1887 |
2/2✓ Branch 0 taken 1022 times.
✓ Branch 1 taken 966 times.
|
1988 | for (int x = 0; x < num_clusters; x++) { |
1888 |
2/2✓ Branch 0 taken 809 times.
✓ Branch 1 taken 213 times.
|
1022 | if (!((cl_cbp >> (y*num_clusters + x)) & 1)) |
1889 | 809 | continue; | |
1890 | 213 | thread->coded_blk[cu_pos + y*2*8 + x*2 + 0] = 1; | |
1891 | 213 | thread->coded_blk[cu_pos + y*2*8 + x*2 + 1] = 1; | |
1892 | 213 | thread->coded_blk[cu_pos + y*2*8 + x*2 + 8] = 1; | |
1893 | 213 | thread->coded_blk[cu_pos + y*2*8 + x*2 + 9] = 1; | |
1894 | 213 | super_cbp = decode_cbp16(gb, subset, sel_qp); | |
1895 |
1/2✓ Branch 0 taken 213 times.
✗ Branch 1 not taken.
|
213 | if (super_cbp) { |
1896 | 213 | decode_cu_16x16(gb, is_intra, qp, sel_qp, y_coeffs, u_coeffs, v_coeffs, super_cbp); | |
1897 |
2/2✓ Branch 0 taken 171 times.
✓ Branch 1 taken 42 times.
|
213 | if (super_cbp & 0xFFFF) { |
1898 | 171 | int off = (ypos + y * 16) * frame->linesize[0] + xpos + x * 16; | |
1899 | 171 | ff_rv60_idct16x16_add(y_coeffs, frame->data[0] + off, frame->linesize[0]); | |
1900 | } | ||
1901 |
2/2✓ Branch 0 taken 162 times.
✓ Branch 1 taken 51 times.
|
213 | if ((super_cbp >> 16) & 0xF) { |
1902 | 162 | int off = ((ypos >> 1) + y * 8) * frame->linesize[1] + (xpos >> 1) + x * 8; | |
1903 | 162 | ff_rv60_idct8x8_add(u_coeffs, frame->data[1] + off, frame->linesize[1]); | |
1904 | } | ||
1905 |
2/2✓ Branch 0 taken 194 times.
✓ Branch 1 taken 19 times.
|
213 | if ((super_cbp >> 20) & 0xF) { |
1906 | 194 | int off = ((ypos >> 1) + y * 8) * frame->linesize[2] + (xpos >> 1) + x * 8; | |
1907 | 194 | ff_rv60_idct8x8_add(v_coeffs, frame->data[2] + off, frame->linesize[2]); | |
1908 | } | ||
1909 | } | ||
1910 | } | ||
1911 | } | ||
1912 | 938 | break; | |
1913 | } | ||
1914 | |||
1915 | 5112 | return 0; | |
1916 | } | ||
1917 | |||
1918 | 19711 | static int deblock_get_pos(RV60Context * s, int xpos, int ypos) | |
1919 | { | ||
1920 | 19711 | return (ypos >> 2) * s->dblk_stride + (xpos >> 2); | |
1921 | } | ||
1922 | |||
1923 | 7779 | static void deblock_set_strength(RV60Context * s, int xpos, int ypos, int size, int q, int strength) | |
1924 | { | ||
1925 | 7779 | int pos = deblock_get_pos(s, xpos, ypos); | |
1926 | 7779 | int dsize = size >> 2; | |
1927 | 7779 | int dval = (q << 2) + strength; | |
1928 | |||
1929 |
2/2✓ Branch 0 taken 23628 times.
✓ Branch 1 taken 7779 times.
|
31407 | for (int x = 0; x < dsize; x++) { |
1930 | 23628 | s->top_str[pos + x] = dval; | |
1931 | 23628 | s->top_str[pos + (dsize - 1)*s->dblk_stride + x] = dval; | |
1932 | } | ||
1933 | |||
1934 |
2/2✓ Branch 0 taken 23628 times.
✓ Branch 1 taken 7779 times.
|
31407 | for (int y = 0; y < dsize; y++) { |
1935 | 23628 | s->left_str[pos + y*s->dblk_stride] = dval; | |
1936 | 23628 | s->left_str[pos + y*s->dblk_stride + dsize - 1] = dval; | |
1937 | } | ||
1938 | 7779 | } | |
1939 | |||
1940 | 13514 | static int deblock_get_top_strength(const RV60Context * s, int pos) | |
1941 | { | ||
1942 | 13514 | return s->top_str[pos] & 3; | |
1943 | } | ||
1944 | |||
1945 | 13716 | static int deblock_get_left_strength(const RV60Context * s, int pos) | |
1946 | { | ||
1947 | 13716 | return s->left_str[pos] & 3; | |
1948 | } | ||
1949 | |||
1950 | 1770 | static void deblock_set_top_strength(RV60Context * s, int pos, int strength) | |
1951 | { | ||
1952 | 1770 | s->top_str[pos] |= strength; | |
1953 | 1770 | } | |
1954 | |||
1955 | 1216 | static void deblock_set_left_strength(RV60Context * s, int pos, int strength) | |
1956 | { | ||
1957 | 1216 | s->left_str[pos] |= strength; | |
1958 | 1216 | } | |
1959 | |||
1960 | 4153 | static void derive_deblock_strength(RV60Context * s, int xpos, int ypos, int size) | |
1961 | { | ||
1962 | 4153 | int blk_pos = (ypos >> 2) * s->blk_stride + (xpos >> 2); | |
1963 | 4153 | int dblk_pos = deblock_get_pos(s, xpos, ypos); | |
1964 |
2/2✓ Branch 0 taken 3850 times.
✓ Branch 1 taken 303 times.
|
4153 | if (ypos > 0) |
1965 |
2/2✓ Branch 0 taken 13514 times.
✓ Branch 1 taken 3850 times.
|
17364 | for (int i = 0; i < size; i++) |
1966 |
4/4✓ Branch 1 taken 11940 times.
✓ Branch 2 taken 1574 times.
✓ Branch 4 taken 1770 times.
✓ Branch 5 taken 10170 times.
|
13514 | if (!deblock_get_top_strength(s, dblk_pos - s->dblk_stride + i) && mvinfo_is_deblock_cand(&s->blk_info[blk_pos + i].mv, &s->blk_info[blk_pos - s->blk_stride + i].mv)) |
1967 | 1770 | deblock_set_top_strength(s, dblk_pos + i, 1); | |
1968 |
2/2✓ Branch 0 taken 3905 times.
✓ Branch 1 taken 248 times.
|
4153 | if (xpos > 0) |
1969 |
2/2✓ Branch 0 taken 13716 times.
✓ Branch 1 taken 3905 times.
|
17621 | for (int i = 0; i < size; i++) |
1970 |
4/4✓ Branch 1 taken 12512 times.
✓ Branch 2 taken 1204 times.
✓ Branch 4 taken 1216 times.
✓ Branch 5 taken 11296 times.
|
13716 | if (!deblock_get_left_strength(s, dblk_pos + i *s->dblk_stride - 1) && mvinfo_is_deblock_cand(&s->blk_info[blk_pos + i*s->blk_stride].mv, &s->blk_info[blk_pos + i*s->blk_stride - 1].mv)) |
1971 | 1216 | deblock_set_left_strength(s, dblk_pos + i *s->dblk_stride, 1); | |
1972 | 4153 | } | |
1973 | |||
1974 | #define STRENGTH(el, lim) (FFABS(el) < (lim) ? 3 : 1) | ||
1975 | #define CLIP_SYMM(a, b) av_clip(a, -(b), b) | ||
1976 | |||
1977 | 23366 | static void filter_luma_edge(uint8_t * dst, int step, int stride, int mode1, int mode2, int lim1, int lim2) | |
1978 | { | ||
1979 | int16_t diff_q1q0[4]; | ||
1980 | int16_t diff_p1p0[4]; | ||
1981 | int str_p, str_q, msum, maxprod, weak; | ||
1982 | |||
1983 |
2/2✓ Branch 0 taken 93464 times.
✓ Branch 1 taken 23366 times.
|
116830 | for (int i = 0; i < 4; i++) { |
1984 | 93464 | diff_q1q0[i] = dst[i * stride - 2*step] - dst[i*stride - step]; | |
1985 | 93464 | diff_p1p0[i] = dst[i * stride + step] - dst[i*stride]; | |
1986 | } | ||
1987 | |||
1988 |
2/2✓ Branch 0 taken 1247 times.
✓ Branch 1 taken 22119 times.
|
23366 | str_p = STRENGTH(diff_q1q0[0] + diff_q1q0[1] + diff_q1q0[2] + diff_q1q0[3], lim2); |
1989 |
2/2✓ Branch 0 taken 1293 times.
✓ Branch 1 taken 22073 times.
|
23366 | str_q = STRENGTH(diff_p1p0[0] + diff_p1p0[1] + diff_p1p0[2] + diff_p1p0[3], lim2); |
1990 | |||
1991 |
2/2✓ Branch 0 taken 22045 times.
✓ Branch 1 taken 1321 times.
|
23366 | if (str_p + str_q <= 2) |
1992 | 22045 | return; | |
1993 | |||
1994 | 1321 | msum = (mode1 + mode2 + str_q + str_p) >> 1; | |
1995 |
4/4✓ Branch 0 taken 1293 times.
✓ Branch 1 taken 28 times.
✓ Branch 2 taken 74 times.
✓ Branch 3 taken 1219 times.
|
1321 | if (str_q == 1 || str_p == 1) { |
1996 | 102 | maxprod = 384; | |
1997 | 102 | weak = 1; | |
1998 | } else { | ||
1999 | 1219 | maxprod = 256; | |
2000 | 1219 | weak = 0; | |
2001 | } | ||
2002 | |||
2003 |
2/2✓ Branch 0 taken 5284 times.
✓ Branch 1 taken 1321 times.
|
6605 | for (int y = 0; y < 4; y++) { |
2004 | 5284 | int diff_p0q0 = dst[0] - dst[-step]; | |
2005 | 5284 | int result = (lim1 * FFABS(diff_p0q0)) & -128; | |
2006 |
4/4✓ Branch 0 taken 3950 times.
✓ Branch 1 taken 1334 times.
✓ Branch 2 taken 2011 times.
✓ Branch 3 taken 1939 times.
|
5284 | if (diff_p0q0 && result <= maxprod) { |
2007 | 2011 | int diff_q1q2 = dst[-2*step] - dst[-3*step]; | |
2008 | 2011 | int diff_p1p2 = dst[step] - dst[2*step]; | |
2009 | int delta; | ||
2010 |
2/2✓ Branch 0 taken 126 times.
✓ Branch 1 taken 1885 times.
|
2011 | if (weak) { |
2011 | 126 | delta = CLIP_SYMM((diff_p0q0 + 1) >> 1, msum >> 1); | |
2012 | } else { | ||
2013 | 1885 | int diff_strg = (dst[-2*step] - dst[step] + 4 * diff_p0q0 + 4) >> 3; | |
2014 | 1885 | delta = CLIP_SYMM(diff_strg, msum); | |
2015 | } | ||
2016 | 2011 | dst[-step] = av_clip_uint8(dst[-step] + delta); | |
2017 | 2011 | dst[0] = av_clip_uint8(dst[0] - delta); | |
2018 |
4/4✓ Branch 0 taken 1915 times.
✓ Branch 1 taken 96 times.
✓ Branch 2 taken 1253 times.
✓ Branch 3 taken 662 times.
|
2011 | if (str_p != 1 && FFABS(diff_q1q2) <= (lim2 >> 2)) { |
2019 | 1253 | int diff = (diff_q1q0[y] + diff_q1q2 - delta) >> 1; | |
2020 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 1240 times.
|
1253 | int delta_q1 = weak ? CLIP_SYMM(diff, mode1 >> 1) : CLIP_SYMM(diff, mode1); |
2021 | 1253 | dst[-2 * step] = av_clip_uint8(dst[-2*step] - delta_q1); | |
2022 | } | ||
2023 |
4/4✓ Branch 0 taken 1981 times.
✓ Branch 1 taken 30 times.
✓ Branch 2 taken 1733 times.
✓ Branch 3 taken 248 times.
|
2011 | if (str_q != 1 && FFABS(diff_p1p2) <= (lim2 >> 2)) { |
2024 | 1733 | int diff = (diff_p1p0[y] + diff_p1p2 + delta) >> 1; | |
2025 |
2/2✓ Branch 0 taken 70 times.
✓ Branch 1 taken 1663 times.
|
1733 | int delta_p1 = weak ? CLIP_SYMM(diff, mode2 >> 1) : CLIP_SYMM(diff, mode2); |
2026 | 1733 | dst[step] = av_clip_uint8(dst[step] - delta_p1); | |
2027 | } | ||
2028 | } | ||
2029 | 5284 | dst += stride; | |
2030 | } | ||
2031 | } | ||
2032 | |||
2033 | 26792 | static void filter_chroma_edge(uint8_t * dst, int step, int stride, int mode1, int mode2, int lim1, int lim2) | |
2034 | { | ||
2035 | 26792 | int diff_q = 4 * FFABS(dst[-2*step] - dst[-step]); | |
2036 | 26792 | int diff_p = 4 * FFABS(dst[ step] - dst[0]); | |
2037 |
2/2✓ Branch 0 taken 148 times.
✓ Branch 1 taken 26644 times.
|
26792 | int str_q = STRENGTH(diff_q, lim2); |
2038 |
2/2✓ Branch 0 taken 201 times.
✓ Branch 1 taken 26591 times.
|
26792 | int str_p = STRENGTH(diff_p, lim2); |
2039 | int msum, maxprod, weak; | ||
2040 | |||
2041 |
2/2✓ Branch 0 taken 26545 times.
✓ Branch 1 taken 247 times.
|
26792 | if (str_p + str_q <= 2) |
2042 | 26545 | return; | |
2043 | |||
2044 | 247 | msum = (mode1 + mode2 + str_q + str_p) >> 1; | |
2045 |
4/4✓ Branch 0 taken 148 times.
✓ Branch 1 taken 99 times.
✓ Branch 2 taken 46 times.
✓ Branch 3 taken 102 times.
|
247 | if (str_q == 1 || str_p == 1) { |
2046 | 145 | maxprod = 384; | |
2047 | 145 | weak = 1; | |
2048 | } else { | ||
2049 | 102 | maxprod = 256; | |
2050 | 102 | weak = 0; | |
2051 | } | ||
2052 | |||
2053 |
2/2✓ Branch 0 taken 494 times.
✓ Branch 1 taken 247 times.
|
741 | for (int y = 0; y < 2; y++) { |
2054 | 494 | int diff_pq = dst[0] - dst[-step]; | |
2055 | 494 | int result = (lim1 * FFABS(diff_pq)) & -128; | |
2056 |
4/4✓ Branch 0 taken 417 times.
✓ Branch 1 taken 77 times.
✓ Branch 2 taken 195 times.
✓ Branch 3 taken 222 times.
|
494 | if (diff_pq && result <= maxprod) { |
2057 | int delta; | ||
2058 |
2/2✓ Branch 0 taken 111 times.
✓ Branch 1 taken 84 times.
|
195 | if (weak) { |
2059 | 111 | delta = CLIP_SYMM((diff_pq + 1) >> 1, msum >> 1); | |
2060 | } else { | ||
2061 | 84 | int diff_strg = (dst[-2*step] - dst[step] + 4 * diff_pq + 4) >> 3; | |
2062 | 84 | delta = CLIP_SYMM(diff_strg, msum); | |
2063 | } | ||
2064 | 195 | dst[-step] = av_clip_uint8(dst[-step] + delta); | |
2065 | 195 | dst[ 0 ] = av_clip_uint8(dst[ 0 ] - delta); | |
2066 | } | ||
2067 | 494 | dst += stride; | |
2068 | } | ||
2069 | } | ||
2070 | |||
2071 | 11120 | static void deblock_edge_ver(AVFrame * frame, int xpos, int ypos, int dblk_l, int dblk_r, int deblock_chroma) | |
2072 | { | ||
2073 | 11120 | int qp_l = dblk_l >> 2; | |
2074 | 11120 | int str_l = dblk_l & 3; | |
2075 | 11120 | int qp_r = dblk_r >> 2; | |
2076 | 11120 | int str_r = dblk_r & 3; | |
2077 | 11120 | const uint8_t * dl_l = rv60_deblock_limits[qp_l]; | |
2078 | 11120 | const uint8_t * dl_r = rv60_deblock_limits[qp_r]; | |
2079 |
2/2✓ Branch 0 taken 8758 times.
✓ Branch 1 taken 2362 times.
|
11120 | int mode_l = str_l ? dl_l[str_l - 1] : 0; |
2080 |
2/2✓ Branch 0 taken 9916 times.
✓ Branch 1 taken 1204 times.
|
11120 | int mode_r = str_r ? dl_r[str_r - 1] : 0; |
2081 | 11120 | int lim1 = dl_r[2]; | |
2082 | 11120 | int lim2 = dl_r[3] * 4; | |
2083 | |||
2084 | 11120 | filter_luma_edge(frame->data[0] + ypos * frame->linesize[0] + xpos, 1, frame->linesize[0], mode_l, mode_r, lim1, lim2); | |
2085 |
3/4✓ Branch 0 taken 6660 times.
✓ Branch 1 taken 4460 times.
✓ Branch 2 taken 6660 times.
✗ Branch 3 not taken.
|
11120 | if ((str_l | str_r) >= 2 && deblock_chroma) |
2086 |
2/2✓ Branch 0 taken 13320 times.
✓ Branch 1 taken 6660 times.
|
19980 | for (int plane = 1; plane < 3; plane++) |
2087 | 13320 | filter_chroma_edge(frame->data[plane] + (ypos >> 1) * frame->linesize[plane] + (xpos >> 1), 1, frame->linesize[plane], mode_l, mode_r, lim1, lim2); | |
2088 | 11120 | } | |
2089 | |||
2090 | 12246 | static void deblock_edge_hor(AVFrame * frame, int xpos, int ypos, int dblk_t, int dblk_d, int deblock_chroma) | |
2091 | { | ||
2092 | 12246 | int qp_t = dblk_t >> 2; | |
2093 | 12246 | int str_t = dblk_t & 3; | |
2094 | 12246 | int qp_d = dblk_d >> 2; | |
2095 | 12246 | int str_d = dblk_d & 3; | |
2096 | 12246 | const uint8_t * dl_t = rv60_deblock_limits[qp_t]; | |
2097 | 12246 | const uint8_t * dl_d = rv60_deblock_limits[qp_d]; | |
2098 |
2/2✓ Branch 0 taken 8902 times.
✓ Branch 1 taken 3344 times.
|
12246 | int mode_t = str_t ? dl_t[str_t - 1] : 0; |
2099 |
2/2✓ Branch 0 taken 10672 times.
✓ Branch 1 taken 1574 times.
|
12246 | int mode_d = str_d ? dl_d[str_d - 1] : 0; |
2100 | 12246 | int lim1 = dl_d[2]; | |
2101 | 12246 | int lim2 = dl_d[3] * 4; | |
2102 | |||
2103 | 12246 | filter_luma_edge(frame->data[0] + ypos * frame->linesize[0] + xpos, frame->linesize[0], 1, mode_t, mode_d, lim1, lim2); | |
2104 |
3/4✓ Branch 0 taken 6736 times.
✓ Branch 1 taken 5510 times.
✓ Branch 2 taken 6736 times.
✗ Branch 3 not taken.
|
12246 | if ((str_t | str_d) >= 2 && deblock_chroma) |
2105 |
2/2✓ Branch 0 taken 13472 times.
✓ Branch 1 taken 6736 times.
|
20208 | for (int plane = 1; plane < 3; plane++) |
2106 | 13472 | filter_chroma_edge(frame->data[plane] + (ypos >> 1) * frame->linesize[plane] + (xpos >> 1), frame->linesize[plane], 1, mode_t, mode_d, lim1, lim2); | |
2107 | 12246 | } | |
2108 | |||
2109 | 15849 | static void deblock8x8(const RV60Context * s, AVFrame * frame, int xpos, int ypos, int dblkpos) | |
2110 | { | ||
2111 |
2/2✓ Branch 0 taken 15243 times.
✓ Branch 1 taken 606 times.
|
15849 | if (xpos > 0) { |
2112 |
2/2✓ Branch 0 taken 14676 times.
✓ Branch 1 taken 567 times.
|
15243 | if (ypos > 0) { |
2113 | 14676 | int str_l = s->left_str[dblkpos - s->dblk_stride - 1]; | |
2114 | 14676 | int str_r = s->left_str[dblkpos - s->dblk_stride]; | |
2115 |
2/2✓ Branch 0 taken 5422 times.
✓ Branch 1 taken 9254 times.
|
14676 | if ((str_l | str_r) & 3) |
2116 | 5422 | deblock_edge_ver(frame, xpos, ypos - 4, str_l, str_r, s->deblock_chroma); | |
2117 | } | ||
2118 | { | ||
2119 | 15243 | int str_l = s->left_str[dblkpos - 1]; | |
2120 | 15243 | int str_r = s->left_str[dblkpos]; | |
2121 |
2/2✓ Branch 0 taken 5563 times.
✓ Branch 1 taken 9680 times.
|
15243 | if ((str_l | str_r) & 3) |
2122 | 5563 | deblock_edge_ver(frame, xpos, ypos, str_l, str_r, s->deblock_chroma); | |
2123 | } | ||
2124 |
2/2✓ Branch 0 taken 312 times.
✓ Branch 1 taken 14931 times.
|
15243 | if (ypos + 8 >= s->aheight) { |
2125 | 312 | int str_l = s->left_str[dblkpos + s->dblk_stride - 1]; | |
2126 | 312 | int str_r = s->left_str[dblkpos + s->dblk_stride]; | |
2127 |
2/2✓ Branch 0 taken 135 times.
✓ Branch 1 taken 177 times.
|
312 | if ((str_l | str_r) & 3) |
2128 | 135 | deblock_edge_ver(frame, xpos, ypos + 4, str_l, str_r, s->deblock_chroma); | |
2129 | } | ||
2130 | } | ||
2131 |
2/2✓ Branch 0 taken 15243 times.
✓ Branch 1 taken 606 times.
|
15849 | if (ypos > 0) { |
2132 |
2/2✓ Branch 0 taken 14676 times.
✓ Branch 1 taken 567 times.
|
15243 | if (xpos > 0) { |
2133 | 14676 | int str_t = s->top_str[dblkpos - s->dblk_stride - 1]; | |
2134 | 14676 | int str_d = s->top_str[dblkpos - 1]; | |
2135 |
2/2✓ Branch 0 taken 5906 times.
✓ Branch 1 taken 8770 times.
|
14676 | if ((str_t | str_d) & 3) |
2136 | 5906 | deblock_edge_hor(frame, xpos - 4, ypos, str_t, str_d, s->deblock_chroma); | |
2137 | } | ||
2138 | { | ||
2139 | 15243 | int str_t = s->top_str[dblkpos - s->dblk_stride]; | |
2140 | 15243 | int str_d = s->top_str[dblkpos]; | |
2141 |
2/2✓ Branch 0 taken 6120 times.
✓ Branch 1 taken 9123 times.
|
15243 | if ((str_t | str_d) & 3) |
2142 | 6120 | deblock_edge_hor(frame, xpos, ypos, str_t, str_d, s->deblock_chroma); | |
2143 | } | ||
2144 |
2/2✓ Branch 0 taken 345 times.
✓ Branch 1 taken 14898 times.
|
15243 | if (xpos + 8 >= s->awidth) { |
2145 | 345 | int str_t = s->top_str[dblkpos - s->dblk_stride + 1]; | |
2146 | 345 | int str_d = s->top_str[dblkpos + 1]; | |
2147 |
2/2✓ Branch 0 taken 220 times.
✓ Branch 1 taken 125 times.
|
345 | if ((str_t | str_d) & 3) |
2148 | 220 | deblock_edge_hor(frame, xpos + 4, ypos, str_t, str_d, s->deblock_chroma); | |
2149 | } | ||
2150 | } | ||
2151 | 15849 | } | |
2152 | |||
2153 | 7779 | static void deblock(const RV60Context * s, AVFrame * frame, int xpos, int ypos, int size, int dpos) | |
2154 | { | ||
2155 |
2/2✓ Branch 0 taken 11814 times.
✓ Branch 1 taken 7779 times.
|
19593 | for (int x = 0; x < size >> 3; x++) |
2156 | 11814 | deblock8x8(s, frame, xpos + x * 8, ypos, dpos + x * 2); | |
2157 | |||
2158 |
2/2✓ Branch 0 taken 4035 times.
✓ Branch 1 taken 7779 times.
|
11814 | for (int y = 1; y < size >> 3; y++) |
2159 | 4035 | deblock8x8(s, frame, xpos, ypos + y * 8, dpos + y * 2 * s->dblk_stride); | |
2160 | 7779 | } | |
2161 | |||
2162 | 7524 | static void deblock_cu_r(RV60Context * s, AVFrame * frame, ThreadContext * thread, int xpos, int ypos, int log_size, int qp) | |
2163 | { | ||
2164 | int pu_pos, tsize, ntiles; | ||
2165 | enum CUType cu_type; | ||
2166 | |||
2167 |
4/4✓ Branch 0 taken 7174 times.
✓ Branch 1 taken 350 times.
✓ Branch 2 taken 280 times.
✓ Branch 3 taken 6894 times.
|
7524 | if (xpos >= s->awidth || ypos >= s->aheight) |
2168 | 630 | return; | |
2169 | |||
2170 |
2/2✓ Branch 0 taken 1782 times.
✓ Branch 1 taken 5112 times.
|
6894 | if (thread->cu_split[thread->cu_split_pos++]) { |
2171 | 1782 | int hsize = 1 << (log_size - 1); | |
2172 | 1782 | log_size--; | |
2173 | 1782 | deblock_cu_r(s, frame, thread, xpos, ypos, log_size, qp); | |
2174 | 1782 | deblock_cu_r(s, frame, thread, xpos + hsize, ypos, log_size, qp); | |
2175 | 1782 | deblock_cu_r(s, frame, thread, xpos, ypos + hsize, log_size, qp); | |
2176 | 1782 | deblock_cu_r(s, frame, thread, xpos + hsize, ypos + hsize, log_size, qp); | |
2177 | 1782 | return; | |
2178 | } | ||
2179 | |||
2180 | 5112 | pu_pos = (ypos >> 3) * s->pu_stride + (xpos >> 3); | |
2181 | 5112 | cu_type = s->pu_info[pu_pos].cu_type; | |
2182 |
3/4✓ Branch 0 taken 3152 times.
✓ Branch 1 taken 1683 times.
✓ Branch 2 taken 277 times.
✗ Branch 3 not taken.
|
5112 | switch (log_size) { |
2183 | 3152 | case 3: tsize = 3; break; | |
2184 |
4/4✓ Branch 0 taken 870 times.
✓ Branch 1 taken 813 times.
✓ Branch 2 taken 148 times.
✓ Branch 3 taken 722 times.
|
1683 | case 4: tsize = cu_type && s->pu_info[pu_pos].pu_type ? 3 : 4; break; |
2185 | 277 | case 5: | |
2186 | 277 | case 6: tsize = 4; break; | |
2187 | } | ||
2188 | 5112 | ntiles = 1 << (log_size - tsize); | |
2189 | |||
2190 |
2/2✓ Branch 0 taken 5769 times.
✓ Branch 1 taken 5112 times.
|
10881 | for (int ty = 0; ty < ntiles; ty++) |
2191 |
2/2✓ Branch 0 taken 7779 times.
✓ Branch 1 taken 5769 times.
|
13548 | for (int tx = 0; tx < ntiles; tx++) { |
2192 | 7779 | int x = xpos + (tx << tsize); | |
2193 | 7779 | int y = ypos + (ty << tsize); | |
2194 | 7779 | int cu_pos = ((y & 63) >> 3) * 8 + ((x & 63) >> 3); | |
2195 | |||
2196 |
2/2✓ Branch 0 taken 2293 times.
✓ Branch 1 taken 5486 times.
|
7779 | if (cu_type == CU_INTRA) |
2197 | 2293 | deblock_set_strength(s, x, y, 1 << tsize, qp, 2); | |
2198 |
4/4✓ Branch 0 taken 1708 times.
✓ Branch 1 taken 3778 times.
✓ Branch 2 taken 1333 times.
✓ Branch 3 taken 375 times.
|
5486 | else if (cu_type != CU_SKIP && thread->coded_blk[cu_pos]) |
2199 | 1333 | deblock_set_strength(s, x, y, 1 << tsize, qp, 1); | |
2200 | else { | ||
2201 | 4153 | deblock_set_strength(s, x, y, 1 << tsize, qp, 0); | |
2202 | 4153 | derive_deblock_strength(s, x, y, 1 << (tsize - 2)); | |
2203 | } | ||
2204 | |||
2205 | 7779 | deblock(s, frame, x, y, 1 << tsize, deblock_get_pos(s, x, y)); | |
2206 | } | ||
2207 | } | ||
2208 | |||
2209 | 396 | static int read_qp_offset(GetBitContext *gb, int qp_off_type) | |
2210 | { | ||
2211 | int val; | ||
2212 | |||
2213 |
1/3✓ Branch 0 taken 396 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
|
396 | switch (qp_off_type) { |
2214 | 396 | case 0: | |
2215 | 396 | return 0; | |
2216 | ✗ | case 1: | |
2217 | ✗ | val = read_code012(gb); | |
2218 | ✗ | return val != 2 ? val : -1; | |
2219 | ✗ | default: | |
2220 | ✗ | if (!get_bits1(gb)) | |
2221 | ✗ | return 0; | |
2222 | ✗ | val = get_bits(gb, 2); | |
2223 | ✗ | if (!(val & 2)) | |
2224 | ✗ | return val + 1; | |
2225 | else | ||
2226 | ✗ | return -((val & 1) + 1); | |
2227 | } | ||
2228 | } | ||
2229 | |||
2230 | 396 | static int calc_sel_qp(int osvquant, int qp) | |
2231 | { | ||
2232 |
2/3✓ Branch 0 taken 140 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 256 times.
|
396 | switch (osvquant) { |
2233 | 140 | case 0: return qp; | |
2234 | ✗ | case 1: return qp <= 25 ? qp + 5 : qp; | |
2235 | 256 | default: | |
2236 |
1/2✓ Branch 0 taken 256 times.
✗ Branch 1 not taken.
|
256 | if (qp <= 18) |
2237 | 256 | return qp + 10; | |
2238 | ✗ | else if (qp <= 25) | |
2239 | ✗ | return qp + 5; | |
2240 | else | ||
2241 | ✗ | return qp; | |
2242 | } | ||
2243 | } | ||
2244 | |||
2245 | 102 | static int decode_slice(AVCodecContext *avctx, void *tdata, int cu_y, int threadnr) | |
2246 | { | ||
2247 | 102 | RV60Context *s = avctx->priv_data; | |
2248 | 102 | AVFrame * frame = tdata; | |
2249 | ThreadContext thread; | ||
2250 | GetBitContext gb; | ||
2251 | int qp, sel_qp, ret; | ||
2252 | |||
2253 | 102 | thread.avg_data[0] = thread.avg_buffer; | |
2254 | 102 | thread.avg_data[1] = thread.avg_buffer + 64*64; | |
2255 | 102 | thread.avg_data[2] = thread.avg_buffer + 64*64 + 32*32; | |
2256 | 102 | thread.avg_linesize[0] = 64; | |
2257 | 102 | thread.avg_linesize[1] = 32; | |
2258 | 102 | thread.avg_linesize[2] = 32; | |
2259 | |||
2260 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 102 times.
|
102 | if ((ret = init_get_bits8(&gb, s->slice[cu_y].data, s->slice[cu_y].data_size)) < 0) |
2261 | ✗ | return ret; | |
2262 | |||
2263 |
2/2✓ Branch 0 taken 396 times.
✓ Branch 1 taken 102 times.
|
498 | for (int cu_x = 0; cu_x < s->cu_width; cu_x++) { |
2264 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 396 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
396 | if ((s->avctx->active_thread_type & FF_THREAD_SLICE) && cu_y) |
2265 | ✗ | ff_thread_progress_await(&s->progress[cu_y - 1], cu_x + 2); | |
2266 | |||
2267 | 396 | qp = s->qp + read_qp_offset(&gb, s->qp_off_type); | |
2268 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 396 times.
|
396 | if (qp < 0) { |
2269 | ✗ | ret = AVERROR_INVALIDDATA; | |
2270 | ✗ | break; | |
2271 | } | ||
2272 | 396 | sel_qp = calc_sel_qp(s->osvquant, qp); | |
2273 | |||
2274 | 396 | memset(thread.coded_blk, 0, sizeof(thread.coded_blk)); | |
2275 | 396 | thread.cu_split_pos = 0; | |
2276 | |||
2277 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 396 times.
|
396 | if ((ret = decode_cu_r(s, frame, &thread, &gb, cu_x << 6, cu_y << 6, 6, qp, sel_qp)) < 0) |
2278 | ✗ | break; | |
2279 | |||
2280 |
1/2✓ Branch 0 taken 396 times.
✗ Branch 1 not taken.
|
396 | if (s->deblock) { |
2281 | 396 | thread.cu_split_pos = 0; | |
2282 | 396 | deblock_cu_r(s, frame, &thread, cu_x << 6, cu_y << 6, 6, qp); | |
2283 | } | ||
2284 | |||
2285 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 396 times.
|
396 | if (s->avctx->active_thread_type & FF_THREAD_SLICE) |
2286 | ✗ | ff_thread_progress_report(&s->progress[cu_y], cu_x + 1); | |
2287 | } | ||
2288 | |||
2289 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 102 times.
|
102 | if (s->avctx->active_thread_type & FF_THREAD_SLICE) |
2290 | ✗ | ff_thread_progress_report(&s->progress[cu_y], INT_MAX); | |
2291 | |||
2292 | 102 | return ret; | |
2293 | } | ||
2294 | |||
2295 | 43 | static int rv60_decode_frame(AVCodecContext *avctx, AVFrame * frame, | |
2296 | int * got_frame, AVPacket * avpkt) | ||
2297 | { | ||
2298 | 43 | RV60Context *s = avctx->priv_data; | |
2299 | GetBitContext gb; | ||
2300 | int ret, header_size, width, height, ofs; | ||
2301 | |||
2302 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 39 times.
|
43 | if (avpkt->size == 0) { |
2303 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 2 times.
|
4 | if (s->last_frame[NEXT_PIC]->data[0]) { |
2304 | 2 | av_frame_move_ref(frame, s->last_frame[NEXT_PIC]); | |
2305 | 2 | *got_frame = 1; | |
2306 | } | ||
2307 | 4 | return 0; | |
2308 | } | ||
2309 | |||
2310 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (avpkt->size < 9) |
2311 | ✗ | return AVERROR_INVALIDDATA; | |
2312 | |||
2313 | 39 | header_size = avpkt->data[0] * 8 + 9; | |
2314 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (avpkt->size < header_size) |
2315 | ✗ | return AVERROR_INVALIDDATA; | |
2316 | |||
2317 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = init_get_bits8(&gb, avpkt->data + header_size, avpkt->size - header_size)) < 0) |
2318 | ✗ | return ret; | |
2319 | |||
2320 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = read_frame_header(s, &gb, &width, &height)) < 0) |
2321 | ✗ | return ret; | |
2322 | |||
2323 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
39 | if (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B || |
2324 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
39 | avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I || |
2325 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | avctx->skip_frame >= AVDISCARD_ALL) |
2326 | ✗ | return avpkt->size; | |
2327 | |||
2328 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 24 times.
|
39 | if (s->pict_type != AV_PICTURE_TYPE_B) |
2329 | 15 | FFSWAP(AVFrame *, s->last_frame[NEXT_PIC], s->last_frame[LAST_PIC]); | |
2330 | |||
2331 |
3/4✓ Branch 0 taken 13 times.
✓ Branch 1 taken 26 times.
✓ Branch 2 taken 13 times.
✗ Branch 3 not taken.
|
39 | if ((s->pict_type == AV_PICTURE_TYPE_P && !s->last_frame[LAST_PIC]->data[0]) || |
2332 |
4/6✓ Branch 0 taken 24 times.
✓ Branch 1 taken 15 times.
✓ Branch 2 taken 24 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 24 times.
|
39 | (s->pict_type == AV_PICTURE_TYPE_B && (!s->last_frame[LAST_PIC]->data[0] || !s->last_frame[NEXT_PIC]->data[0]))) { |
2333 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "missing reference frame\n"); | |
2334 | ✗ | return AVERROR_INVALIDDATA; | |
2335 | } | ||
2336 | |||
2337 | 39 | s->last_frame[CUR_PIC]->pict_type = s->pict_type; | |
2338 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 37 times.
|
39 | if (s->pict_type == AV_PICTURE_TYPE_I) |
2339 | 2 | s->last_frame[CUR_PIC]->flags |= AV_FRAME_FLAG_KEY; | |
2340 | |||
2341 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = update_dimensions_clear_info(s, width, height)) < 0) |
2342 | ✗ | return ret; | |
2343 | |||
2344 |
1/2✓ Branch 0 taken 39 times.
✗ Branch 1 not taken.
|
39 | if (!s->last_frame[CUR_PIC]->data[0]) |
2345 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = ff_get_buffer(avctx, s->last_frame[CUR_PIC], 0)) < 0) |
2346 | ✗ | return ret; | |
2347 | |||
2348 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 39 times.
|
39 | if ((ret = read_slice_sizes(s, &gb)) < 0) |
2349 | ✗ | return ret; | |
2350 | |||
2351 | 39 | ofs = get_bits_count(&gb) / 8; | |
2352 | |||
2353 |
2/2✓ Branch 0 taken 102 times.
✓ Branch 1 taken 39 times.
|
141 | for (int i = 0; i < s->cu_height; i++) { |
2354 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 102 times.
|
102 | if (ofs >= avpkt->size - header_size) |
2355 | ✗ | return AVERROR_INVALIDDATA; | |
2356 | 102 | s->slice[i].data = avpkt->data + header_size + ofs; | |
2357 | 102 | s->slice[i].data_size = FFMIN(s->slice[i].size, avpkt->size - header_size - ofs); | |
2358 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 102 times.
|
102 | if (s->slice[i].size > INT32_MAX - ofs) |
2359 | ✗ | return AVERROR_INVALIDDATA; | |
2360 | 102 | ofs += s->slice[i].size; | |
2361 | } | ||
2362 | |||
2363 | 39 | ret = progress_init(s, s->cu_height); | |
2364 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (ret < 0) |
2365 | ✗ | return ret; | |
2366 | |||
2367 | 39 | s->avctx->execute2(s->avctx, decode_slice, s->last_frame[CUR_PIC], NULL, s->cu_height); | |
2368 | |||
2369 | 39 | ret = 0; | |
2370 |
2/2✓ Branch 0 taken 24 times.
✓ Branch 1 taken 15 times.
|
39 | if (s->pict_type == AV_PICTURE_TYPE_B) |
2371 | 24 | av_frame_move_ref(frame, s->last_frame[CUR_PIC]); | |
2372 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 2 times.
|
15 | else if (s->last_frame[LAST_PIC]->data[0]) |
2373 | 13 | ret = av_frame_ref(frame, s->last_frame[LAST_PIC]); | |
2374 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 39 times.
|
39 | if (ret < 0) |
2375 | ✗ | return ret; | |
2376 | |||
2377 |
2/2✓ Branch 0 taken 37 times.
✓ Branch 1 taken 2 times.
|
39 | if (frame->data[0]) |
2378 | 37 | *got_frame = 1; | |
2379 | |||
2380 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 24 times.
|
39 | if (s->pict_type != AV_PICTURE_TYPE_B) { |
2381 | 15 | av_frame_unref(s->last_frame[NEXT_PIC]); | |
2382 | 15 | FFSWAP(AVFrame *, s->last_frame[CUR_PIC], s->last_frame[NEXT_PIC]); | |
2383 | } | ||
2384 | |||
2385 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 24 times.
|
39 | if (s->pict_type != AV_PICTURE_TYPE_B) { |
2386 | 15 | s->ref_pts[0] = s->ref_pts[1]; | |
2387 | 15 | s->ref_pts[1] = avpkt->pts; | |
2388 | |||
2389 | 15 | s->ref_ts[0] = s->ref_ts[1]; | |
2390 | 15 | s->ref_ts[1] = s->ts; | |
2391 | |||
2392 |
3/4✓ Branch 0 taken 13 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 13 times.
✗ Branch 3 not taken.
|
15 | if (s->ref_pts[1] > s->ref_pts[0] && s->ref_ts[1] > s->ref_ts[0]) |
2393 | 13 | s->ts_scale = (s->ref_pts[1] - s->ref_pts[0]) / (s->ref_ts[1] - s->ref_ts[0]); | |
2394 | } else { | ||
2395 | 24 | frame->pts = s->ref_pts[0] + (s->ts - s->ref_ts[0]) * s->ts_scale; | |
2396 | } | ||
2397 | |||
2398 | 39 | return avpkt->size; | |
2399 | } | ||
2400 | |||
2401 | ✗ | static av_cold void rv60_flush(AVCodecContext *avctx) | |
2402 | { | ||
2403 | ✗ | RV60Context *s = avctx->priv_data; | |
2404 | |||
2405 | ✗ | for (int i = 0; i < 3; i++) | |
2406 | ✗ | av_frame_unref(s->last_frame[i]); | |
2407 | ✗ | } | |
2408 | |||
2409 | 4 | static av_cold int rv60_decode_end(AVCodecContext * avctx) | |
2410 | { | ||
2411 | 4 | RV60Context *s = avctx->priv_data; | |
2412 | |||
2413 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 4 times.
|
16 | for (int i = 0; i < 3; i++) |
2414 | 12 | av_frame_free(&s->last_frame[i]); | |
2415 | |||
2416 | 4 | av_freep(&s->slice); | |
2417 | 4 | av_freep(&s->pu_info); | |
2418 | 4 | av_freep(&s->blk_info); | |
2419 | 4 | av_freep(&s->top_str); | |
2420 | 4 | av_freep(&s->left_str); | |
2421 | |||
2422 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 4 times.
|
14 | for (int i = 0; i < s->nb_progress; i++) |
2423 | 10 | ff_thread_progress_destroy(&s->progress[i]); | |
2424 | 4 | av_freep(&s->progress); | |
2425 | |||
2426 | 4 | return 0; | |
2427 | } | ||
2428 | |||
2429 | const FFCodec ff_rv60_decoder = { | ||
2430 | .p.name = "rv60", | ||
2431 | CODEC_LONG_NAME("RealVideo 6.0"), | ||
2432 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
2433 | .p.id = AV_CODEC_ID_RV60, | ||
2434 | .priv_data_size = sizeof(RV60Context), | ||
2435 | .init = rv60_decode_init, | ||
2436 | .close = rv60_decode_end, | ||
2437 | FF_CODEC_DECODE_CB(rv60_decode_frame), | ||
2438 | .flush = rv60_flush, | ||
2439 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS, | ||
2440 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, | ||
2441 | }; | ||
2442 |