summaryrefslogtreecommitdiff
path: root/libavcodec/h264_direct.c (plain)
blob: a7a107c8c216361c811b8d3aff28477c22d15074
1/*
2 * H.26L/H.264/AVC/JVT/14496-10/... direct mb/block decoding
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22/**
23 * @file
24 * H.264 / AVC / MPEG-4 part10 direct mb/block decoding.
25 * @author Michael Niedermayer <michaelni@gmx.at>
26 */
27
28#include "internal.h"
29#include "avcodec.h"
30#include "h264dec.h"
31#include "h264_ps.h"
32#include "mpegutils.h"
33#include "rectangle.h"
34#include "thread.h"
35
36#include <assert.h>
37
38static int get_scale_factor(H264SliceContext *sl,
39 int poc, int poc1, int i)
40{
41 int poc0 = sl->ref_list[0][i].poc;
42 int64_t pocdiff = poc1 - (int64_t)poc0;
43 int td = av_clip_int8(pocdiff);
44
45 if (pocdiff != (int)pocdiff)
46 avpriv_request_sample(sl->h264->avctx, "pocdiff overflow\n");
47
48 if (td == 0 || sl->ref_list[0][i].parent->long_ref) {
49 return 256;
50 } else {
51 int64_t pocdiff0 = poc - (int64_t)poc0;
52 int tb = av_clip_int8(pocdiff0);
53 int tx = (16384 + (FFABS(td) >> 1)) / td;
54
55 if (pocdiff0 != (int)pocdiff0)
56 av_log(sl->h264->avctx, AV_LOG_DEBUG, "pocdiff0 overflow\n");
57
58 return av_clip_intp2((tb * tx + 32) >> 6, 10);
59 }
60}
61
62void ff_h264_direct_dist_scale_factor(const H264Context *const h,
63 H264SliceContext *sl)
64{
65 const int poc = FIELD_PICTURE(h) ? h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD]
66 : h->cur_pic_ptr->poc;
67 const int poc1 = sl->ref_list[1][0].poc;
68 int i, field;
69
70 if (FRAME_MBAFF(h))
71 for (field = 0; field < 2; field++) {
72 const int poc = h->cur_pic_ptr->field_poc[field];
73 const int poc1 = sl->ref_list[1][0].parent->field_poc[field];
74 for (i = 0; i < 2 * sl->ref_count[0]; i++)
75 sl->dist_scale_factor_field[field][i ^ field] =
76 get_scale_factor(sl, poc, poc1, i + 16);
77 }
78
79 for (i = 0; i < sl->ref_count[0]; i++)
80 sl->dist_scale_factor[i] = get_scale_factor(sl, poc, poc1, i);
81}
82
83static void fill_colmap(const H264Context *h, H264SliceContext *sl,
84 int map[2][16 + 32], int list,
85 int field, int colfield, int mbafi)
86{
87 H264Picture *const ref1 = sl->ref_list[1][0].parent;
88 int j, old_ref, rfield;
89 int start = mbafi ? 16 : 0;
90 int end = mbafi ? 16 + 2 * sl->ref_count[0] : sl->ref_count[0];
91 int interl = mbafi || h->picture_structure != PICT_FRAME;
92
93 /* bogus; fills in for missing frames */
94 memset(map[list], 0, sizeof(map[list]));
95
96 for (rfield = 0; rfield < 2; rfield++) {
97 for (old_ref = 0; old_ref < ref1->ref_count[colfield][list]; old_ref++) {
98 int poc = ref1->ref_poc[colfield][list][old_ref];
99
100 if (!interl)
101 poc |= 3;
102 // FIXME: store all MBAFF references so this is not needed
103 else if (interl && (poc & 3) == 3)
104 poc = (poc & ~3) + rfield + 1;
105
106 for (j = start; j < end; j++) {
107 if (4 * sl->ref_list[0][j].parent->frame_num +
108 (sl->ref_list[0][j].reference & 3) == poc) {
109 int cur_ref = mbafi ? (j - 16) ^ field : j;
110 if (ref1->mbaff)
111 map[list][2 * old_ref + (rfield ^ field) + 16] = cur_ref;
112 if (rfield == field || !interl)
113 map[list][old_ref] = cur_ref;
114 break;
115 }
116 }
117 }
118 }
119}
120
121void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl)
122{
123 H264Ref *const ref1 = &sl->ref_list[1][0];
124 H264Picture *const cur = h->cur_pic_ptr;
125 int list, j, field;
126 int sidx = (h->picture_structure & 1) ^ 1;
127 int ref1sidx = (ref1->reference & 1) ^ 1;
128
129 for (list = 0; list < sl->list_count; list++) {
130 cur->ref_count[sidx][list] = sl->ref_count[list];
131 for (j = 0; j < sl->ref_count[list]; j++)
132 cur->ref_poc[sidx][list][j] = 4 * sl->ref_list[list][j].parent->frame_num +
133 (sl->ref_list[list][j].reference & 3);
134 }
135
136 if (h->picture_structure == PICT_FRAME) {
137 memcpy(cur->ref_count[1], cur->ref_count[0], sizeof(cur->ref_count[0]));
138 memcpy(cur->ref_poc[1], cur->ref_poc[0], sizeof(cur->ref_poc[0]));
139 }
140
141 if (h->current_slice == 0) {
142 cur->mbaff = FRAME_MBAFF(h);
143 } else {
144 av_assert0(cur->mbaff == FRAME_MBAFF(h));
145 }
146
147 sl->col_fieldoff = 0;
148
149 if (sl->list_count != 2 || !sl->ref_count[1])
150 return;
151
152 if (h->picture_structure == PICT_FRAME) {
153 int cur_poc = h->cur_pic_ptr->poc;
154 int *col_poc = sl->ref_list[1][0].parent->field_poc;
155 if (col_poc[0] == INT_MAX && col_poc[1] == INT_MAX) {
156 av_log(h->avctx, AV_LOG_ERROR, "co located POCs unavailable\n");
157 sl->col_parity = 1;
158 } else
159 sl->col_parity = (FFABS(col_poc[0] - cur_poc) >=
160 FFABS(col_poc[1] - cur_poc));
161 ref1sidx =
162 sidx = sl->col_parity;
163 // FL -> FL & differ parity
164 } else if (!(h->picture_structure & sl->ref_list[1][0].reference) &&
165 !sl->ref_list[1][0].parent->mbaff) {
166 sl->col_fieldoff = 2 * sl->ref_list[1][0].reference - 3;
167 }
168
169 if (sl->slice_type_nos != AV_PICTURE_TYPE_B || sl->direct_spatial_mv_pred)
170 return;
171
172 for (list = 0; list < 2; list++) {
173 fill_colmap(h, sl, sl->map_col_to_list0, list, sidx, ref1sidx, 0);
174 if (FRAME_MBAFF(h))
175 for (field = 0; field < 2; field++)
176 fill_colmap(h, sl, sl->map_col_to_list0_field[field], list, field,
177 field, 1);
178 }
179}
180
181static void await_reference_mb_row(const H264Context *const h, H264Ref *ref,
182 int mb_y)
183{
184 int ref_field = ref->reference - 1;
185 int ref_field_picture = ref->parent->field_picture;
186 int ref_height = 16 * h->mb_height >> ref_field_picture;
187
188 if (!HAVE_THREADS || !(h->avctx->active_thread_type & FF_THREAD_FRAME))
189 return;
190
191 /* FIXME: It can be safe to access mb stuff
192 * even if pixels aren't deblocked yet. */
193
194 ff_thread_await_progress(&ref->parent->tf,
195 FFMIN(16 * mb_y >> ref_field_picture,
196 ref_height - 1),
197 ref_field_picture && ref_field);
198}
199
200static void pred_spatial_direct_motion(const H264Context *const h, H264SliceContext *sl,
201 int *mb_type)
202{
203 int b8_stride = 2;
204 int b4_stride = h->b_stride;
205 int mb_xy = sl->mb_xy, mb_y = sl->mb_y;
206 int mb_type_col[2];
207 const int16_t (*l1mv0)[2], (*l1mv1)[2];
208 const int8_t *l1ref0, *l1ref1;
209 const int is_b8x8 = IS_8X8(*mb_type);
210 unsigned int sub_mb_type = MB_TYPE_L0L1;
211 int i8, i4;
212 int ref[2];
213 int mv[2];
214 int list;
215
216 assert(sl->ref_list[1][0].reference & 3);
217
218 await_reference_mb_row(h, &sl->ref_list[1][0],
219 sl->mb_y + !!IS_INTERLACED(*mb_type));
220
221#define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16 | MB_TYPE_INTRA4x4 | \
222 MB_TYPE_INTRA16x16 | MB_TYPE_INTRA_PCM)
223
224 /* ref = min(neighbors) */
225 for (list = 0; list < 2; list++) {
226 int left_ref = sl->ref_cache[list][scan8[0] - 1];
227 int top_ref = sl->ref_cache[list][scan8[0] - 8];
228 int refc = sl->ref_cache[list][scan8[0] - 8 + 4];
229 const int16_t *C = sl->mv_cache[list][scan8[0] - 8 + 4];
230 if (refc == PART_NOT_AVAILABLE) {
231 refc = sl->ref_cache[list][scan8[0] - 8 - 1];
232 C = sl->mv_cache[list][scan8[0] - 8 - 1];
233 }
234 ref[list] = FFMIN3((unsigned)left_ref,
235 (unsigned)top_ref,
236 (unsigned)refc);
237 if (ref[list] >= 0) {
238 /* This is just pred_motion() but with the cases removed that
239 * cannot happen for direct blocks. */
240 const int16_t *const A = sl->mv_cache[list][scan8[0] - 1];
241 const int16_t *const B = sl->mv_cache[list][scan8[0] - 8];
242
243 int match_count = (left_ref == ref[list]) +
244 (top_ref == ref[list]) +
245 (refc == ref[list]);
246
247 if (match_count > 1) { // most common
248 mv[list] = pack16to32(mid_pred(A[0], B[0], C[0]),
249 mid_pred(A[1], B[1], C[1]));
250 } else {
251 assert(match_count == 1);
252 if (left_ref == ref[list])
253 mv[list] = AV_RN32A(A);
254 else if (top_ref == ref[list])
255 mv[list] = AV_RN32A(B);
256 else
257 mv[list] = AV_RN32A(C);
258 }
259 av_assert2(ref[list] < (sl->ref_count[list] << !!FRAME_MBAFF(h)));
260 } else {
261 int mask = ~(MB_TYPE_L0 << (2 * list));
262 mv[list] = 0;
263 ref[list] = -1;
264 if (!is_b8x8)
265 *mb_type &= mask;
266 sub_mb_type &= mask;
267 }
268 }
269 if (ref[0] < 0 && ref[1] < 0) {
270 ref[0] = ref[1] = 0;
271 if (!is_b8x8)
272 *mb_type |= MB_TYPE_L0L1;
273 sub_mb_type |= MB_TYPE_L0L1;
274 }
275
276 if (!(is_b8x8 | mv[0] | mv[1])) {
277 fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
278 fill_rectangle(&sl->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
279 fill_rectangle(&sl->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4);
280 fill_rectangle(&sl->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4);
281 *mb_type = (*mb_type & ~(MB_TYPE_8x8 | MB_TYPE_16x8 | MB_TYPE_8x16 |
282 MB_TYPE_P1L0 | MB_TYPE_P1L1)) |
283 MB_TYPE_16x16 | MB_TYPE_DIRECT2;
284 return;
285 }
286
287 if (IS_INTERLACED(sl->ref_list[1][0].parent->mb_type[mb_xy])) { // AFL/AFR/FR/FL -> AFL/FL
288 if (!IS_INTERLACED(*mb_type)) { // AFR/FR -> AFL/FL
289 mb_y = (sl->mb_y & ~1) + sl->col_parity;
290 mb_xy = sl->mb_x +
291 ((sl->mb_y & ~1) + sl->col_parity) * h->mb_stride;
292 b8_stride = 0;
293 } else {
294 mb_y += sl->col_fieldoff;
295 mb_xy += h->mb_stride * sl->col_fieldoff; // non-zero for FL -> FL & differ parity
296 }
297 goto single_col;
298 } else { // AFL/AFR/FR/FL -> AFR/FR
299 if (IS_INTERLACED(*mb_type)) { // AFL /FL -> AFR/FR
300 mb_y = sl->mb_y & ~1;
301 mb_xy = (sl->mb_y & ~1) * h->mb_stride + sl->mb_x;
302 mb_type_col[0] = sl->ref_list[1][0].parent->mb_type[mb_xy];
303 mb_type_col[1] = sl->ref_list[1][0].parent->mb_type[mb_xy + h->mb_stride];
304 b8_stride = 2 + 4 * h->mb_stride;
305 b4_stride *= 6;
306 if (IS_INTERLACED(mb_type_col[0]) !=
307 IS_INTERLACED(mb_type_col[1])) {
308 mb_type_col[0] &= ~MB_TYPE_INTERLACED;
309 mb_type_col[1] &= ~MB_TYPE_INTERLACED;
310 }
311
312 sub_mb_type |= MB_TYPE_16x16 | MB_TYPE_DIRECT2; /* B_SUB_8x8 */
313 if ((mb_type_col[0] & MB_TYPE_16x16_OR_INTRA) &&
314 (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA) &&
315 !is_b8x8) {
316 *mb_type |= MB_TYPE_16x8 | MB_TYPE_DIRECT2; /* B_16x8 */
317 } else {
318 *mb_type |= MB_TYPE_8x8;
319 }
320 } else { // AFR/FR -> AFR/FR
321single_col:
322 mb_type_col[0] =
323 mb_type_col[1] = sl->ref_list[1][0].parent->mb_type[mb_xy];
324
325 sub_mb_type |= MB_TYPE_16x16 | MB_TYPE_DIRECT2; /* B_SUB_8x8 */
326 if (!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)) {
327 *mb_type |= MB_TYPE_16x16 | MB_TYPE_DIRECT2; /* B_16x16 */
328 } else if (!is_b8x8 &&
329 (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16))) {
330 *mb_type |= MB_TYPE_DIRECT2 |
331 (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16));
332 } else {
333 if (!h->ps.sps->direct_8x8_inference_flag) {
334 /* FIXME: Save sub mb types from previous frames (or derive
335 * from MVs) so we know exactly what block size to use. */
336 sub_mb_type += (MB_TYPE_8x8 - MB_TYPE_16x16); /* B_SUB_4x4 */
337 }
338 *mb_type |= MB_TYPE_8x8;
339 }
340 }
341 }
342
343 await_reference_mb_row(h, &sl->ref_list[1][0], mb_y);
344
345 l1mv0 = (void*)&sl->ref_list[1][0].parent->motion_val[0][h->mb2b_xy[mb_xy]];
346 l1mv1 = (void*)&sl->ref_list[1][0].parent->motion_val[1][h->mb2b_xy[mb_xy]];
347 l1ref0 = &sl->ref_list[1][0].parent->ref_index[0][4 * mb_xy];
348 l1ref1 = &sl->ref_list[1][0].parent->ref_index[1][4 * mb_xy];
349 if (!b8_stride) {
350 if (sl->mb_y & 1) {
351 l1ref0 += 2;
352 l1ref1 += 2;
353 l1mv0 += 2 * b4_stride;
354 l1mv1 += 2 * b4_stride;
355 }
356 }
357
358 if (IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])) {
359 int n = 0;
360 for (i8 = 0; i8 < 4; i8++) {
361 int x8 = i8 & 1;
362 int y8 = i8 >> 1;
363 int xy8 = x8 + y8 * b8_stride;
364 int xy4 = x8 * 3 + y8 * b4_stride;
365 int a, b;
366
367 if (is_b8x8 && !IS_DIRECT(sl->sub_mb_type[i8]))
368 continue;
369 sl->sub_mb_type[i8] = sub_mb_type;
370
371 fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8,
372 (uint8_t)ref[0], 1);
373 fill_rectangle(&sl->ref_cache[1][scan8[i8 * 4]], 2, 2, 8,
374 (uint8_t)ref[1], 1);
375 if (!IS_INTRA(mb_type_col[y8]) && !sl->ref_list[1][0].parent->long_ref &&
376 ((l1ref0[xy8] == 0 &&
377 FFABS(l1mv0[xy4][0]) <= 1 &&
378 FFABS(l1mv0[xy4][1]) <= 1) ||
379 (l1ref0[xy8] < 0 &&
380 l1ref1[xy8] == 0 &&
381 FFABS(l1mv1[xy4][0]) <= 1 &&
382 FFABS(l1mv1[xy4][1]) <= 1))) {
383 a =
384 b = 0;
385 if (ref[0] > 0)
386 a = mv[0];
387 if (ref[1] > 0)
388 b = mv[1];
389 n++;
390 } else {
391 a = mv[0];
392 b = mv[1];
393 }
394 fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8, a, 4);
395 fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8, b, 4);
396 }
397 if (!is_b8x8 && !(n & 3))
398 *mb_type = (*mb_type & ~(MB_TYPE_8x8 | MB_TYPE_16x8 | MB_TYPE_8x16 |
399 MB_TYPE_P1L0 | MB_TYPE_P1L1)) |
400 MB_TYPE_16x16 | MB_TYPE_DIRECT2;
401 } else if (IS_16X16(*mb_type)) {
402 int a, b;
403
404 fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
405 fill_rectangle(&sl->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
406 if (!IS_INTRA(mb_type_col[0]) && !sl->ref_list[1][0].parent->long_ref &&
407 ((l1ref0[0] == 0 &&
408 FFABS(l1mv0[0][0]) <= 1 &&
409 FFABS(l1mv0[0][1]) <= 1) ||
410 (l1ref0[0] < 0 && !l1ref1[0] &&
411 FFABS(l1mv1[0][0]) <= 1 &&
412 FFABS(l1mv1[0][1]) <= 1 &&
413 h->sei.unregistered.x264_build > 33U))) {
414 a = b = 0;
415 if (ref[0] > 0)
416 a = mv[0];
417 if (ref[1] > 0)
418 b = mv[1];
419 } else {
420 a = mv[0];
421 b = mv[1];
422 }
423 fill_rectangle(&sl->mv_cache[0][scan8[0]], 4, 4, 8, a, 4);
424 fill_rectangle(&sl->mv_cache[1][scan8[0]], 4, 4, 8, b, 4);
425 } else {
426 int n = 0;
427 for (i8 = 0; i8 < 4; i8++) {
428 const int x8 = i8 & 1;
429 const int y8 = i8 >> 1;
430
431 if (is_b8x8 && !IS_DIRECT(sl->sub_mb_type[i8]))
432 continue;
433 sl->sub_mb_type[i8] = sub_mb_type;
434
435 fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8, mv[0], 4);
436 fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8, mv[1], 4);
437 fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8,
438 (uint8_t)ref[0], 1);
439 fill_rectangle(&sl->ref_cache[1][scan8[i8 * 4]], 2, 2, 8,
440 (uint8_t)ref[1], 1);
441
442 assert(b8_stride == 2);
443 /* col_zero_flag */
444 if (!IS_INTRA(mb_type_col[0]) && !sl->ref_list[1][0].parent->long_ref &&
445 (l1ref0[i8] == 0 ||
446 (l1ref0[i8] < 0 &&
447 l1ref1[i8] == 0 &&
448 h->sei.unregistered.x264_build > 33U))) {
449 const int16_t (*l1mv)[2] = l1ref0[i8] == 0 ? l1mv0 : l1mv1;
450 if (IS_SUB_8X8(sub_mb_type)) {
451 const int16_t *mv_col = l1mv[x8 * 3 + y8 * 3 * b4_stride];
452 if (FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1) {
453 if (ref[0] == 0)
454 fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2,
455 8, 0, 4);
456 if (ref[1] == 0)
457 fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2,
458 8, 0, 4);
459 n += 4;
460 }
461 } else {
462 int m = 0;
463 for (i4 = 0; i4 < 4; i4++) {
464 const int16_t *mv_col = l1mv[x8 * 2 + (i4 & 1) +
465 (y8 * 2 + (i4 >> 1)) * b4_stride];
466 if (FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1) {
467 if (ref[0] == 0)
468 AV_ZERO32(sl->mv_cache[0][scan8[i8 * 4 + i4]]);
469 if (ref[1] == 0)
470 AV_ZERO32(sl->mv_cache[1][scan8[i8 * 4 + i4]]);
471 m++;
472 }
473 }
474 if (!(m & 3))
475 sl->sub_mb_type[i8] += MB_TYPE_16x16 - MB_TYPE_8x8;
476 n += m;
477 }
478 }
479 }
480 if (!is_b8x8 && !(n & 15))
481 *mb_type = (*mb_type & ~(MB_TYPE_8x8 | MB_TYPE_16x8 | MB_TYPE_8x16 |
482 MB_TYPE_P1L0 | MB_TYPE_P1L1)) |
483 MB_TYPE_16x16 | MB_TYPE_DIRECT2;
484 }
485}
486
487static void pred_temp_direct_motion(const H264Context *const h, H264SliceContext *sl,
488 int *mb_type)
489{
490 int b8_stride = 2;
491 int b4_stride = h->b_stride;
492 int mb_xy = sl->mb_xy, mb_y = sl->mb_y;
493 int mb_type_col[2];
494 const int16_t (*l1mv0)[2], (*l1mv1)[2];
495 const int8_t *l1ref0, *l1ref1;
496 const int is_b8x8 = IS_8X8(*mb_type);
497 unsigned int sub_mb_type;
498 int i8, i4;
499
500 assert(sl->ref_list[1][0].reference & 3);
501
502 await_reference_mb_row(h, &sl->ref_list[1][0],
503 sl->mb_y + !!IS_INTERLACED(*mb_type));
504
505 if (IS_INTERLACED(sl->ref_list[1][0].parent->mb_type[mb_xy])) { // AFL/AFR/FR/FL -> AFL/FL
506 if (!IS_INTERLACED(*mb_type)) { // AFR/FR -> AFL/FL
507 mb_y = (sl->mb_y & ~1) + sl->col_parity;
508 mb_xy = sl->mb_x +
509 ((sl->mb_y & ~1) + sl->col_parity) * h->mb_stride;
510 b8_stride = 0;
511 } else {
512 mb_y += sl->col_fieldoff;
513 mb_xy += h->mb_stride * sl->col_fieldoff; // non-zero for FL -> FL & differ parity
514 }
515 goto single_col;
516 } else { // AFL/AFR/FR/FL -> AFR/FR
517 if (IS_INTERLACED(*mb_type)) { // AFL /FL -> AFR/FR
518 mb_y = sl->mb_y & ~1;
519 mb_xy = sl->mb_x + (sl->mb_y & ~1) * h->mb_stride;
520 mb_type_col[0] = sl->ref_list[1][0].parent->mb_type[mb_xy];
521 mb_type_col[1] = sl->ref_list[1][0].parent->mb_type[mb_xy + h->mb_stride];
522 b8_stride = 2 + 4 * h->mb_stride;
523 b4_stride *= 6;
524 if (IS_INTERLACED(mb_type_col[0]) !=
525 IS_INTERLACED(mb_type_col[1])) {
526 mb_type_col[0] &= ~MB_TYPE_INTERLACED;
527 mb_type_col[1] &= ~MB_TYPE_INTERLACED;
528 }
529
530 sub_mb_type = MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
531 MB_TYPE_DIRECT2; /* B_SUB_8x8 */
532
533 if ((mb_type_col[0] & MB_TYPE_16x16_OR_INTRA) &&
534 (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA) &&
535 !is_b8x8) {
536 *mb_type |= MB_TYPE_16x8 | MB_TYPE_L0L1 |
537 MB_TYPE_DIRECT2; /* B_16x8 */
538 } else {
539 *mb_type |= MB_TYPE_8x8 | MB_TYPE_L0L1;
540 }
541 } else { // AFR/FR -> AFR/FR
542single_col:
543 mb_type_col[0] =
544 mb_type_col[1] = sl->ref_list[1][0].parent->mb_type[mb_xy];
545
546 sub_mb_type = MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
547 MB_TYPE_DIRECT2; /* B_SUB_8x8 */
548 if (!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)) {
549 *mb_type |= MB_TYPE_16x16 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
550 MB_TYPE_DIRECT2; /* B_16x16 */
551 } else if (!is_b8x8 &&
552 (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16))) {
553 *mb_type |= MB_TYPE_L0L1 | MB_TYPE_DIRECT2 |
554 (mb_type_col[0] & (MB_TYPE_16x8 | MB_TYPE_8x16));
555 } else {
556 if (!h->ps.sps->direct_8x8_inference_flag) {
557 /* FIXME: save sub mb types from previous frames (or derive
558 * from MVs) so we know exactly what block size to use */
559 sub_mb_type = MB_TYPE_8x8 | MB_TYPE_P0L0 | MB_TYPE_P0L1 |
560 MB_TYPE_DIRECT2; /* B_SUB_4x4 */
561 }
562 *mb_type |= MB_TYPE_8x8 | MB_TYPE_L0L1;
563 }
564 }
565 }
566
567 await_reference_mb_row(h, &sl->ref_list[1][0], mb_y);
568
569 l1mv0 = (void*)&sl->ref_list[1][0].parent->motion_val[0][h->mb2b_xy[mb_xy]];
570 l1mv1 = (void*)&sl->ref_list[1][0].parent->motion_val[1][h->mb2b_xy[mb_xy]];
571 l1ref0 = &sl->ref_list[1][0].parent->ref_index[0][4 * mb_xy];
572 l1ref1 = &sl->ref_list[1][0].parent->ref_index[1][4 * mb_xy];
573 if (!b8_stride) {
574 if (sl->mb_y & 1) {
575 l1ref0 += 2;
576 l1ref1 += 2;
577 l1mv0 += 2 * b4_stride;
578 l1mv1 += 2 * b4_stride;
579 }
580 }
581
582 {
583 const int *map_col_to_list0[2] = { sl->map_col_to_list0[0],
584 sl->map_col_to_list0[1] };
585 const int *dist_scale_factor = sl->dist_scale_factor;
586 int ref_offset;
587
588 if (FRAME_MBAFF(h) && IS_INTERLACED(*mb_type)) {
589 map_col_to_list0[0] = sl->map_col_to_list0_field[sl->mb_y & 1][0];
590 map_col_to_list0[1] = sl->map_col_to_list0_field[sl->mb_y & 1][1];
591 dist_scale_factor = sl->dist_scale_factor_field[sl->mb_y & 1];
592 }
593 ref_offset = (sl->ref_list[1][0].parent->mbaff << 4) & (mb_type_col[0] >> 3);
594
595 if (IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])) {
596 int y_shift = 2 * !IS_INTERLACED(*mb_type);
597 assert(h->ps.sps->direct_8x8_inference_flag);
598
599 for (i8 = 0; i8 < 4; i8++) {
600 const int x8 = i8 & 1;
601 const int y8 = i8 >> 1;
602 int ref0, scale;
603 const int16_t (*l1mv)[2] = l1mv0;
604
605 if (is_b8x8 && !IS_DIRECT(sl->sub_mb_type[i8]))
606 continue;
607 sl->sub_mb_type[i8] = sub_mb_type;
608
609 fill_rectangle(&sl->ref_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 1);
610 if (IS_INTRA(mb_type_col[y8])) {
611 fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 1);
612 fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 4);
613 fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 4);
614 continue;
615 }
616
617 ref0 = l1ref0[x8 + y8 * b8_stride];
618 if (ref0 >= 0)
619 ref0 = map_col_to_list0[0][ref0 + ref_offset];
620 else {
621 ref0 = map_col_to_list0[1][l1ref1[x8 + y8 * b8_stride] +
622 ref_offset];
623 l1mv = l1mv1;
624 }
625 scale = dist_scale_factor[ref0];
626 fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8,
627 ref0, 1);
628
629 {
630 const int16_t *mv_col = l1mv[x8 * 3 + y8 * b4_stride];
631 int my_col = (mv_col[1] * (1 << y_shift)) / 2;
632 int mx = (scale * mv_col[0] + 128) >> 8;
633 int my = (scale * my_col + 128) >> 8;
634 fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8,
635 pack16to32(mx, my), 4);
636 fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8,
637 pack16to32(mx - mv_col[0], my - my_col), 4);
638 }
639 }
640 return;
641 }
642
643 /* one-to-one mv scaling */
644
645 if (IS_16X16(*mb_type)) {
646 int ref, mv0, mv1;
647
648 fill_rectangle(&sl->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1);
649 if (IS_INTRA(mb_type_col[0])) {
650 ref = mv0 = mv1 = 0;
651 } else {
652 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0] + ref_offset]
653 : map_col_to_list0[1][l1ref1[0] + ref_offset];
654 const int scale = dist_scale_factor[ref0];
655 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0];
656 int mv_l0[2];
657 mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
658 mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
659 ref = ref0;
660 mv0 = pack16to32(mv_l0[0], mv_l0[1]);
661 mv1 = pack16to32(mv_l0[0] - mv_col[0], mv_l0[1] - mv_col[1]);
662 }
663 fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
664 fill_rectangle(&sl->mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4);
665 fill_rectangle(&sl->mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4);
666 } else {
667 for (i8 = 0; i8 < 4; i8++) {
668 const int x8 = i8 & 1;
669 const int y8 = i8 >> 1;
670 int ref0, scale;
671 const int16_t (*l1mv)[2] = l1mv0;
672
673 if (is_b8x8 && !IS_DIRECT(sl->sub_mb_type[i8]))
674 continue;
675 sl->sub_mb_type[i8] = sub_mb_type;
676 fill_rectangle(&sl->ref_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 1);
677 if (IS_INTRA(mb_type_col[0])) {
678 fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 1);
679 fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8, 0, 4);
680 fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8, 0, 4);
681 continue;
682 }
683
684 assert(b8_stride == 2);
685 ref0 = l1ref0[i8];
686 if (ref0 >= 0)
687 ref0 = map_col_to_list0[0][ref0 + ref_offset];
688 else {
689 ref0 = map_col_to_list0[1][l1ref1[i8] + ref_offset];
690 l1mv = l1mv1;
691 }
692 scale = dist_scale_factor[ref0];
693
694 fill_rectangle(&sl->ref_cache[0][scan8[i8 * 4]], 2, 2, 8,
695 ref0, 1);
696 if (IS_SUB_8X8(sub_mb_type)) {
697 const int16_t *mv_col = l1mv[x8 * 3 + y8 * 3 * b4_stride];
698 int mx = (scale * mv_col[0] + 128) >> 8;
699 int my = (scale * mv_col[1] + 128) >> 8;
700 fill_rectangle(&sl->mv_cache[0][scan8[i8 * 4]], 2, 2, 8,
701 pack16to32(mx, my), 4);
702 fill_rectangle(&sl->mv_cache[1][scan8[i8 * 4]], 2, 2, 8,
703 pack16to32(mx - mv_col[0], my - mv_col[1]), 4);
704 } else {
705 for (i4 = 0; i4 < 4; i4++) {
706 const int16_t *mv_col = l1mv[x8 * 2 + (i4 & 1) +
707 (y8 * 2 + (i4 >> 1)) * b4_stride];
708 int16_t *mv_l0 = sl->mv_cache[0][scan8[i8 * 4 + i4]];
709 mv_l0[0] = (scale * mv_col[0] + 128) >> 8;
710 mv_l0[1] = (scale * mv_col[1] + 128) >> 8;
711 AV_WN32A(sl->mv_cache[1][scan8[i8 * 4 + i4]],
712 pack16to32(mv_l0[0] - mv_col[0],
713 mv_l0[1] - mv_col[1]));
714 }
715 }
716 }
717 }
718 }
719}
720
721void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl,
722 int *mb_type)
723{
724 if (sl->direct_spatial_mv_pred)
725 pred_spatial_direct_motion(h, sl, mb_type);
726 else
727 pred_temp_direct_motion(h, sl, mb_type);
728}
729
generated by cgit at 2024-05-17 03:17:45 (GMT)