diff --git a/av1/av1_cx_iface.c b/av1/av1_cx_iface.c
index 17c4d70..8a2fe7f 100644
--- a/av1/av1_cx_iface.c
+++ b/av1/av1_cx_iface.c
@@ -3129,71 +3129,6 @@
   return flags;
 }
 
-#if CONFIG_MIXED_LOSSLESS_ENCODE
-
-static void check_mixed_lossless_plane(AV1_COMP *cpi, const uint16_t *a,
-                                       int a_stride, const uint16_t *b,
-                                       int b_stride, int width, int height,
-                                       int plane) {
-  int shift = plane ? 1 : 0;
-
-  for (int y = 0; y < height; ++y) {
-    for (int x = 0; x < width; ++x) {
-      uint16_t org = a[y * a_stride + x];
-      uint16_t rec = b[y * b_stride + x];
-      int mi_row = (y << shift) >> MI_SIZE_LOG2;
-      int mi_col = (x << shift) >> MI_SIZE_LOG2;
-      int curr_sb_row = mi_row / cpi->common.mib_size;
-      int curr_sb_col = mi_col / cpi->common.mib_size;
-      int middle_sb_rows =
-          (cpi->common.mi_params.mi_rows / cpi->common.mib_size) >> 1;
-      int middle_sb_cols =
-          (cpi->common.mi_params.mi_cols / cpi->common.mib_size) >> 1;
-      int min_sb_rows = AOMMAX(0, middle_sb_rows - 1);
-      int max_sb_rows =
-          AOMMIN(cpi->common.mi_params.mi_rows / cpi->common.mib_size,
-                 middle_sb_rows + 1);
-      int min_sb_cols = AOMMAX(0, middle_sb_cols - 1);
-      int max_sb_cols =
-          AOMMIN(cpi->common.mi_params.mi_cols / cpi->common.mib_size,
-                 middle_sb_cols + 1);
-      int is_lossless = 1;
-      is_lossless &=
-          (curr_sb_row >= min_sb_rows) && (curr_sb_row <= max_sb_rows);
-      is_lossless &=
-          (curr_sb_col >= min_sb_cols) && (curr_sb_col <= max_sb_cols);
-
-      if (is_lossless && org != rec) {
-        printf(" plane = %d x = %x, y=%d \n", plane, x, y);
-      }
-      assert(IMPLIES(is_lossless, org == rec));
-    }
-  }
-}
-
-static void check_mixed_lossless(AV1_COMP *cpi, const YV12_BUFFER_CONFIG *a,
-                                 const YV12_BUFFER_CONFIG *b) {
-  assert(a->y_crop_width == b->y_crop_width);
-  assert(a->y_crop_height == b->y_crop_height);
-  assert(a->uv_crop_width == b->uv_crop_width);
-  assert(a->uv_crop_height == b->uv_crop_height);
-  const int widths[3] = { a->y_crop_width, a->uv_crop_width, a->uv_crop_width };
-  const int heights[3] = { a->y_crop_height, a->uv_crop_height,
-                           a->uv_crop_height };
-  const int a_strides[3] = { a->y_stride, a->uv_stride, a->uv_stride };
-  const int b_strides[3] = { b->y_stride, b->uv_stride, b->uv_stride };
-  int i;
-
-  for (i = 0; i < 3; ++i) {
-    const int w = widths[i];
-    const int h = heights[i];
-    check_mixed_lossless_plane(cpi, a->buffers[i], a_strides[i], b->buffers[i],
-                               b_strides[i], w, h, i);
-  }
-}
-
-#endif  // CONFIG_MIXED_LOSSLESS_ENCODE
-
 static void calculate_psnr(AV1_COMP *cpi, PSNR_STATS *psnr) {
   const uint32_t in_bit_depth = cpi->oxcf.input_cfg.input_bit_depth;
   const uint32_t bit_depth = cpi->td.mb.e_mbd.bd;
@@ -3204,22 +3139,11 @@
   aom_calc_highbd_psnr(source, &cpi->common.cur_frame->buf, psnr, bit_depth,
                        in_bit_depth, is_lossless_requested(&cpi->oxcf.rc_cfg));
 
-#if CONFIG_MIXED_LOSSLESS_ENCODE
-  if (cpi->enc_seg.has_lossless_segment) {
-    check_mixed_lossless(cpi, source, &cpi->common.cur_frame->buf);
-  }
-#endif  // CONFIG_MIXED_LOSSLESS_ENCODE
-
 #else
   aom_calc_highbd_psnr(cpi->unfiltered_source, &cpi->common.cur_frame->buf,
                        psnr, bit_depth, in_bit_depth,
                        is_lossless_requested(&cpi->oxcf.rc_cfg));
 
-#if CONFIG_MIXED_LOSSLESS_ENCODE
-  check_mixed_lossless(cpi, cpi->unfiltered_source, &cpi->common.cur_frame->buf,
-                       psnr, bit_depth, in_bit_depth,
-                       is_lossless_requested(&cpi->oxcf.rc_cfg));
-#endif  // CONFIG_MIXED_LOSSLESS_ENCODE
 #endif  // CONFIG_FIX_RESIZE_PSNR
 }
 
