Detect spatial direct MBs partitioned smaller than 16x16 that can be partitioned
[ffmpeg.git] / libavcodec / h264_direct.c
index 65fbd23..a2f1e1d 100644 (file)
@@ -30,7 +30,6 @@
 #include "avcodec.h"
 #include "mpegvideo.h"
 #include "h264.h"
-#include "h264_mvpred.h"
 #include "rectangle.h"
 
 //#undef NDEBUG
@@ -120,17 +119,22 @@ void ff_h264_direct_ref_list_init(H264Context * const h){
 
     cur->mbaff= FRAME_MBAFF;
 
-    if(cur->pict_type != FF_B_TYPE || h->direct_spatial_mv_pred)
-        return;
-
+    h->col_fieldoff= 0;
     if(s->picture_structure == PICT_FRAME){
         int cur_poc = s->current_picture_ptr->poc;
         int *col_poc = h->ref_list[1]->field_poc;
-        ref1sidx=sidx= (FFABS(col_poc[0] - cur_poc) >= FFABS(col_poc[1] - cur_poc));
+        h->col_parity= (FFABS(col_poc[0] - cur_poc) >= FFABS(col_poc[1] - cur_poc));
+        ref1sidx=sidx= h->col_parity;
+    }else if(!(s->picture_structure & h->ref_list[1][0].reference) && !h->ref_list[1][0].mbaff){ // FL -> FL & differ parity
+        h->col_fieldoff= s->mb_stride*(2*(h->ref_list[1][0].reference) - 3);
     }
 
+    if(cur->pict_type != FF_B_TYPE || h->direct_spatial_mv_pred)
+        return;
+
     for(list=0; list<2; list++){
         fill_colmap(h, h->map_col_to_list0, list, sidx, ref1sidx, 0);
+        if(FRAME_MBAFF)
         for(field=0; field<2; field++)
             fill_colmap(h, h->map_col_to_list0_field[field], list, field, field, 1);
     }
@@ -154,14 +158,10 @@ void ff_h264_pred_direct_motion(H264Context * const h, int *mb_type){
 
     if(IS_INTERLACED(h->ref_list[1][0].mb_type[mb_xy])){ // AFL/AFR/FR/FL -> AFL/FL
         if(!IS_INTERLACED(*mb_type)){                    //     AFR/FR    -> AFL/FL
-            int cur_poc = s->current_picture_ptr->poc;
-            int *col_poc = h->ref_list[1]->field_poc;
-            int col_parity = FFABS(col_poc[0] - cur_poc) >= FFABS(col_poc[1] - cur_poc);
-            mb_xy= s->mb_x + ((s->mb_y&~1) + col_parity)*s->mb_stride;
+            mb_xy= s->mb_x + ((s->mb_y&~1) + h->col_parity)*s->mb_stride;
             b8_stride = 0;
-        }else if(!(s->picture_structure & h->ref_list[1][0].reference) && !h->ref_list[1][0].mbaff){// FL -> FL & differ parity
-            int fieldoff= 2*(h->ref_list[1][0].reference)-3;
-            mb_xy += s->mb_stride*fieldoff;
+        }else{
+            mb_xy += h->col_fieldoff; // non zero for FL -> FL & differ parity
         }
         goto single_col;
     }else{                                               // AFL/AFR/FR/FL -> AFR/FR
@@ -171,14 +171,13 @@ void ff_h264_pred_direct_motion(H264Context * const h, int *mb_type){
             mb_type_col[1] = h->ref_list[1][0].mb_type[mb_xy + s->mb_stride];
             b8_stride *= 3;
             b4_stride *= 6;
-            //FIXME IS_8X8(mb_type_col[0]) && !h->sps.direct_8x8_inference_flag
+
+            sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
             if(    (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)
                 && (mb_type_col[1] & MB_TYPE_16x16_OR_INTRA)
                 && !is_b8x8){
-                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
                 *mb_type   |= MB_TYPE_16x8 |MB_TYPE_L0L1|MB_TYPE_DIRECT2; /* B_16x8 */
             }else{
-                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
                 *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;
             }
         }else{                                           //     AFR/FR    -> AFR/FR
@@ -193,6 +192,9 @@ single_col:
             }else if(!is_b8x8 && (mb_type_col[0] & MB_TYPE_16x16_OR_INTRA)){
                 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
                 *mb_type   |= MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_16x16 */
+            }else if(!is_b8x8 && (mb_type_col[0] & (MB_TYPE_16x8|MB_TYPE_8x16))){
+                sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
+                *mb_type   |= MB_TYPE_L0L1|MB_TYPE_DIRECT2 | (mb_type_col[0] & (MB_TYPE_16x8|MB_TYPE_8x16));
             }else{
                 sub_mb_type = MB_TYPE_16x16|MB_TYPE_P0L0|MB_TYPE_P0L1|MB_TYPE_DIRECT2; /* B_SUB_8x8 */
                 *mb_type   |= MB_TYPE_8x8|MB_TYPE_L0L1;
@@ -218,41 +220,53 @@ single_col:
         int mv[2][2];
         int list;
 
-        /* FIXME interlacing + spatial direct uses wrong colocated block positions */
-
         /* ref = min(neighbors) */
         for(list=0; list<2; list++){
-            int refa = h->ref_cache[list][scan8[0] - 1];
-            int refb = h->ref_cache[list][scan8[0] - 8];
+            int left_ref = h->ref_cache[list][scan8[0] - 1];
+            int top_ref  = h->ref_cache[list][scan8[0] - 8];
             int refc = h->ref_cache[list][scan8[0] - 8 + 4];
-            if(refc == PART_NOT_AVAILABLE)
+            const int16_t *C= h->mv_cache[list][ scan8[0] - 8 + 4];
+            if(refc == PART_NOT_AVAILABLE){
                 refc = h->ref_cache[list][scan8[0] - 8 - 1];
-            ref[list] = FFMIN3((unsigned)refa, (unsigned)refb, (unsigned)refc);
-            if(ref[list] < 0)
+                C    = h-> mv_cache[list][scan8[0] - 8 - 1];
+            }
+            ref[list] = FFMIN3((unsigned)left_ref, (unsigned)top_ref, (unsigned)refc);
+            if(ref[list] >= 0){
+                //this is just pred_motion() but with the cases removed that cannot happen for direct blocks
+                const int16_t * const A= h->mv_cache[list][ scan8[0] - 1 ];
+                const int16_t * const B= h->mv_cache[list][ scan8[0] - 8 ];
+
+                int match_count= (left_ref==ref[list]) + (top_ref==ref[list]) + (refc==ref[list]);
+                if(match_count > 1){ //most common
+                    mv[list][0]= mid_pred(A[0], B[0], C[0]);
+                    mv[list][1]= mid_pred(A[1], B[1], C[1]);
+                }else {
+                    assert(match_count==1);
+                    if(left_ref==ref[list]){
+                        mv[list][0]= A[0];
+                        mv[list][1]= A[1];
+                    }else if(top_ref==ref[list]){
+                        mv[list][0]= B[0];
+                        mv[list][1]= B[1];
+                    }else{
+                        mv[list][0]= C[0];
+                        mv[list][1]= C[1];
+                    }
+                }
+            }else{
+                int mask= ~(MB_TYPE_L0 << (2*list));
+                mv[list][0] = mv[list][1] = 0;
                 ref[list] = -1;
+                if(!is_b8x8)
+                    *mb_type &= mask;
+                sub_mb_type &= mask;
+            }
         }
-
         if(ref[0] < 0 && ref[1] < 0){
             ref[0] = ref[1] = 0;
-            mv[0][0] = mv[0][1] =
-            mv[1][0] = mv[1][1] = 0;
-        }else{
-            for(list=0; list<2; list++){
-                if(ref[list] >= 0)
-                    pred_motion(h, 0, 4, list, ref[list], &mv[list][0], &mv[list][1]);
-                else
-                    mv[list][0] = mv[list][1] = 0;
-            }
-        }
-
-        if(ref[1] < 0){
-            if(!is_b8x8)
-                *mb_type &= ~MB_TYPE_L1;
-            sub_mb_type &= ~MB_TYPE_L1;
-        }else if(ref[0] < 0){
             if(!is_b8x8)
-                *mb_type &= ~MB_TYPE_L0;
-            sub_mb_type &= ~MB_TYPE_L0;
+                *mb_type |= MB_TYPE_L0L1;
+            sub_mb_type |= MB_TYPE_L0L1;
         }
 
         if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){
@@ -261,7 +275,7 @@ single_col:
                 int y8 = i8>>1;
                 int xy8 = x8+y8*b8_stride;
                 int xy4 = 3*x8+y8*b4_stride;
-                int a=0, b=0;
+                int a,b;
 
                 if(is_b8x8 && !IS_DIRECT(h->sub_mb_type[i8]))
                     continue;
@@ -272,6 +286,7 @@ single_col:
                 if(!IS_INTRA(mb_type_col[y8]) && !h->ref_list[1][0].long_ref
                    && (   (l1ref0[xy8] == 0 && FFABS(l1mv0[xy4][0]) <= 1 && FFABS(l1mv0[xy4][1]) <= 1)
                        || (l1ref0[xy8]  < 0 && l1ref1[xy8] == 0 && FFABS(l1mv1[xy4][0]) <= 1 && FFABS(l1mv1[xy4][1]) <= 1))){
+                    a=b=0;
                     if(ref[0] > 0)
                         a= pack16to32(mv[0][0],mv[0][1]);
                     if(ref[1] > 0)
@@ -284,14 +299,15 @@ single_col:
                 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, b, 4);
             }
         }else if(IS_16X16(*mb_type)){
-            int a=0, b=0;
+            int a,b;
 
             fill_rectangle(&h->ref_cache[0][scan8[0]], 4, 4, 8, (uint8_t)ref[0], 1);
             fill_rectangle(&h->ref_cache[1][scan8[0]], 4, 4, 8, (uint8_t)ref[1], 1);
             if(!IS_INTRA(mb_type_col[0]) && !h->ref_list[1][0].long_ref
                && (   (l1ref0[0] == 0 && FFABS(l1mv0[0][0]) <= 1 && FFABS(l1mv0[0][1]) <= 1)
                    || (l1ref0[0]  < 0 && l1ref1[0] == 0 && FFABS(l1mv1[0][0]) <= 1 && FFABS(l1mv1[0][1]) <= 1
-                       && (h->x264_build>33 || !h->x264_build)))){
+                       && h->x264_build>33U))){
+                a=b=0;
                 if(ref[0] > 0)
                     a= pack16to32(mv[0][0],mv[0][1]);
                 if(ref[1] > 0)
@@ -303,6 +319,7 @@ single_col:
             fill_rectangle(&h->mv_cache[0][scan8[0]], 4, 4, 8, a, 4);
             fill_rectangle(&h->mv_cache[1][scan8[0]], 4, 4, 8, b, 4);
         }else{
+            int n=0;
             for(i8=0; i8<4; i8++){
                 const int x8 = i8&1;
                 const int y8 = i8>>1;
@@ -319,7 +336,7 @@ single_col:
                 /* col_zero_flag */
                 if(!IS_INTRA(mb_type_col[0]) && !h->ref_list[1][0].long_ref && (   l1ref0[x8 + y8*b8_stride] == 0
                                               || (l1ref0[x8 + y8*b8_stride] < 0 && l1ref1[x8 + y8*b8_stride] == 0
-                                                  && (h->x264_build>33 || !h->x264_build)))){
+                                                  && h->x264_build>33U))){
                     const int16_t (*l1mv)[2]= l1ref0[x8 + y8*b8_stride] == 0 ? l1mv0 : l1mv1;
                     if(IS_SUB_8X8(sub_mb_type)){
                         const int16_t *mv_col = l1mv[x8*3 + y8*3*b4_stride];
@@ -328,8 +345,10 @@ single_col:
                                 fill_rectangle(&h->mv_cache[0][scan8[i8*4]], 2, 2, 8, 0, 4);
                             if(ref[1] == 0)
                                 fill_rectangle(&h->mv_cache[1][scan8[i8*4]], 2, 2, 8, 0, 4);
+                            n+=4;
                         }
-                    }else
+                    }else{
+                        int m=0;
                     for(i4=0; i4<4; i4++){
                         const int16_t *mv_col = l1mv[x8*2 + (i4&1) + (y8*2 + (i4>>1))*b4_stride];
                         if(FFABS(mv_col[0]) <= 1 && FFABS(mv_col[1]) <= 1){
@@ -337,26 +356,31 @@ single_col:
                                 *(uint32_t*)h->mv_cache[0][scan8[i8*4+i4]] = 0;
                             if(ref[1] == 0)
                                 *(uint32_t*)h->mv_cache[1][scan8[i8*4+i4]] = 0;
+                            m++;
                         }
                     }
+                    if(!(m&3))
+                        h->sub_mb_type[i8]+= MB_TYPE_16x16 - MB_TYPE_8x8;
+                    n+=m;
+                    }
                 }
             }
+            if(!is_b8x8 && !(n&15))
+                *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;
         }
     }else{ /* direct temporal mv pred */
         const int *map_col_to_list0[2] = {h->map_col_to_list0[0], h->map_col_to_list0[1]};
         const int *dist_scale_factor = h->dist_scale_factor;
-        int ref_offset= 0;
+        int ref_offset;
 
         if(FRAME_MBAFF && IS_INTERLACED(*mb_type)){
             map_col_to_list0[0] = h->map_col_to_list0_field[s->mb_y&1][0];
             map_col_to_list0[1] = h->map_col_to_list0_field[s->mb_y&1][1];
             dist_scale_factor   =h->dist_scale_factor_field[s->mb_y&1];
         }
-        if(h->ref_list[1][0].mbaff && IS_INTERLACED(mb_type_col[0]))
-            ref_offset += 16;
+        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
 
         if(IS_INTERLACED(*mb_type) != IS_INTERLACED(mb_type_col[0])){
-            /* FIXME assumes direct_8x8_inference == 1 */
             int y_shift  = 2*!IS_INTERLACED(*mb_type);
             assert(h->sps.direct_8x8_inference_flag);