[NORMATIVE] Add frame-level flag to enable/disable filter_intra

BUG=aomedia:1401

Change-Id: I0f9adce33118a8e50e26a42a5a828a8bc887a594

av1/common/blockd.h

diff --git a/av1/common/blockd.h b/av1/common/blockd.h
index 3a7f442..4d0720e 100644
--- a/av1/common/blockd.h
+++ b/av1/common/blockd.h
@@ -755,18 +755,6 @@
   0, 90, 180, 45, 135, 113, 157, 203, 67, 0, 0, 0, 0,
 };
 
-static INLINE int av1_filter_intra_allowed_bsize(BLOCK_SIZE bs) {
-  if (bs == BLOCK_INVALID) return 0;
-
-  return block_size_wide[bs] <= 32 && block_size_high[bs] <= 32;
-}
-
-static INLINE int av1_filter_intra_allowed(const MB_MODE_INFO *mbmi) {
-  return mbmi->mode == DC_PRED &&
-         mbmi->palette_mode_info.palette_size[0] == 0 &&
-         av1_filter_intra_allowed_bsize(mbmi->sb_type);
-}
-
 // Converts block_index for given transform size to index of the block in raster
 // order.
 static INLINE int av1_block_index_to_raster_order(TX_SIZE tx_size,

av1/common/onyxc_int.h

diff --git a/av1/common/onyxc_int.h b/av1/common/onyxc_int.h
index a15fd14..30a7a57 100644
--- a/av1/common/onyxc_int.h
+++ b/av1/common/onyxc_int.h
@@ -321,6 +321,7 @@
   int disable_intra_edge_filter;  // 1 - disable corner/edge/upsampling
   int allow_screen_content_tools;
   int allow_intrabc;
+  int allow_filter_intra;
   int allow_interintra_compound;
   int allow_masked_compound;
 

av1/common/reconintra.h

diff --git a/av1/common/reconintra.h b/av1/common/reconintra.h
index eb813c4..29b32cc 100644
--- a/av1/common/reconintra.h
+++ b/av1/common/reconintra.h
@@ -64,6 +64,20 @@
   return cm->allow_screen_content_tools && cm->allow_intrabc;
 }
 
+static INLINE int av1_filter_intra_allowed_bsize(const AV1_COMMON *const cm,
+                                                 BLOCK_SIZE bs) {
+  if (!cm->allow_filter_intra || bs == BLOCK_INVALID) return 0;
+
+  return block_size_wide[bs] <= 32 && block_size_high[bs] <= 32;
+}
+
+static INLINE int av1_filter_intra_allowed(const AV1_COMMON *const cm,
+                                           const MB_MODE_INFO *mbmi) {
+  return mbmi->mode == DC_PRED &&
+         mbmi->palette_mode_info.palette_size[0] == 0 &&
+         av1_filter_intra_allowed_bsize(cm, mbmi->sb_type);
+}
+
 extern const int8_t av1_filter_intra_taps[FILTER_INTRA_MODES][8][8];
 
 #ifdef __cplusplus

av1/decoder/decodeframe.c

diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index a98eaf0..6414736 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -2697,6 +2697,7 @@
   cm->intra_only = cm->frame_type == INTRA_ONLY_FRAME;
   cm->error_resilient_mode = aom_rb_read_bit(rb);
   cm->disable_intra_edge_filter = aom_rb_read_bit(rb);
+  cm->allow_filter_intra = aom_rb_read_bit(rb);
 
 #if CONFIG_CDF_UPDATE_MODE
   cm->disable_cdf_update = aom_rb_read_bit(rb);

av1/decoder/decodemv.c

diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index a8a5f1e..c042066 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -630,13 +630,14 @@
   return sym - MAX_ANGLE_DELTA;
 }
 