diff --git a/av1/common/av1_common_int.h b/av1/common/av1_common_int.h
index a88d5fb..a178198 100644
--- a/av1/common/av1_common_int.h
+++ b/av1/common/av1_common_int.h
@@ -5348,6 +5348,57 @@
   return reduced_tx_set_used;
 }
 
+// This function is required because, for chroma plane in particular,
+// the actual 'mi' location maybe at an offset from the mi_row/mi_col.
+static INLINE MB_MODE_INFO **get_mi_location_from_collocated_mi(
+    const AV1_COMMON *const cm, MB_MODE_INFO **this_mi, int plane) {
+  if (plane > 0) {  // Chroma plane.
+    // Two possible cases:
+    // 1. Decoupled luma/chroma tree OR
+    // 2. Shared luma/chroma tree.
+    // Need to get appropriate 'mi' location differently for each case.
+    const bool is_sdp_eligible = cm->seq_params.enable_sdp &&
+                                 !cm->seq_params.monochrome &&
+                                 this_mi[0]->region_type == INTRA_REGION;
+    if (is_sdp_eligible) {
+      // 1. Decoupled luma/chroma tree:
+      // Get top-left mi location using chroma_mi_row_start/chroma_mi_col_start.
+      MB_MODE_INFO **top_left_mi =
+          cm->mi_params.mi_grid_base +
+          this_mi[0]->chroma_mi_row_start * cm->mi_params.mi_stride +
+          this_mi[0]->chroma_mi_col_start;
+      assert(top_left_mi[0]->region_type == INTRA_REGION);
+      return top_left_mi;
+    } else {
+      // 2. Shared luma/chroma tree.
+      // Get bottom-right mi location using chroma_ref_info.
+      const CHROMA_REF_INFO *chroma_ref_info = &this_mi[0]->chroma_ref_info;
+      if (!chroma_ref_info->is_chroma_ref) {
+        // For sub8x8 block, if this mi is NOT a chroma ref, then chroma
+        // prediction mode is obtained from the bottom/right mi. So, for chroma
+        // plane, mi_row and mi_col should map to the bottom/right mi structure.
+        // Also, mi_grid_base array is only filled in for on-screen mi's, even
+        // though chroma block can extend over the edge. So, make sure we stay
+        // within mi_grid_base array's bottom and right limits.
+        const int bottom_mi_row =
+            AOMMIN(chroma_ref_info->mi_row_chroma_base +
+                       mi_size_high[chroma_ref_info->bsize_base] - 1,
+                   cm->mi_params.mi_rows - 1);
+        const int right_mi_col =
+            AOMMIN(chroma_ref_info->mi_col_chroma_base +
+                       mi_size_wide[chroma_ref_info->bsize_base] - 1,
+                   cm->mi_params.mi_cols - 1);
+        MB_MODE_INFO **bottom_right_mi =
+            cm->mi_params.mi_grid_base +
+            bottom_mi_row * cm->mi_params.mi_stride + right_mi_col;
+        assert(bottom_right_mi[0]->chroma_ref_info.is_chroma_ref);
+        return bottom_right_mi;
+      }
+    }
+  }
+  return this_mi;
+}
+
 #ifdef __cplusplus
 }  // extern "C"
 #endif
diff --git a/av1/common/av1_loopfilter.c b/av1/common/av1_loopfilter.c
index f7ac72e..be583f9 100644
--- a/av1/common/av1_loopfilter.c
+++ b/av1/common/av1_loopfilter.c
@@ -770,51 +770,7 @@
                            this_mi_row * cm->mi_params.mi_stride + this_mi_col;
   *mi_row = this_mi_row;
   *mi_col = this_mi_col;
