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 / MPEG4 part10 direct mb/block decoding. 25 * @author Michael Niedermayer <michaelni@gmx.at> 26 */ 27 28#include "internal.h" 29#include "dsputil.h" 30#include "avcodec.h" 31#include "mpegvideo.h" 32#include "h264.h" 33#include "rectangle.h" 34 35//#undef NDEBUG 36#include <assert.h> 37 38 39static int get_scale_factor(H264Context * const h, int poc, int poc1, int i){ 40 int poc0 = h->ref_list[0][i].poc; 41 int td = av_clip(poc1 - poc0, -128, 127); 42 if(td == 0 || h->ref_list[0][i].long_ref){ 43 return 256; 44 }else{ 45 int tb = av_clip(poc - poc0, -128, 127); 46 int tx = (16384 + (FFABS(td) >> 1)) / td; 47 return av_clip((tb*tx + 32) >> 6, -1024, 1023); 48 } 49} 50 51void ff_h264_direct_dist_scale_factor(H264Context * const h){ 52 MpegEncContext * const s = &h->s; 53 const int poc = h->s.current_picture_ptr->field_poc[ s->picture_structure == PICT_BOTTOM_FIELD ]; 54 const int poc1 = h->ref_list[1][0].poc; 55 int i, field; 56 for(field=0; field<2; field++){ 57 const int poc = h->s.current_picture_ptr->field_poc[field]; 58 const int poc1 = h->ref_list[1][0].field_poc[field]; 59 for(i=0; i < 2*h->ref_count[0]; i++) 60 h->dist_scale_factor_field[field][i^field] = get_scale_factor(h, poc, poc1, i+16); 61 } 62 63 for(i=0; i<h->ref_count[0]; i++){ 64 h->dist_scale_factor[i] = get_scale_factor(h, poc, poc1, i); 65 } 66} 67 68static void fill_colmap(H264Context *h, int map[2][16+32], int list, int field, int colfield, int mbafi){ 69 MpegEncContext * const s = &h->s; 70 Picture * const ref1 = &h->ref_list[1][0]; 71 int j, old_ref, rfield; 72 int start= mbafi ? 16 : 0; 73 int end = mbafi ? 16+2*h->ref_count[0] : h->ref_count[0]; 74 int interl= mbafi || s->picture_structure != PICT_FRAME; 75 76 /* bogus; fills in for missing frames */ 77 memset(map[list], 0, sizeof(map[list])); 78 79 for(rfield=0; rfield<2; rfield++){ 80 for(old_ref=0; old_ref<ref1->ref_count[colfield][list]; old_ref++){ 81 int poc = ref1->ref_poc[colfield][list][old_ref]; 82 83 if (!interl) 84 poc |= 3; 85 else if( interl && (poc&3) == 3) //FIXME store all MBAFF references so this isnt needed 86 poc= (poc&~3) + rfield + 1; 87 88 for(j=start; j<end; j++){ 89 if(4*h->ref_list[0][j].frame_num + (h->ref_list[0][j].reference&3) == poc){ 90 int cur_ref= mbafi ? (j-16)^field : j; 91 map[list][2*old_ref + (rfield^field) + 16] = cur_ref; 92 if(rfield == field || !interl) 93 map[list][old_ref] = cur_ref; 94 break; 95 } 96 } 97 } 98 } 99} 100 101void ff_h264_direct_ref_list_init(H264Context * const h){ 102 MpegEncContext * const s = &h->s; 103 Picture * const ref1 = &h->ref_list[1][0]; 104 Picture * const cur = s->current_picture_ptr; 105 int list, j, field; 106 int sidx= (s->picture_structure&1)^1; 107 int ref1sidx= (ref1->reference&1)^1; 108 109 for(list=0; list<2; list++){ 110 cur->ref_count[sidx][list] = h->ref_count[list]; 111 for(j=0; j<h->ref_count[list]; j++) 112 cur->ref_poc[sidx][list][j] = 4*h->ref_list[list][j].frame_num + (h->ref_list[list][j].reference&3); 113 } 114 115 if(s->picture_structure == PICT_FRAME){ 116 memcpy(cur->ref_count[1], cur->ref_count[0], sizeof(cur->ref_count[0])); 117 memcpy(cur->ref_poc [1], cur->ref_poc [0], sizeof(cur->ref_poc [0])); 118 } 119 120 cur->mbaff= FRAME_MBAFF; 121 122 h->col_fieldoff= 0; 123 if(s->picture_structure == PICT_FRAME){ 124 int cur_poc = s->current_picture_ptr->poc; 125 int *col_poc = h->ref_list[1]->field_poc; 126 h->col_parity= (FFABS(col_poc[0] - cur_poc) >= FFABS(col_poc[1] - cur_poc)); 127 ref1sidx=sidx= h->col_parity; 128 }else if(!(s->picture_structure & h->ref_list[1][0].reference) && !h->ref_list[1][0].mbaff){ // FL -> FL & differ parity 129 h->col_fieldoff= s->mb_stride*(2*(h->ref_list[1][0].reference) - 3); 130 } 131 132 if(cur->pict_type != FF_B_TYPE || h->direct_spatial_mv_pred) 133 return; 134 135 for(list=0; list<2; list++){ 136 fill_colmap(h, h->map_col_to_list0, list, sidx, ref1sidx, 0); 137 if(FRAME_MBAFF) 138 for(field=0; field<2; field++) 139 fill_colmap(h, h->map_col_to_list0_field[field], list, field, field, 1); 140 } 141} 142 143static void pred_spatial_direct_motion(H264Context * const h, int *mb_type){ 144 MpegEncContext * const s = &h->s; 145 int b8_stride = 2; 146 int b4_stride = h->b_stride; 147 int mb_xy = h->mb_xy; 148 int mb_type_col[2]; 149 const int16_t (*l1mv0)[2], (*l1mv1)[2]; 150 const int8_t *l1ref0, *l1ref1; 151 const int is_b8x8 = IS_8X8(*mb_type); 152 unsigned int sub_mb_type= MB_TYPE_L0L1; 153 int i8, i4; 154 int ref[2]; 155 int mv[2]; 156 int list; 157 158 assert(h->ref_list[1][0].reference&3); 159 160#define MB_TYPE_16x16_OR_INTRA (MB_TYPE_16x16|MB_TYPE_INTRA4x4|MB_TYPE_INTRA16x16|MB_TYPE_INTRA_PCM) 161 162 163 /* ref = min(neighbors) */ 164 for(list=0; list<2; list++){ 165 int left_ref = h->ref_cache[list][scan8[0] - 1]; 166 int top_ref = h->ref_cache[list][scan8[0] - 8]; 167 int refc = h->ref_cache[list][scan8[0] - 8 + 4]; 168 const int16_t *C= h->mv_cache[list][ scan8[0] - 8 + 4]; 169 if(refc == PART_NOT_AVAILABLE){ 170 refc = h->ref_cache[list][scan8[0] - 8 - 1]; 171 C = h-> mv_cache[list][scan8[0] - 8 - 1]; 172 } 173 ref[list] = FFMIN3((unsigned)left_ref, (unsigned)top_ref, (unsigned)refc); 174 if(ref[list] >= 0){ 175 //this is just pred_motion() but with the cases removed that cannot happen for direct blocks 176 const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ]; 177 const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ]; 178 179 int match_count= (left_ref==ref[list]) + (top_ref==ref[list]) + (refc==ref[list]); 180 if(match_count > 1){ //most common 181 mv[list]= pack16to32(mid_pred(A[0], B[0], C[0]), 182 mid_pred(A[1], B[1], C[1]) ); 183 }else { 184 assert(match_count==1); 185 if(left_ref==ref[list]){ 186 mv[list]= AV_RN32A(A); 187 }else if(top_ref==ref[list]){ 188 mv[list]= AV_RN32A(B); 189 }else{ 190 mv[list]= AV_RN32A(C); 191 } 192 } 193 }else{ 194 int mask= ~(MB_TYPE_L0 << (2*list)); 195 mv[list] = 0; 196 ref[list] = -1; 197 if(!is_b8x8) 198 *mb_type &= mask; 199 sub_mb_type &= mask; 200 } 201 } 202 if(ref[0] < 0 && ref[1] < 0){ 203 ref[0] = ref[1] = 0; 204 if(!is_b8x8) 205 *mb_type |= MB_TYPE_L0L1; 206 sub_mb_type |= MB_TYPE_L0L1; 207 } 208 209 if(!(is_b8x8|mv[0]|mv[1])){ 210 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1); 211 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1); 212 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, 0, 4); 213 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, 0, 4); 214 *mb_type= (*mb_type & ~(MB_TYPE_8x8|MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_P1L0|MB_TYPE_P1L1))|MB_TYPE_16x16|MB_TYPE_DIRECT2; 215 return; 216 } 217 218 if(IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])){ // AFL/AFR/FR/FL -> AFL/FL 219 if(!IS_INTERLACED(*mb_type)){ // AFR/FR -> AFL/FL 220 mb_xy= s->mb_x + ((s->mb_y&~1) + h->col_parity)*s->mb_stride; 221 b8_stride = 0; 222 }else{ 223 mb_xy += h->col_fieldoff; // non zero for FL -> FL & differ parity 224 } 225 goto single_col; 226 }else{ // AFL/AFR/FR/FL -> AFR/FR 227 if(IS_INTERLACED(*mb_type)){ // AFL /FL -> AFR/FR 228 mb_xy= s->mb_x + (s->mb_y&~1)*s->mb_stride; 229 mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy]; 230 mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + s->mb_stride]; 231 b8_stride = 2+4*s->mb_stride; 232 b4_stride *= 6; 233 234 sub_mb_type |= MB_TYPE_16x16|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ 235 if( (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA) 236 && (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA) 237 && !is_b8x8){ 238 *mb_type |= MB_TYPE_16x8 |MB_TYPE_DIRECT2; /* B_16x8 */ 239 }else{ 240 *mb_type |= MB_TYPE_8x8; 241 } 242 }else{ // AFR/FR -> AFR/FR 243single_col: 244 mb_type_col[0] = 245 mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy]; 246 247 sub_mb_type |= MB_TYPE_16x16|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ 248 if(!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)){ 249 *mb_type |= MB_TYPE_16x16|MB_TYPE_DIRECT2; /* B_16x16 */ 250 }else if(!is_b8x8 && (mb_type_col[0] & (MB_TYPE_16x8|MB_TYPE_8x16))){ 251 *mb_type |= MB_TYPE_DIRECT2 | (mb_type_col[0] & (MB_TYPE_16x8|MB_TYPE_8x16)); 252 }else{ 253 if(!h->sps.direct_8x8_inference_flag){ 254 /* FIXME save sub mb types from previous frames (or derive from MVs) 255 * so we know exactly what block size to use */ 256 sub_mb_type += (MB_TYPE_8x8-MB_TYPE_16x16); /* B_SUB_4x4 */ 257 } 258 *mb_type |= MB_TYPE_8x8; 259 } 260 } 261 } 262 263 l1mv0 = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]]; 264 l1mv1 = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]]; 265 l1ref0 = &h->ref_list[1][0].ref_index [0][4*mb_xy]; 266 l1ref1 = &h->ref_list[1][0].ref_index [1][4*mb_xy]; 267 if(!b8_stride){ 268 if(s->mb_y&1){ 269 l1ref0 += 2; 270 l1ref1 += 2; 271 l1mv0 += 2*b4_stride; 272 l1mv1 += 2*b4_stride; 273 } 274 } 275 276 277 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){ 278 int n=0; 279 for(i8=0; i8<4; i8++){ 280 int x8 = i8&1; 281 int y8 = i8>>1; 282 int xy8 = x8+y8*b8_stride; 283 int xy4 = 3*x8+y8*b4_stride; 284 int a,b; 285 286 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) 287 continue; 288 h->sub_mb_type[i8] = sub_mb_type; 289 290 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1); 291 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1); 292 if(!IS_INTRA(mb_type_col[y8]) && !h->ref_list[1][0].long_ref 293 && ( (l1ref0[xy8] == 0 && FFABS(l1mv0[xy4][0]) <= 1 && FFABS(l1mv0[xy4][1]) <= 1) 294 || (l1ref0[xy8] < 0 && l1ref1[xy8] == 0 && FFABS(l1mv1[xy4][0]) <= 1 && FFABS(l1mv1[xy4][1]) <= 1))){ 295 a=b=0; 296 if(ref[0] > 0) 297 a= mv[0]; 298 if(ref[1] > 0) 299 b= mv[1]; 300 n++; 301 }else{ 302 a= mv[0]; 303 b= mv[1]; 304 } 305 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, a, 4); 306 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, b, 4); 307 } 308 if(!is_b8x8 && !(n&3)) 309 *mb_type= (*mb_type & ~(MB_TYPE_8x8|MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_P1L0|MB_TYPE_P1L1))|MB_TYPE_16x16|MB_TYPE_DIRECT2; 310 }else if(IS_16X16(*mb_type)){ 311 int a,b; 312 313 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1); 314 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1); 315 if(!IS_INTRA(mb_type_col[0]) && !h->ref_list[1][0].long_ref 316 && ( (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1) 317 || (l1ref0[0] < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1 318 && h->x264_build>33U))){ 319 a=b=0; 320 if(ref[0] > 0) 321 a= mv[0]; 322 if(ref[1] > 0) 323 b= mv[1]; 324 }else{ 325 a= mv[0]; 326 b= mv[1]; 327 } 328 fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, a, 4); 329 fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, b, 4); 330 }else{ 331 int n=0; 332 for(i8=0; i8<4; i8++){ 333 const int x8 = i8&1; 334 const int y8 = i8>>1; 335 336 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) 337 continue; 338 h->sub_mb_type[i8] = sub_mb_type; 339 340 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, mv[0], 4); 341 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, mv[1], 4); 342 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[0], 1); 343 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, (uint8_t)ref[1], 1); 344 345 assert(b8_stride==2); 346 /* col_zero_flag */ 347 if(!IS_INTRA(mb_type_col[0]) && !h->ref_list[1][0].long_ref && ( l1ref0[i8] == 0 348 || (l1ref0[i8] < 0 && l1ref1[i8] == 0 349 && h->x264_build>33U))){ 350 const int16_t (*l1mv)[2]= l1ref0[i8] == 0 ? l1mv0 : l1mv1; 351 if(IS_SUB_8X8(sub_mb_type)){ 352 const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride]; 353 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ 354 if(ref[0] == 0) 355 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); 356 if(ref[1] == 0) 357 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); 358 n+=4; 359 } 360 }else{ 361 int m=0; 362 for(i4=0; i4<4; i4++){ 363 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride]; 364 if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){ 365 if(ref[0] == 0) 366 AV_ZERO32(h->mv_cache[0][scan8[i8*4+i4]]); 367 if(ref[1] == 0) 368 AV_ZERO32(h->mv_cache[1][scan8[i8*4+i4]]); 369 m++; 370 } 371 } 372 if(!(m&3)) 373 h->sub_mb_type[i8]+= MB_TYPE_16x16 - MB_TYPE_8x8; 374 n+=m; 375 } 376 } 377 } 378 if(!is_b8x8 && !(n&15)) 379 *mb_type= (*mb_type & ~(MB_TYPE_8x8|MB_TYPE_16x8|MB_TYPE_8x16|MB_TYPE_P1L0|MB_TYPE_P1L1))|MB_TYPE_16x16|MB_TYPE_DIRECT2; 380 } 381} 382 383static void pred_temp_direct_motion(H264Context * const h, int *mb_type){ 384 MpegEncContext * const s = &h->s; 385 int b8_stride = 2; 386 int b4_stride = h->b_stride; 387 int mb_xy = h->mb_xy; 388 int mb_type_col[2]; 389 const int16_t (*l1mv0)[2], (*l1mv1)[2]; 390 const int8_t *l1ref0, *l1ref1; 391 const int is_b8x8 = IS_8X8(*mb_type); 392 unsigned int sub_mb_type; 393 int i8, i4; 394 395 assert(h->ref_list[1][0].reference&3); 396 397 if(IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])){ // AFL/AFR/FR/FL -> AFL/FL 398 if(!IS_INTERLACED(*mb_type)){ // AFR/FR -> AFL/FL 399 mb_xy= s->mb_x + ((s->mb_y&~1) + h->col_parity)*s->mb_stride; 400 b8_stride = 0; 401 }else{ 402 mb_xy += h->col_fieldoff; // non zero for FL -> FL & differ parity 403 } 404 goto single_col; 405 }else{ // AFL/AFR/FR/FL -> AFR/FR 406 if(IS_INTERLACED(*mb_type)){ // AFL /FL -> AFR/FR 407 mb_xy= s->mb_x + (s->mb_y&~1)*s->mb_stride; 408 mb_type_col[0] = h->ref_list[1][0].mb_type[mb_xy]; 409 mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + s->mb_stride]; 410 b8_stride = 2+4*s->mb_stride; 411 b4_stride *= 6; 412 413 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ 414 415 if( (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA) 416 && (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA) 417 && !is_b8x8){ 418 *mb_type |= MB_TYPE_16x8 |MB_TYPE_L0L1|MB_TYPE_DIRECT2; /* B_16x8 */ 419 }else{ 420 *mb_type |= MB_TYPE_8x8|MB_TYPE_L0L1; 421 } 422 }else{ // AFR/FR -> AFR/FR 423single_col: 424 mb_type_col[0] = 425 mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy]; 426 427 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */ 428 if(!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)){ 429 *mb_type |= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */ 430 }else if(!is_b8x8 && (mb_type_col[0] & (MB_TYPE_16x8|MB_TYPE_8x16))){ 431 *mb_type |= MB_TYPE_L0L1|MB_TYPE_DIRECT2 | (mb_type_col[0] & (MB_TYPE_16x8|MB_TYPE_8x16)); 432 }else{ 433 if(!h->sps.direct_8x8_inference_flag){ 434 /* FIXME save sub mb types from previous frames (or derive from MVs) 435 * so we know exactly what block size to use */ 436 sub_mb_type = MB_TYPE_8x8|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_4x4 */ 437 } 438 *mb_type |= MB_TYPE_8x8|MB_TYPE_L0L1; 439 } 440 } 441 } 442 443 l1mv0 = &h->ref_list[1][0].motion_val[0][h->mb2b_xy [mb_xy]]; 444 l1mv1 = &h->ref_list[1][0].motion_val[1][h->mb2b_xy [mb_xy]]; 445 l1ref0 = &h->ref_list[1][0].ref_index [0][4*mb_xy]; 446 l1ref1 = &h->ref_list[1][0].ref_index [1][4*mb_xy]; 447 if(!b8_stride){ 448 if(s->mb_y&1){ 449 l1ref0 += 2; 450 l1ref1 += 2; 451 l1mv0 += 2*b4_stride; 452 l1mv1 += 2*b4_stride; 453 } 454 } 455 456 { 457 const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]}; 458 const int *dist_scale_factor = h->dist_scale_factor; 459 int ref_offset; 460 461 if(FRAME_MBAFF && IS_INTERLACED(*mb_type)){ 462 map_col_to_list0[0] = h->map_col_to_list0_field[s->mb_y&1][0]; 463 map_col_to_list0[1] = h->map_col_to_list0_field[s->mb_y&1][1]; 464 dist_scale_factor =h->dist_scale_factor_field[s->mb_y&1]; 465 } 466 ref_offset = (h->ref_list[1][0].mbaff<<4) & (mb_type_col[0]>>3); //if(h->ref_list[1][0].mbaff && IS_INTERLACED(mb_type_col[0])) ref_offset=16 else 0 467 468 if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){ 469 int y_shift = 2*!IS_INTERLACED(*mb_type); 470 assert(h->sps.direct_8x8_inference_flag); 471 472 for(i8=0; i8<4; i8++){ 473 const int x8 = i8&1; 474 const int y8 = i8>>1; 475 int ref0, scale; 476 const int16_t (*l1mv)[2]= l1mv0; 477 478 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) 479 continue; 480 h->sub_mb_type[i8] = sub_mb_type; 481 482 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); 483 if(IS_INTRA(mb_type_col[y8])){ 484 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); 485 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); 486 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); 487 continue; 488 } 489 490 ref0 = l1ref0[x8 + y8*b8_stride]; 491 if(ref0 >= 0) 492 ref0 = map_col_to_list0[0][ref0 + ref_offset]; 493 else{ 494 ref0 = map_col_to_list0[1][l1ref1[x8 + y8*b8_stride] + ref_offset]; 495 l1mv= l1mv1; 496 } 497 scale = dist_scale_factor[ref0]; 498 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); 499 500 { 501 const int16_t *mv_col = l1mv[x8*3 + y8*b4_stride]; 502 int my_col = (mv_col[1]<<y_shift)/2; 503 int mx = (scale * mv_col[0] + 128) >> 8; 504 int my = (scale * my_col + 128) >> 8; 505 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); 506 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-my_col), 4); 507 } 508 } 509 return; 510 } 511 512 /* one-to-one mv scaling */ 513 514 if(IS_16X16(*mb_type)){ 515 int ref, mv0, mv1; 516 517 fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, 0, 1); 518 if(IS_INTRA(mb_type_col[0])){ 519 ref=mv0=mv1=0; 520 }else{ 521 const int ref0 = l1ref0[0] >= 0 ? map_col_to_list0[0][l1ref0[0] + ref_offset] 522 : map_col_to_list0[1][l1ref1[0] + ref_offset]; 523 const int scale = dist_scale_factor[ref0]; 524 const int16_t *mv_col = l1ref0[0] >= 0 ? l1mv0[0] : l1mv1[0]; 525 int mv_l0[2]; 526 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; 527 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; 528 ref= ref0; 529 mv0= pack16to32(mv_l0[0],mv_l0[1]); 530 mv1= pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1]); 531 } 532 fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); 533 fill_rectangle(&h-> mv_cache[0][scan8[0]], 4, 4, 8, mv0, 4); 534 fill_rectangle(&h-> mv_cache[1][scan8[0]], 4, 4, 8, mv1, 4); 535 }else{ 536 for(i8=0; i8<4; i8++){ 537 const int x8 = i8&1; 538 const int y8 = i8>>1; 539 int ref0, scale; 540 const int16_t (*l1mv)[2]= l1mv0; 541 542 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8])) 543 continue; 544 h->sub_mb_type[i8] = sub_mb_type; 545 fill_rectangle(&h->ref_cache[1][scan8[i8*4]], 2, 2, 8, 0, 1); 546 if(IS_INTRA(mb_type_col[0])){ 547 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, 0, 1); 548 fill_rectangle(&h-> mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4); 549 fill_rectangle(&h-> mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4); 550 continue; 551 } 552 553 assert(b8_stride == 2); 554 ref0 = l1ref0[i8]; 555 if(ref0 >= 0) 556 ref0 = map_col_to_list0[0][ref0 + ref_offset]; 557 else{ 558 ref0 = map_col_to_list0[1][l1ref1[i8] + ref_offset]; 559 l1mv= l1mv1; 560 } 561 scale = dist_scale_factor[ref0]; 562 563 fill_rectangle(&h->ref_cache[0][scan8[i8*4]], 2, 2, 8, ref0, 1); 564 if(IS_SUB_8X8(sub_mb_type)){ 565 const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride]; 566 int mx = (scale * mv_col[0] + 128) >> 8; 567 int my = (scale * mv_col[1] + 128) >> 8; 568 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, pack16to32(mx,my), 4); 569 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, pack16to32(mx-mv_col[0],my-mv_col[1]), 4); 570 }else 571 for(i4=0; i4<4; i4++){ 572 const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride]; 573 int16_t *mv_l0 = h->mv_cache[0][scan8[i8*4+i4]]; 574 mv_l0[0] = (scale * mv_col[0] + 128) >> 8; 575 mv_l0[1] = (scale * mv_col[1] + 128) >> 8; 576 AV_WN32A(h->mv_cache[1][scan8[i8*4+i4]], 577 pack16to32(mv_l0[0]-mv_col[0],mv_l0[1]-mv_col[1])); 578 } 579 } 580 } 581 } 582} 583 584void ff_h264_pred_direct_motion(H264Context * const h, int *mb_type){ 585 if(h->direct_spatial_mv_pred){ 586 pred_spatial_direct_motion(h, mb_type); 587 }else{ 588 pred_temp_direct_motion(h, mb_type); 589 } 590} 591