-static void read_filter_intra_mode_info(MACROBLOCKD *const xd, aom_reader *r) {
+static void read_filter_intra_mode_info(const AV1_COMMON *const cm,
+                                        MACROBLOCKD *const xd, aom_reader *r) {
   MODE_INFO *const mi = xd->mi[0];
   MB_MODE_INFO *const mbmi = &mi->mbmi;
   FILTER_INTRA_MODE_INFO *filter_intra_mode_info =
       &mbmi->filter_intra_mode_info;
 
-  if (av1_filter_intra_allowed(mbmi)) {
+  if (av1_filter_intra_allowed(cm, mbmi)) {
     filter_intra_mode_info->use_filter_intra = aom_read_symbol(
         r, xd->tile_ctx->filter_intra_cdfs[mbmi->sb_type], 2, ACCT_STR);
     if (filter_intra_mode_info->use_filter_intra) {
@@ -885,7 +886,7 @@
   if (av1_allow_palette(cm->allow_screen_content_tools, bsize))
     read_palette_mode_info(cm, xd, mi_row, mi_col, r);
 
-  read_filter_intra_mode_info(xd, r);
+  read_filter_intra_mode_info(cm, xd, r);
 }
 
 static int read_mv_component(aom_reader *r, nmv_component *mvcomp,
@@ -1165,7 +1166,7 @@
   if (av1_allow_palette(cm->allow_screen_content_tools, bsize))
     read_palette_mode_info(cm, xd, mi_row, mi_col, r);
 
-  read_filter_intra_mode_info(xd, r);
+  read_filter_intra_mode_info(cm, xd, r);
 }
 
 static INLINE int is_mv_valid(const MV *mv) {

av1/encoder/bitstream.c

diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index a32317a..aea6683 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -617,10 +617,11 @@
   }
 }
 
-static void write_filter_intra_mode_info(const MACROBLOCKD *xd,
+static void write_filter_intra_mode_info(const AV1_COMMON *cm,
+                                         const MACROBLOCKD *xd,
                                          const MB_MODE_INFO *const mbmi,
                                          aom_writer *w) {
-  if (av1_filter_intra_allowed(mbmi)) {
+  if (av1_filter_intra_allowed(cm, mbmi)) {
     aom_write_symbol(w, mbmi->filter_intra_mode_info.use_filter_intra,
                      xd->tile_ctx->filter_intra_cdfs[mbmi->sb_type], 2);
     if (mbmi->filter_intra_mode_info.use_filter_intra) {
@@ -1091,7 +1092,7 @@
     if (av1_allow_palette(cm->allow_screen_content_tools, bsize))
       write_palette_mode_info(cm, xd, mi, mi_row, mi_col, w);
 
-    write_filter_intra_mode_info(xd, mbmi, w);
+    write_filter_intra_mode_info(cm, xd, mbmi, w);
   } else {
     int16_t mode_ctx;
 
@@ -1355,7 +1356,7 @@
   if (av1_allow_palette(cm->allow_screen_content_tools, bsize))
     write_palette_mode_info(cm, xd, mi, mi_row, mi_col, w);
 
-  write_filter_intra_mode_info(xd, mbmi, w);
+  write_filter_intra_mode_info(cm, xd, mbmi, w);
 }
 
 #if CONFIG_RD_DEBUG
@@ -3042,6 +3043,7 @@
   aom_wb_write_bit(wb, cm->error_resilient_mode);
 
   aom_wb_write_bit(wb, cm->disable_intra_edge_filter);
+  aom_wb_write_bit(wb, cm->allow_filter_intra);
 
 #if CONFIG_CDF_UPDATE_MODE
   aom_wb_write_bit(wb, cm->disable_cdf_update);

av1/encoder/encodeframe.c

diff --git a/av1/encoder/encodeframe.c b/av1/encoder/encodeframe.c
index 9248fcf..fc331bf 100644
--- a/av1/encoder/encodeframe.c
+++ b/av1/encoder/encodeframe.c
@@ -731,11 +731,11 @@
   }
 }
 
-static void sum_intra_stats(FRAME_COUNTS *counts, MACROBLOCKD *xd,
-                            const MODE_INFO *mi, const MODE_INFO *above_mi,
-                            const MODE_INFO *left_mi, const int intraonly,
-                            const int mi_row, const int mi_col,
-                            uint8_t allow_update_cdf) {
+static void sum_intra_stats(const AV1_COMMON *const cm, FRAME_COUNTS *counts,
+                            MACROBLOCKD *xd, const MODE_INFO *mi,
+                            const MODE_INFO *above_mi, const MODE_INFO *left_mi,
+                            const int intraonly, const int mi_row,
+                            const int mi_col, uint8_t allow_update_cdf) {
   FRAME_CONTEXT *fc = xd->tile_ctx;
   const MB_MODE_INFO *const mbmi = &mi->mbmi;
   const PREDICTION_MODE y_mode = mbmi->mode;
@@ -761,7 +761,7 @@
       update_cdf(fc->y_mode_cdf[size_group_lookup[bsize]], y_mode, INTRA_MODES);
   }
 
-  if (av1_filter_intra_allowed(mbmi)) {
+  if (av1_filter_intra_allowed(cm, mbmi)) {
     const int use_filter_intra_mode =
         mbmi->filter_intra_mode_info.use_filter_intra;
 #if CONFIG_ENTROPY_STATS
@@ -950,7 +950,7 @@
   }
 
   if (!is_inter_block(mbmi)) {
-    sum_intra_stats(td->counts, xd, mi, xd->above_mi, xd->left_mi,
+    sum_intra_stats(cm, td->counts, xd, mi, xd->above_mi, xd->left_mi,
                     frame_is_intra_only(cm), mi_row, mi_col,
                     tile_data->allow_update_cdf);
     if (av1_allow_palette(cm->allow_screen_content_tools, bsize) &&

av1/encoder/encoder.c

diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index fe10e9e..27b9777 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -2567,6 +2567,7 @@
   cm->seq_params.force_integer_mv = 2;
 #endif
   cm->disable_intra_edge_filter = 0;
+  cm->allow_filter_intra = 1;
 }
 
 AV1_COMP *av1_create_compressor(AV1EncoderConfig *oxcf,

av1/encoder/rd.c

diff --git a/av1/encoder/rd.c b/av1/encoder/rd.c
index 94fc38e..a62d8e8 100644
--- a/av1/encoder/rd.c
+++ b/av1/encoder/rd.c
@@ -123,7 +123,7 @@
   av1_cost_tokens_from_cdf(x->filter_intra_mode_cost, fc->filter_intra_mode_cdf,
                            NULL);
   for (i = 0; i < BLOCK_SIZES_ALL; ++i) {
-    if (av1_filter_intra_allowed_bsize(i))
+    if (av1_filter_intra_allowed_bsize(cm, i))
       av1_cost_tokens_from_cdf(x->filter_intra_cost[i],
                                fc->filter_intra_cdfs[i], NULL);
   }

av1/encoder/rdopt.c

diff --git a/av1/encoder/rdopt.c b/av1/encoder/rdopt.c
index 45848fe..32f8dc1 100644
--- a/av1/encoder/rdopt.c
+++ b/av1/encoder/rdopt.c
@@ -2494,7 +2494,7 @@
       total_rate += palette_mode_cost;
     }
   }
-  if (av1_filter_intra_allowed(mbmi)) {
+  if (av1_filter_intra_allowed(&cpi->common, mbmi)) {
     total_rate += x->filter_intra_cost[mbmi->sb_type][use_filter_intra];
     if (use_filter_intra) {
       total_rate += x->filter_intra_mode_cost[mbmi->filter_intra_mode_info
@@ -2603,7 +2603,8 @@
         x->angle_delta_cost[mbmi->mode - V_PRED]
                            [MAX_ANGLE_DELTA + mbmi->angle_delta[PLANE_TYPE_Y]];
   }
-  if (mbmi->mode == DC_PRED && av1_filter_intra_allowed_bsize(mbmi->sb_type)) {
+  if (mbmi->mode == DC_PRED &&
+      av1_filter_intra_allowed_bsize(cm, mbmi->sb_type)) {
     if (mbmi->filter_intra_mode_info.use_filter_intra) {
       const int mode = mbmi->filter_intra_mode_info.filter_intra_mode;
       mode_cost += x->filter_intra_cost[mbmi->sb_type][1] +
@@ -3303,7 +3304,7 @@
                               ctx->blk_skip[0]);
   }
 
-  if (beat_best_rd && av1_filter_intra_allowed_bsize(bsize)) {
+  if (beat_best_rd && av1_filter_intra_allowed_bsize(&cpi->common, bsize)) {
     if (rd_pick_filter_intra_sby(cpi, x, rate, rate_tokenonly, distortion,
                                  skippable, bsize, bmode_costs[DC_PRED],
                                  &best_rd, &best_model_rd, ctx)) {
@@ -8863,7 +8864,7 @@
       memcpy(best_blk_skip, x->blk_skip[0],
              sizeof(best_blk_skip[0]) * ctx->num_4x4_blk);
 
-      if (mbmi->mode == DC_PRED && av1_filter_intra_allowed_bsize(bsize)) {
+      if (mbmi->mode == DC_PRED && av1_filter_intra_allowed_bsize(cm, bsize)) {
         RD_STATS rd_stats_y_fi;
         int filter_intra_selected_flag = 0;
         TX_SIZE best_tx_size = mbmi->tx_size;
@@ -8872,7 +8873,7 @@
                sizeof(*best_txk_type) * TXK_TYPE_BUF_LEN);
         FILTER_INTRA_MODE best_fi_mode = FILTER_DC_PRED;
         int64_t best_rd_tmp = INT64_MAX;
-        if (rate_y != INT_MAX && av1_filter_intra_allowed_bsize(bsize)) {
+        if (rate_y != INT_MAX) {
           best_rd_tmp = RDCOST(x->rdmult,
                                rate_y + x->filter_intra_cost[bsize][0] +
                                    intra_mode_cost[mbmi->mode],