-  if (plane > 0) {  // Chroma plane.
-    // Two possible cases:
-    // 1. Decoupled luma/chroma tree OR
-    // 2. Shared luma/chroma tree.
-    // Need to get appropriate 'mi' location differently for each case.
-    const bool is_sdp_eligible = cm->seq_params.enable_sdp &&
-                                 !cm->seq_params.monochrome &&
-                                 this_mi[0]->region_type == INTRA_REGION;
-    if (is_sdp_eligible) {
-      // 1. Decoupled luma/chroma tree:
-      // Get top-left mi location using chroma_mi_row_start/chroma_mi_col_start.
-      MB_MODE_INFO **top_left_mi =
-          cm->mi_params.mi_grid_base +
-          this_mi[0]->chroma_mi_row_start * cm->mi_params.mi_stride +
-          this_mi[0]->chroma_mi_col_start;
-      assert(top_left_mi[0]->region_type == INTRA_REGION);
-      return top_left_mi;
-    } else {
-      // 2. Shared luma/chroma tree.
-      // Get bottom-right mi location using chroma_ref_info.
-      const CHROMA_REF_INFO *chroma_ref_info = &this_mi[0]->chroma_ref_info;
-      if (!chroma_ref_info->is_chroma_ref) {
-        // For sub8x8 block, if this mi is NOT a chroma ref, then chroma
-        // prediction mode is obtained from the bottom/right mi. So, for chroma
-        // plane, mi_row and mi_col should map to the bottom/right mi structure.
-        // Also, mi_grid_base array is only filled in for on-screen mi's, even
-        // though chroma block can extend over the edge. So, make sure we stay
-        // within mi_grid_base array's bottom and right limits.
-        const int bottom_mi_row =
-            AOMMIN(chroma_ref_info->mi_row_chroma_base +
-                       mi_size_high[chroma_ref_info->bsize_base] - 1,
-                   cm->mi_params.mi_rows - 1);
-        const int right_mi_col =
-            AOMMIN(chroma_ref_info->mi_col_chroma_base +
-                       mi_size_wide[chroma_ref_info->bsize_base] - 1,
-                   cm->mi_params.mi_cols - 1);
-        MB_MODE_INFO **bottom_right_mi =
-            cm->mi_params.mi_grid_base +
-            bottom_mi_row * cm->mi_params.mi_stride + right_mi_col;
-        assert(bottom_right_mi[0]->chroma_ref_info.is_chroma_ref);
-        return bottom_right_mi;
-      }
-    }
-  }
-  return this_mi;
+  return get_mi_location_from_collocated_mi(cm, this_mi, plane);
 }
 
 // Return TX_SIZE from get_transform_size(), so it is plane and direction
diff --git a/av1/common/ccso.c b/av1/common/ccso.c
index 3dcecd3..1c3429f 100644
--- a/av1/common/ccso.c
+++ b/av1/common/ccso.c
@@ -249,7 +249,8 @@
     const int dst_stride, const int y_uv_hscale, const int y_uv_vscale,
     const int thr, const int neg_thr, const int *src_loc, const int max_val,
     const int blk_size_x, const int blk_size_y, const bool isSingleBand,
-    const uint8_t shift_bits, const int edge_clf, const uint8_t ccso_bo_only) {
+    const uint8_t shift_bits, const int edge_clf, const uint8_t ccso_bo_only,
+    int plane) {
   const CommonModeInfoParams *const mi_params = &cm->mi_params;
   const int y_end = AOMMIN(pic_height - y, blk_size_y);
   const int x_end = AOMMIN(pic_width - x, blk_size_x);
@@ -261,18 +262,24 @@
     for (int x_start = 0; x_start < x_end; x_start += min_b_size_x) {
       const int x_pos = x + x_start;
 #if CONFIG_CONTROL_LOOPFILTERS_ACROSS_TILES
-      const int mbmi_idx = get_mi_grid_idx(
-          mi_params,
-          (tile_row_start + y_pos + y) >> (MI_SIZE_LOG2 - y_uv_vscale),
-          (tile_col_start + x_pos) >> (MI_SIZE_LOG2 - y_uv_hscale));
+      const int this_mi_row =
+          ((tile_row_start + y_pos + y) << y_uv_vscale) >> MI_SIZE_LOG2;
+      const int this_mi_col =
+          ((tile_col_start + x_pos) << y_uv_hscale) >> MI_SIZE_LOG2;
+
 #else
-      const int mbmi_idx = get_mi_grid_idx(
-          mi_params, (y_pos + y) >> (MI_SIZE_LOG2 - y_uv_vscale),
-          (x_pos) >> (MI_SIZE_LOG2 - y_uv_hscale));
+      const int this_mi_row = ((y_pos + y) << y_uv_vscale) >> MI_SIZE_LOG2;
+      const int this_mi_col = (x_pos << y_uv_hscale) >> MI_SIZE_LOG2;
+
 #endif  // CONFIG_CONTROL_LOOPFILTERS_ACROSS_TILES
+      MB_MODE_INFO **this_mbmi_ptr = mi_params->mi_grid_base +
+                                     this_mi_row * mi_params->mi_stride +
+                                     this_mi_col;
+      MB_MODE_INFO **this_mbmi =
+          get_mi_location_from_collocated_mi(cm, this_mbmi_ptr, plane);
+
       const int is_lossless =
-          cm->features
-              .lossless_segment[mi_params->mi_grid_base[mbmi_idx]->segment_id];
+          cm->features.lossless_segment[this_mbmi[0]->segment_id];
       if (!is_lossless) {
         int j_max = AOMMIN(x_pos + min_b_size_x, x + x_start + x_end);
         int i_max = AOMMIN(y_pos + min_b_size_y, y_end);
@@ -421,7 +428,7 @@
                       cm->ccso_info.filter_offset[plane], ccso_ext_tile_stride,
                       dst_stride, 0, 0, thr, neg_thr, src_loc, max_val,
                       unit_size, unit_size, false, shift_bits, edge_clf,
-                      cm->ccso_info.ccso_bo_only[plane]);
+                      cm->ccso_info.ccso_bo_only[plane], plane);
                 } else {
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
                   if (cm->ccso_info.ccso_bo_only[plane]) {
@@ -502,7 +509,8 @@
                 x + unit_x, y + unit_y, pic_width, pic_height, src_cls,
                 cm->ccso_info.filter_offset[plane], ccso_ext_stride, dst_stride,
                 0, 0, thr, neg_thr, src_loc, max_val, unit_size, unit_size,
-                false, shift_bits, edge_clf, cm->ccso_info.ccso_bo_only[plane]);
+                false, shift_bits, edge_clf, cm->ccso_info.ccso_bo_only[plane],
+                plane);
           } else {
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
 
@@ -649,7 +657,7 @@
                       cm->ccso_info.filter_offset[plane], ccso_ext_tile_stride,
                       dst_stride, 0, 0, thr, neg_thr, src_loc, max_val,
                       unit_size, unit_size, true, shift_bits, edge_clf,
-                      cm->ccso_info.ccso_bo_only[plane]);
+                      cm->ccso_info.ccso_bo_only[plane], plane);
                 } else {
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
                   if (cm->ccso_info.ccso_bo_only[plane]) {
@@ -729,7 +737,8 @@
                 x + unit_x, y + unit_y, pic_width, pic_height, src_cls,
                 cm->ccso_info.filter_offset[plane], ccso_ext_stride, dst_stride,
                 0, 0, thr, neg_thr, src_loc, max_val, unit_size, unit_size,
-                true, shift_bits, edge_clf, cm->ccso_info.ccso_bo_only[plane]);
+                true, shift_bits, edge_clf, cm->ccso_info.ccso_bo_only[plane],
+                plane);
           } else {
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
             if (cm->ccso_info.ccso_bo_only[plane]) {
@@ -899,7 +908,7 @@
                       ccso_ext_tile_y_stride, dst_stride, y_uv_hscale,
                       y_uv_vscale, thr, neg_thr, src_loc, max_val, unit_size_x,
                       unit_size_y, false, shift_bits, edge_clf,
-                      cm->ccso_info.ccso_bo_only[plane]);
+                      cm->ccso_info.ccso_bo_only[plane], plane);
                 } else {
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
                   if (cm->ccso_info.ccso_bo_only[plane]) {
@@ -985,7 +994,7 @@
                 cm->ccso_info.filter_offset[plane], ccso_ext_stride, dst_stride,
                 y_uv_hscale, y_uv_vscale, thr, neg_thr, src_loc, max_val,
                 unit_size_x, unit_size_y, false, shift_bits, edge_clf,
-                cm->ccso_info.ccso_bo_only[plane]);
+                cm->ccso_info.ccso_bo_only[plane], plane);
           } else {
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
             if (cm->ccso_info.ccso_bo_only[plane]) {
@@ -1157,7 +1166,7 @@
                       ccso_ext_tile_y_stride, dst_stride, y_uv_hscale,
                       y_uv_vscale, thr, neg_thr, src_loc, max_val, unit_size_x,
                       unit_size_y, true, shift_bits, edge_clf,
-                      cm->ccso_info.ccso_bo_only[plane]);
+                      cm->ccso_info.ccso_bo_only[plane], plane);
                 } else {
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
                   if (cm->ccso_info.ccso_bo_only[plane]) {
@@ -1243,7 +1252,7 @@
                 cm->ccso_info.filter_offset[plane], ccso_ext_stride, dst_stride,
                 y_uv_hscale, y_uv_vscale, thr, neg_thr, src_loc, max_val,
                 unit_size_x, unit_size_y, true, shift_bits, edge_clf,
-                cm->ccso_info.ccso_bo_only[plane]);
+                cm->ccso_info.ccso_bo_only[plane], plane);
           } else {
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
             if (cm->ccso_info.ccso_bo_only[plane]) {
diff --git a/av1/common/ccso.h b/av1/common/ccso.h
index 767f824..0a7405b 100644
--- a/av1/common/ccso.h
+++ b/av1/common/ccso.h
@@ -86,7 +86,8 @@
     const int dst_stride, const int y_uv_hscale, const int y_uv_vscale,
     const int thr, const int neg_thr, const int *src_loc, const int max_val,
     const int blk_size_x, const int blk_size_y, const bool isSingleBand,
-    const uint8_t shift_bits, const int edge_clf, const uint8_t ccso_bo_only);
+    const uint8_t shift_bits, const int edge_clf, const uint8_t ccso_bo_only,
+    int plane);
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
 
 #ifdef __cplusplus
diff --git a/av1/common/restoration.c b/av1/common/restoration.c
index d10545a..cf86067 100644
--- a/av1/common/restoration.c
+++ b/av1/common/restoration.c
@@ -1107,12 +1107,14 @@
     bool tskip_zero_flag
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
     ,
-    MB_MODE_INFO **mbmi_ptr_procunit, int mi_stride, int ss_x, int ss_y,
-    const bool *lossless_segment
+    const struct AV1Common *cm, MB_MODE_INFO **mbmi_ptr_procunit, int mi_stride,
+    int ss_x, int ss_y, const bool *lossless_segment
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
 
 ) {
+#if !CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
   (void)is_uv;
+#endif  //! CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
   const bool skip_filtering = classify_only;
   assert(!is_uv || skip_filtering);
   const int pc_filter_num_taps =
@@ -1256,8 +1258,10 @@
         const int start_mi_y = block_row_begin >> (MI_SIZE_LOG2 - ss_y);
         MB_MODE_INFO **this_mbmi_ptr =
             mbmi_ptr_procunit + start_mi_y * mi_stride + start_mi_x;
+        MB_MODE_INFO **this_mbmi =
+            get_mi_location_from_collocated_mi(cm, this_mbmi_ptr, is_uv);
 
-        if (lossless_segment[this_mbmi_ptr[0]->segment_id]) {
+        if (lossless_segment[this_mbmi[0]->segment_id]) {
           // Copy the data
           for (int r = block_row_begin; r < block_row_end; ++r) {
             for (int c = block_col_begin; c < block_col_end; ++c) {
@@ -1379,7 +1383,7 @@
         rui->tskip_zero_flag
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
         ,
-        mbmi_ptr_procunit, rui->mi_stride, rui->ss_x, rui->ss_y,
+        rui->cm, mbmi_ptr_procunit, rui->mi_stride, rui->ss_x, rui->ss_y,
         rui->lossless_segment
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
     );
@@ -1505,8 +1509,8 @@
     int class_id_restrict, int num_classes, int set_index
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
     ,
-    MB_MODE_INFO **mbmi_ptr_procunit, int mi_stride, int ss_x, int ss_y,
-    const bool *lossless_segment
+    const struct AV1Common *cm, MB_MODE_INFO **mbmi_ptr_procunit, int mi_stride,
+    int ss_x, int ss_y, const bool *lossless_segment, int plane
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
 ) {
   const int block_size = 4;
@@ -1525,7 +1529,9 @@
       const int start_mi_y = r >> (MI_SIZE_LOG2 - ss_y);
       MB_MODE_INFO **this_mbmi_ptr =
           mbmi_ptr_procunit + start_mi_y * mi_stride + start_mi_x;
-      if (lossless_segment[this_mbmi_ptr[0]->segment_id]) {
+      MB_MODE_INFO **this_mbmi =
+          get_mi_location_from_collocated_mi(cm, this_mbmi_ptr, plane);
+      if (lossless_segment[this_mbmi[0]->segment_id]) {
         copy_tile(w, h, dgd_row + c, stride, dst_row + c, dst_stride);
         continue;
       }
@@ -1551,10 +1557,11 @@
 }
 
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
-static AOM_INLINE int check_lossless(MB_MODE_INFO **mbmi_ptr_procunit,
+static AOM_INLINE int check_lossless(const struct AV1Common *cm,
+                                     MB_MODE_INFO **mbmi_ptr_procunit,
                                      const bool *lossless_segment, int width,
                                      int height, int mi_stride, int ss_x,
-                                     int ss_y) {
+                                     int ss_y, int plane) {
   const int block_size = 4;
   for (int r = 0; r < height; r += block_size) {
     const int start_mi_y = r >> (MI_SIZE_LOG2 - ss_y);
@@ -1562,7 +1569,9 @@
       const int start_mi_x = c >> (MI_SIZE_LOG2 - ss_x);
       MB_MODE_INFO **this_mbmi_ptr =
           mbmi_ptr_procunit + start_mi_y * mi_stride + start_mi_x;
-      if (lossless_segment[this_mbmi_ptr[0]->segment_id]) {
+      MB_MODE_INFO **this_mbmi =
+          get_mi_location_from_collocated_mi(cm, this_mbmi_ptr, plane);
+      if (lossless_segment[this_mbmi[0]->segment_id]) {
         return 1;
       }
     }
@@ -1580,19 +1589,27 @@
     int num_classes, int set_index
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
     ,
-    MB_MODE_INFO **mbmi_ptr_procunit, int mi_stride, int ss_x, int ss_y,
-    const bool *lossless_segment
+    const struct AV1Common *cm, MB_MODE_INFO **mbmi_ptr_procunit, int mi_stride,
+    int ss_x, int ss_y, const bool *lossless_segment
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
 ) {
   (void)luma;
   (void)luma_stride;
+#if !CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
   (void)plane;
+#endif  // !CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
+#if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
+  const uint8_t *pc_wiener_sub_classify =
+      get_pc_wiener_sub_classifier(num_classes, set_index);
+#endif
 
   const int block_size = 4;
   int is_uv = (plane != AOM_PLANE_Y);
   if (is_uv && nsfilter_config->num_pixels2 != 0) {
+#if !CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
     const uint8_t *pc_wiener_sub_classify =
         get_pc_wiener_sub_classifier(num_classes, set_index);
+#endif
     for (int r = 0; r < height; r += block_size) {
       const int h = AOMMIN(block_size, height - r);
       const uint16_t *dgd_row = dgd + r * stride;
@@ -1607,7 +1624,9 @@
         const int start_mi_y = r >> (MI_SIZE_LOG2 - ss_y);
         MB_MODE_INFO **this_mbmi_ptr =
             mbmi_ptr_procunit + start_mi_y * mi_stride + start_mi_x;
-        if (lossless_segment[this_mbmi_ptr[0]->segment_id]) {
+        MB_MODE_INFO **this_mbmi =
+            get_mi_location_from_collocated_mi(cm, this_mbmi_ptr, plane);
+        if (lossless_segment[this_mbmi[0]->segment_id]) {
           copy_tile(w, h, dgd_row + c, stride, dst_row + c, dst_stride);
           continue;
         }
@@ -1636,8 +1655,8 @@
   if (num_classes == 1) {
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
     const int is_lossless_block =
-        check_lossless(mbmi_ptr_procunit, lossless_segment, width, height,
-                       mi_stride, ss_x, ss_y);
+        check_lossless(cm, mbmi_ptr_procunit, lossless_segment, width, height,
+                       mi_stride, ss_x, ss_y, plane);
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
     const int is_sym = (nsfilter_config->asymmetric == 0);
     if (!nsfilter_config->strict_bounds && is_sym &&
@@ -1673,7 +1692,7 @@
       num_classes, set_index
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
       ,
-      mbmi_ptr_procunit, mi_stride, ss_x, ss_y, lossless_segment
+      cm, mbmi_ptr_procunit, mi_stride, ss_x, ss_y, lossless_segment, plane
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
   );
 
@@ -1705,7 +1724,8 @@
           true, NULL, NULL, rui->pcwiener_buffers, rui->tskip_zero_flag
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
           ,
-          NULL, rui->mi_stride, rui->ss_x, rui->ss_y, rui->lossless_segment
+          rui->cm, NULL, rui->mi_stride, rui->ss_x, rui->ss_y,
+          rui->lossless_segment
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
       );
     }
@@ -1773,7 +1793,7 @@
         rui->wienerns_info.num_classes, set_index
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
         ,
-        mbmi_ptr_procunit, rui->mi_stride, rui->ss_x, rui->ss_y,
+        rui->cm, mbmi_ptr_procunit, rui->mi_stride, rui->ss_x, rui->ss_y,
         rui->lossless_segment
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
 
@@ -2338,6 +2358,7 @@
 
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
   rsi->unit_info[rest_unit_idx].lossless_segment = ctxt->lossless_segment;
+  rsi->unit_info[rest_unit_idx].cm = ctxt->cm;
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
 
   av1_loop_restoration_filter_unit(
@@ -2410,6 +2431,7 @@
     lr_plane_ctxt->error = &cm->error;
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
     lr_plane_ctxt->lossless_segment = &cm->features.lossless_segment[0];
+    lr_plane_ctxt->cm = cm;
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
   }
 }
diff --git a/av1/common/restoration.h b/av1/common/restoration.h
index 8c5062b..595b14e 100644
--- a/av1/common/restoration.h
+++ b/av1/common/restoration.h
@@ -322,7 +322,14 @@
   struct aom_internal_error_info *error;
   /*!\endcond */
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
+  /*!
+   * Pointer to point lossless_segment array in cm.
+   */
   const bool *lossless_segment;
+  /*!
+   * Pointer to cm.
+   */
+  const struct AV1Common *cm;
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
 } RestorationUnitInfo;
 
@@ -585,6 +592,7 @@
   struct aom_internal_error_info *error;
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
   const bool *lossless_segment;
+  const struct AV1Common *cm;
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
 } FilterFrameCtxt;
 
diff --git a/av1/decoder/decodemv.c b/av1/decoder/decodemv.c
index 5094994..810de47 100644
--- a/av1/decoder/decodemv.c
+++ b/av1/decoder/decodemv.c
@@ -4032,10 +4032,6 @@
 
   mbmi->current_qindex = xd->current_base_qindex;
 
-#if CONFIG_MIXED_LOSSLESS_ENCODE
-  assert(IMPLIES(mbmi->segment_id, xd->lossless[mbmi->segment_id]));
-#endif  // CONFIG_MIXED_LOSSLESS_ENCODE
-
   if (!inter_block &&
       av1_allow_intrabc(cm, xd, mbmi->sb_type[xd->tree_type == CHROMA_PART]) &&
       xd->tree_type != CHROMA_PART) {
diff --git a/av1/encoder/aq_variance.c b/av1/encoder/aq_variance.c
index bc6853a..b4afa59 100644
--- a/av1/encoder/aq_variance.c
+++ b/av1/encoder/aq_variance.c
@@ -83,12 +83,10 @@
     for (i = 0; i < max_seg_num; ++i) {
       // Set up avg segment id to be 1.0 and adjust the other segments around
       // it.
-      int qindex_delta = av1_compute_qdelta_by_rate(
-          &cpi->rc, cm->current_frame.frame_type, base_qindex,
-          rate_ratio[i] / avg_ratio, cpi->is_screen_content_type,
-          cm->seq_params.bit_depth);
 
 #if CONFIG_MIXED_LOSSLESS_ENCODE
+      (void)avg_ratio;
+      int qindex_delta;
       // Assume base QP in command line 100
       if (i > 0) {
         qindex_delta = -base_qindex;
@@ -97,6 +95,10 @@
       }
 
 #else
+      int qindex_delta = av1_compute_qdelta_by_rate(
+          &cpi->rc, cm->current_frame.frame_type, base_qindex,
+          rate_ratio[i] / avg_ratio, cpi->is_screen_content_type,
+          cm->seq_params.bit_depth);
       // We don't allow qindex 0 in a segment if the base value is not 0.
       // Q index 0 (lossless) implies 4x4 encoding only and in AQ mode a segment
       // Q delta is sometimes applied without going back around the rd loop.
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 0616e4e..b9977e5 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -833,9 +833,6 @@
   const int mi_row = xd->mi_row;
   const int mi_col = xd->mi_col;
 
-#if CONFIG_MIXED_LOSSLESS_ENCODE
-  assert(IMPLIES(mbmi->segment_id, xd->lossless[mbmi->segment_id]));
-#endif  // CONFIG_MIXED_LOSSLESS_ENCODE
   // Avoid change of segment_id for a lossless segment, as well as change
   // to a lossless segment as this could lead to invalid tx_size.
   // In other words, lossless segments remain pure. No lossless
diff --git a/av1/encoder/encode_strategy.c b/av1/encoder/encode_strategy.c
index 4d3a7a6..d2857a2 100644
--- a/av1/encoder/encode_strategy.c
+++ b/av1/encoder/encode_strategy.c
@@ -812,7 +812,9 @@
              get_frame_update_type(&cpi->gf_group) == INTNL_ARF_UPDATE) {
     // ARF
     apply_filtering = oxcf->algo_cfg.arnr_max_frames > 0;
+#if !CONFIG_MIXED_LOSSLESS_ENCODE
     if (is_lossless_requested(&oxcf->rc_cfg)) {
+#endif  //! CONFIG_MIXED_LOSSLESS_ENCODE
       // Turn off temporal filtering if overlay is off.
       // Also, turn off temporal filtering for internal ARF if overlay is on,
       // since overlay is not supported for this frame, and without overlay,
@@ -820,7 +822,9 @@
       apply_filtering &=
           (oxcf->algo_cfg.enable_overlay &
            (get_frame_update_type(&cpi->gf_group) != INTNL_ARF_UPDATE));
+#if !CONFIG_MIXED_LOSSLESS_ENCODE
     }
+#endif  //! CONFIG_MIXED_LOSSLESS_ENCODE
     if (gf_group->is_user_specified) {
       apply_filtering &= gf_group->is_filtered[gf_group->index];
     }
diff --git a/av1/encoder/pickrst.c b/av1/encoder/pickrst.c
index 7a28126..b96dd31 100644
--- a/av1/encoder/pickrst.c
+++ b/av1/encoder/pickrst.c
@@ -460,6 +460,7 @@
   rui.mi_stride = rsc->cm->mi_params.mi_stride;
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
   rui.lossless_segment = rsc->cm->features.lossless_segment;
+  rui.cm = rsc->cm;
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
   // Only need the classification if running for frame filters.
   rui.skip_pcwiener_filtering = pcwiener_disabled ? 1 : 0;
@@ -512,6 +513,7 @@
     rui->mi_stride = rsc->cm->mi_params.mi_stride;
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
     rui->lossless_segment = rsc->cm->features.lossless_segment;
+    rui->cm = rsc->cm;
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
     err = try_restoration_unit(rsc, limits, tile, rui);
   } else {
@@ -536,6 +538,7 @@
         rui->mi_stride = rsc->cm->mi_params.mi_stride;
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
         rui->lossless_segment = rsc->cm->features.lossless_segment;
+        rui->cm = rsc->cm;
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
         err += try_restoration_unit(rsc, &old_unit->limits, tile, rui);
         n++;
@@ -591,6 +594,7 @@
         rui->mi_stride = rsc->cm->mi_params.mi_stride;
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
         rui->lossless_segment = rsc->cm->features.lossless_segment;
+        rui->cm = rsc->cm;
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
         err += try_restoration_unit(rsc, &old_unit->limits, tile, rui);
         n++;
@@ -2309,6 +2313,7 @@
   rui.mi_stride = rsc->cm->mi_params.mi_stride;
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
   rui.lossless_segment = rsc->cm->features.lossless_segment;
+  rui.cm = rsc->cm;
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
   // Calculate and save this RU's stats.
   RstUnitStats unit_stats;
@@ -2449,6 +2454,7 @@
   rui.mi_stride = rsc->cm->mi_params.mi_stride;
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
   rui.lossless_segment = rsc->cm->features.lossless_segment;
+  rui.cm = rsc->cm;
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
 
   // Classification has already been calculated by search_pc_wiener_visitor().
@@ -3566,6 +3572,7 @@
           get_mi_grid_idx(&rsc->cm->mi_params, start_mi_y, start_mi_x);
 #if CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
       rui->lossless_segment = rsc->cm->features.lossless_segment;
+      rui->cm = rsc->cm;
 #endif  // CONFIG_DISABLE_LOOP_FILTERS_LOSSLESS
       rui->mbmi_ptr = rsc->cm->mi_params.mi_grid_base + mbmi_idx;
       rui->ss_x = ss_x;
diff --git a/av1/encoder/temporal_filter.c b/av1/encoder/temporal_filter.c
index b3a5c36..2cfa9cf 100644
--- a/av1/encoder/temporal_filter.c
+++ b/av1/encoder/temporal_filter.c
@@ -1327,10 +1327,12 @@
 
     if (!is_second_arf) {
       *show_existing_arf = 0;
+#if !CONFIG_MIXED_LOSSLESS_ENCODE
       if (!is_lossless_requested(&cpi->oxcf.rc_cfg) && mean < threshold &&
           std < mean * 1.2) {
         *show_existing_arf = 1;
       }
+#endif  //! CONFIG_MIXED_LOSSLESS_ENCODE
       cpi->common.showable_frame |= *show_existing_arf;
     } else {
       if (show_existing_arf) *show_existing_arf = 0;