diff --git a/av1/common/restoration.c b/av1/common/restoration.c
index aa06313..05cd169 100644
--- a/av1/common/restoration.c
+++ b/av1/common/restoration.c
@@ -14,6 +14,7 @@
 
 #include "./aom_config.h"
 #include "./aom_dsp_rtcd.h"
+#include "./aom_scale_rtcd.h"
 #include "av1/common/onyxc_int.h"
 #include "av1/common/restoration.h"
 #include "aom_dsp/aom_dsp_common.h"
@@ -41,12 +42,14 @@
 
 typedef void (*restore_func_type)(uint8_t *data8, int width, int height,
                                   int stride, RestorationInternal *rst,
-                                  uint8_t *tmpdata8, int tmpstride);
+                                  uint8_t *tmpdata8, int tmpstride,
+                                  uint8_t *dst8, int dst_stride);
 #if CONFIG_AOM_HIGHBITDEPTH
 typedef void (*restore_func_highbd_type)(uint8_t *data8, int width, int height,
                                          int stride, RestorationInternal *rst,
                                          uint8_t *tmpdata8, int tmpstride,
-                                         int bit_depth);
+                                         int bit_depth, uint8_t *dst8,
+                                         int dst_stride);
 #endif  // CONFIG_AOM_HIGHBITDEPTH
 
 static void GenDomainTxfmRFVtable() {
@@ -119,6 +122,40 @@
   }
 }
 
+// Some filters do not write the outermost RESTORATION_HALFWIN pixels,
+// so copy them over explicitly.
+static void copy_border(uint8_t *data, int width, int height, int stride,
+                        uint8_t *dst, int dst_stride) {
+  int i;
+  for (i = RESTORATION_HALFWIN; i < height - RESTORATION_HALFWIN; ++i) {
+    memcpy(dst + i * dst_stride, data + i * stride, RESTORATION_HALFWIN);
+    memcpy(dst + i * dst_stride + (width - RESTORATION_HALFWIN),
+           data + i * stride + (width - RESTORATION_HALFWIN),
+           RESTORATION_HALFWIN);
+  }
+  for (i = 0; i < RESTORATION_HALFWIN; ++i) {
+    memcpy(dst + i * dst_stride, data + i * stride, width);
+  }
+  for (i = height - RESTORATION_HALFWIN; i < height; ++i)
+    memcpy(dst + i * dst_stride, data + i * stride, width);
+}
+
+static void loop_copy_tile(uint8_t *data, int tile_idx, int subtile_idx,
+                           int subtile_bits, int width, int height, int stride,
+                           RestorationInternal *rst, uint8_t *dst,
+                           int dst_stride) {
+  const int tile_width = rst->tile_width >> rst->subsampling_x;
+  const int tile_height = rst->tile_height >> rst->subsampling_y;
+  int i;
+  int h_start, h_end, v_start, v_end;
+  av1_get_rest_tile_limits(tile_idx, subtile_idx, subtile_bits, rst->nhtiles,
+                           rst->nvtiles, tile_width, tile_height, width, height,
+                           0, 0, &h_start, &h_end, &v_start, &v_end);
+  for (i = v_start; i < v_end; ++i)
+    memcpy(dst + i * dst_stride + h_start, data + i * stride + h_start,
+           h_end - h_start);
+}
+
 uint8_t hor_sym_filter(uint8_t *d, int *hfilter) {
   int32_t s =
       (1 << (RESTORATION_FILT_BITS - 1)) + d[0] * hfilter[RESTORATION_HALFWIN];
@@ -140,14 +177,19 @@
 static void loop_wiener_filter_tile(uint8_t *data, int tile_idx, int width,
                                     int height, int stride,
                                     RestorationInternal *rst, uint8_t *tmpdata,
-                                    int tmpstride) {
+                                    int tmpstride, uint8_t *dst,
+                                    int dst_stride) {
   const int tile_width = rst->tile_width >> rst->subsampling_x;
   const int tile_height = rst->tile_height >> rst->subsampling_y;
   int i, j;
   int h_start, h_end, v_start, v_end;
-  uint8_t *data_p, *tmpdata_p;
+  uint8_t *data_p, *tmpdata_p, *dst_p;
 
-  if (rst->rsi->wiener_info[tile_idx].level == 0) return;
+  if (rst->rsi->wiener_info[tile_idx].level == 0) {
+    loop_copy_tile(data, tile_idx, 0, 0, width, height, stride, rst, dst,
+                   dst_stride);
+    return;
+  }
   // Filter row-wise
   av1_get_rest_tile_limits(tile_idx, 0, 0, rst->nhtiles, rst->nvtiles,
                            tile_width, tile_height, width, height, 1, 0,
@@ -166,35 +208,34 @@
   av1_get_rest_tile_limits(tile_idx, 0, 0, rst->nhtiles, rst->nvtiles,
                            tile_width, tile_height, width, height, 0, 1,
                            &h_start, &h_end, &v_start, &v_end);
-  data_p = data + h_start + v_start * stride;
+  dst_p = dst + h_start + v_start * dst_stride;
   tmpdata_p = tmpdata + h_start + v_start * tmpstride;
   for (i = 0; i < (v_end - v_start); ++i) {
     for (j = 0; j < (h_end - h_start); ++j) {
-      *data_p++ = ver_sym_filter(tmpdata_p++, tmpstride,
-                                 rst->rsi->wiener_info[tile_idx].vfilter);
+      *dst_p++ = ver_sym_filter(tmpdata_p++, tmpstride,
+                                rst->rsi->wiener_info[tile_idx].vfilter);
     }
-    data_p += stride - (h_end - h_start);
+    dst_p += dst_stride - (h_end - h_start);
     tmpdata_p += tmpstride - (h_end - h_start);
   }
 }
 
 static void loop_wiener_filter(uint8_t *data, int width, int height, int stride,
                                RestorationInternal *rst, uint8_t *tmpdata,
-                               int tmpstride) {
-  int tile_idx;
-  int i;
-  uint8_t *data_p, *tmpdata_p;
+                               int tmpstride, uint8_t *dst, int dst_stride) {
+  int tile_idx, i;
   // Initialize tmp buffer
-  data_p = data;
-  tmpdata_p = tmpdata;
+  uint8_t *data_p = data;
+  uint8_t *tmpdata_p = tmpdata;
   for (i = 0; i < height; ++i) {
     memcpy(tmpdata_p, data_p, sizeof(*data_p) * width);
     data_p += stride;
     tmpdata_p += tmpstride;
   }
+  copy_border(data, width, height, stride, dst, dst_stride);
   for (tile_idx = 0; tile_idx < rst->ntiles; ++tile_idx) {
     loop_wiener_filter_tile(data, tile_idx, width, height, stride, rst, tmpdata,
-                            tmpstride);
+                            tmpstride, dst, dst_stride);
   }
 }
 
@@ -494,16 +535,21 @@
 
 static void loop_sgrproj_filter_tile(uint8_t *data, int tile_idx, int width,
                                      int height, int stride,
-                                     RestorationInternal *rst, void *tmpbuf) {
+                                     RestorationInternal *rst, void *tmpbuf,
+                                     uint8_t *dst, int dst_stride) {
   const int tile_width = rst->tile_width >> rst->subsampling_x;
   const int tile_height = rst->tile_height >> rst->subsampling_y;
   int i, j;
   int h_start, h_end, v_start, v_end;
-  uint8_t *data_p;
+  uint8_t *data_p, *dst_p;
   int64_t *dat = (int64_t *)tmpbuf;
   tmpbuf = (uint8_t *)tmpbuf + RESTORATION_TILEPELS_MAX * sizeof(*dat);
 
-  if (rst->rsi->sgrproj_info[tile_idx].level == 0) return;
+  if (rst->rsi->sgrproj_info[tile_idx].level == 0) {
+    loop_copy_tile(data, tile_idx, 0, 0, width, height, stride, rst, dst,
+                   dst_stride);
+    return;
+  }
   av1_get_rest_tile_limits(tile_idx, 0, 0, rst->nhtiles, rst->nvtiles,
                            tile_width, tile_height, width, height, 0, 0,
                            &h_start, &h_end, &v_start, &v_end);
@@ -517,23 +563,26 @@
                                h_end - h_start, 8,
                                rst->rsi->sgrproj_info[tile_idx].ep,
                                rst->rsi->sgrproj_info[tile_idx].xqd, tmpbuf);
+  dst_p = dst + h_start + v_start * dst_stride;
   for (i = 0; i < (v_end - v_start); ++i) {
     for (j = 0; j < (h_end - h_start); ++j) {
-      data_p[i * stride + j] = clip_pixel((int)dat[i * (h_end - h_start) + j]);
+      dst_p[i * dst_stride + j] =
+          clip_pixel((int)dat[i * (h_end - h_start) + j]);
     }
   }
 }
 
 static void loop_sgrproj_filter(uint8_t *data, int width, int height,
                                 int stride, RestorationInternal *rst,
-                                uint8_t *tmpdata, int tmpstride) {
+                                uint8_t *tmpdata, int tmpstride, uint8_t *dst,
+                                int dst_stride) {
   int tile_idx;
   uint8_t *tmpbuf = aom_malloc(SGRPROJ_TMPBUF_SIZE);
   (void)tmpdata;
   (void)tmpstride;
   for (tile_idx = 0; tile_idx < rst->ntiles; ++tile_idx) {
-    loop_sgrproj_filter_tile(data, tile_idx, width, height, stride, rst,
-                             tmpbuf);
+    loop_sgrproj_filter_tile(data, tile_idx, width, height, stride, rst, tmpbuf,
+                             dst, dst_stride);
   }
   aom_free(tmpbuf);
 }
@@ -609,7 +658,8 @@
 }
 
 void av1_domaintxfmrf_restoration(uint8_t *dgd, int width, int height,
-                                  int stride, int param) {
+                                  int stride, int param, uint8_t *dst,
+                                  int dst_stride) {
   int32_t dat[RESTORATION_TILEPELS_MAX];
   int i, j, t;
   for (i = 0; i < height; ++i) {
@@ -624,7 +674,7 @@
   }
   for (i = 0; i < height; ++i) {
     for (j = 0; j < width; ++j) {
-      dgd[i * stride + j] = clip_pixel(dat[i * width + j]);
+      dst[i * dst_stride + j] = clip_pixel(dat[i * width + j]);
     }
   }
 }
@@ -632,64 +682,105 @@
 static void loop_domaintxfmrf_filter_tile(uint8_t *data, int tile_idx,
                                           int width, int height, int stride,
                                           RestorationInternal *rst,
-                                          void *tmpbuf) {
+                                          uint8_t *dst, int dst_stride) {
   const int tile_width = rst->tile_width >> rst->subsampling_x;
   const int tile_height = rst->tile_height >> rst->subsampling_y;
   int h_start, h_end, v_start, v_end;
-  (void)tmpbuf;
 
-  if (rst->rsi->domaintxfmrf_info[tile_idx].level == 0) return;
+  if (rst->rsi->domaintxfmrf_info[tile_idx].level == 0) {
+    loop_copy_tile(data, tile_idx, 0, 0, width, height, stride, rst, dst,
+                   dst_stride);
+    return;
+  }
   av1_get_rest_tile_limits(tile_idx, 0, 0, rst->nhtiles, rst->nvtiles,
                            tile_width, tile_height, width, height, 0, 0,
                            &h_start, &h_end, &v_start, &v_end);
-  av1_domaintxfmrf_restoration(data + h_start + v_start * stride,
-                               h_end - h_start, v_end - v_start, stride,
-                               rst->rsi->domaintxfmrf_info[tile_idx].sigma_r);
+  av1_domaintxfmrf_restoration(
+      data + h_start + v_start * stride, h_end - h_start, v_end - v_start,
+      stride, rst->rsi->domaintxfmrf_info[tile_idx].sigma_r,
+      dst + h_start + v_start * dst_stride, dst_stride);
 }
 
 static void loop_domaintxfmrf_filter(uint8_t *data, int width, int height,
                                      int stride, RestorationInternal *rst,
-                                     uint8_t *tmpdata, int tmpstride) {
+                                     uint8_t *tmpdata, int tmpstride,
+                                     uint8_t *dst, int dst_stride) {
   int tile_idx;
   (void)tmpdata;
   (void)tmpstride;
   for (tile_idx = 0; tile_idx < rst->ntiles; ++tile_idx) {
     loop_domaintxfmrf_filter_tile(data, tile_idx, width, height, stride, rst,
-                                  NULL);
+                                  dst, dst_stride);
   }
 }
 
 static void loop_switchable_filter(uint8_t *data, int width, int height,
                                    int stride, RestorationInternal *rst,
-                                   uint8_t *tmpdata, int tmpstride) {
+                                   uint8_t *tmpdata, int tmpstride,
+                                   uint8_t *dst, int dst_stride) {
   int i, tile_idx;
-  uint8_t *data_p, *tmpdata_p;
   uint8_t *tmpbuf = aom_malloc(SGRPROJ_TMPBUF_SIZE);
-
   // Initialize tmp buffer
-  data_p = data;
-  tmpdata_p = tmpdata;
+  uint8_t *data_p = data;
+  uint8_t *tmpdata_p = tmpdata;
   for (i = 0; i < height; ++i) {
     memcpy(tmpdata_p, data_p, sizeof(*data_p) * width);
     data_p += stride;
     tmpdata_p += tmpstride;
   }
+  copy_border(data, width, height, stride, dst, dst_stride);
   for (tile_idx = 0; tile_idx < rst->ntiles; ++tile_idx) {
-    if (rst->rsi->restoration_type[tile_idx] == RESTORE_WIENER) {
+    if (rst->rsi->restoration_type[tile_idx] == RESTORE_NONE) {
+      loop_copy_tile(data, tile_idx, 0, 0, width, height, stride, rst, dst,
+                     dst_stride);
+    } else if (rst->rsi->restoration_type[tile_idx] == RESTORE_WIENER) {
       loop_wiener_filter_tile(data, tile_idx, width, height, stride, rst,
-                              tmpdata, tmpstride);
+                              tmpdata, tmpstride, dst, dst_stride);
     } else if (rst->rsi->restoration_type[tile_idx] == RESTORE_SGRPROJ) {
       loop_sgrproj_filter_tile(data, tile_idx, width, height, stride, rst,
-                               tmpbuf);
+                               tmpbuf, dst, dst_stride);
     } else if (rst->rsi->restoration_type[tile_idx] == RESTORE_DOMAINTXFMRF) {
       loop_domaintxfmrf_filter_tile(data, tile_idx, width, height, stride, rst,
-                                    tmpbuf);
+                                    dst, dst_stride);
     }
   }
   aom_free(tmpbuf);
 }
 
 #if CONFIG_AOM_HIGHBITDEPTH
+static void copy_border_highbd(uint16_t *data, int width, int height,
+                               int stride, uint16_t *dst, int dst_stride) {
+  int i;
+  for (i = RESTORATION_HALFWIN; i < height - RESTORATION_HALFWIN; ++i) {
+    memcpy(dst + i * dst_stride, data + i * stride,
+           RESTORATION_HALFWIN * sizeof(*dst));
+    memcpy(dst + i * dst_stride + (width - RESTORATION_HALFWIN),
+           data + i * stride + (width - RESTORATION_HALFWIN),
+           RESTORATION_HALFWIN * sizeof(*dst));
+  }
+  for (i = 0; i < RESTORATION_HALFWIN; ++i) {
+    memcpy(dst + i * dst_stride, data + i * stride, width * sizeof(*dst));
+  }
+  for (i = height - RESTORATION_HALFWIN; i < height; ++i)
+    memcpy(dst + i * dst_stride, data + i * stride, width * sizeof(*dst));
+}
+
+static void loop_copy_tile_highbd(uint16_t *data, int tile_idx, int subtile_idx,
+                                  int subtile_bits, int width, int height,
+                                  int stride, RestorationInternal *rst,
+                                  uint16_t *dst, int dst_stride) {
+  const int tile_width = rst->tile_width >> rst->subsampling_x;
+  const int tile_height = rst->tile_height >> rst->subsampling_y;
+  int i;
+  int h_start, h_end, v_start, v_end;
+  av1_get_rest_tile_limits(tile_idx, subtile_idx, subtile_bits, rst->nhtiles,
+                           rst->nvtiles, tile_width, tile_height, width, height,
+                           0, 0, &h_start, &h_end, &v_start, &v_end);
+  for (i = v_start; i < v_end; ++i)
+    memcpy(dst + i * dst_stride + h_start, data + i * stride + h_start,
+           (h_end - h_start) * sizeof(*dst));
+}
+
 uint16_t hor_sym_filter_highbd(uint16_t *d, int *hfilter, int bd) {
   int32_t s =
       (1 << (RESTORATION_FILT_BITS - 1)) + d[0] * hfilter[RESTORATION_HALFWIN];
@@ -712,14 +803,19 @@
                                            int width, int height, int stride,
                                            RestorationInternal *rst,
                                            uint16_t *tmpdata, int tmpstride,
-                                           int bit_depth) {
+                                           int bit_depth, uint16_t *dst,
+                                           int dst_stride) {
   const int tile_width = rst->tile_width >> rst->subsampling_x;
   const int tile_height = rst->tile_height >> rst->subsampling_y;
   int h_start, h_end, v_start, v_end;
   int i, j;
-  uint16_t *data_p, *tmpdata_p;
+  uint16_t *data_p, *tmpdata_p, *dst_p;
 
-  if (rst->rsi->wiener_info[tile_idx].level == 0) return;
+  if (rst->rsi->wiener_info[tile_idx].level == 0) {
+    loop_copy_tile_highbd(data, tile_idx, 0, 0, width, height, stride, rst, dst,
+                          dst_stride);
+    return;
+  }
   // Filter row-wise
   av1_get_rest_tile_limits(tile_idx, 0, 0, rst->nhtiles, rst->nvtiles,
                            tile_width, tile_height, width, height, 1, 0,
@@ -738,15 +834,15 @@
   av1_get_rest_tile_limits(tile_idx, 0, 0, rst->nhtiles, rst->nvtiles,
                            tile_width, tile_height, width, height, 0, 1,
                            &h_start, &h_end, &v_start, &v_end);
-  data_p = data + h_start + v_start * stride;
+  dst_p = dst + h_start + v_start * dst_stride;
   tmpdata_p = tmpdata + h_start + v_start * tmpstride;
   for (i = 0; i < (v_end - v_start); ++i) {
     for (j = 0; j < (h_end - h_start); ++j) {
-      *data_p++ = ver_sym_filter_highbd(tmpdata_p++, tmpstride,
-                                        rst->rsi->wiener_info[tile_idx].vfilter,
-                                        bit_depth);
+      *dst_p++ = ver_sym_filter_highbd(tmpdata_p++, tmpstride,
+                                       rst->rsi->wiener_info[tile_idx].vfilter,
+                                       bit_depth);
     }
-    data_p += stride - (h_end - h_start);
+    dst_p += dst_stride - (h_end - h_start);
     tmpdata_p += tmpstride - (h_end - h_start);
   }
 }
@@ -754,39 +850,47 @@
 static void loop_wiener_filter_highbd(uint8_t *data8, int width, int height,
                                       int stride, RestorationInternal *rst,
                                       uint8_t *tmpdata8, int tmpstride,
-                                      int bit_depth) {
+                                      int bit_depth, uint8_t *dst8,
+                                      int dst_stride) {
   uint16_t *data = CONVERT_TO_SHORTPTR(data8);
   uint16_t *tmpdata = CONVERT_TO_SHORTPTR(tmpdata8);
+  uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
   int tile_idx, i;
-  uint16_t *data_p, *tmpdata_p;
 
   // Initialize tmp buffer
-  data_p = data;
-  tmpdata_p = tmpdata;
+  uint16_t *data_p = data;
+  uint16_t *tmpdata_p = tmpdata;
   for (i = 0; i < height; ++i) {
     memcpy(tmpdata_p, data_p, sizeof(*data_p) * width);
     data_p += stride;
     tmpdata_p += tmpstride;
   }
+  copy_border_highbd(data, width, height, stride, dst, dst_stride);
   for (tile_idx = 0; tile_idx < rst->ntiles; ++tile_idx) {
     loop_wiener_filter_tile_highbd(data, tile_idx, width, height, stride, rst,
-                                   tmpdata, tmpstride, bit_depth);
+                                   tmpdata, tmpstride, bit_depth, dst,
+                                   dst_stride);
   }
 }
 
 static void loop_sgrproj_filter_tile_highbd(uint16_t *data, int tile_idx,
                                             int width, int height, int stride,
                                             RestorationInternal *rst,
-                                            int bit_depth, void *tmpbuf) {
+                                            int bit_depth, void *tmpbuf,
+                                            uint16_t *dst, int dst_stride) {
   const int tile_width = rst->tile_width >> rst->subsampling_x;
   const int tile_height = rst->tile_height >> rst->subsampling_y;
   int i, j;
   int h_start, h_end, v_start, v_end;
-  uint16_t *data_p;
+  uint16_t *data_p, *dst_p;
   int64_t *dat = (int64_t *)tmpbuf;
   tmpbuf = (uint8_t *)tmpbuf + RESTORATION_TILEPELS_MAX * sizeof(*dat);
 
-  if (rst->rsi->sgrproj_info[tile_idx].level == 0) return;
+  if (rst->rsi->sgrproj_info[tile_idx].level == 0) {
+    loop_copy_tile_highbd(data, tile_idx, 0, 0, width, height, stride, rst, dst,
+                          dst_stride);
+    return;
+  }
   av1_get_rest_tile_limits(tile_idx, 0, 0, rst->nhtiles, rst->nvtiles,
                            tile_width, tile_height, width, height, 0, 0,
                            &h_start, &h_end, &v_start, &v_end);
@@ -800,9 +904,10 @@
                                h_end - h_start, bit_depth,
                                rst->rsi->sgrproj_info[tile_idx].ep,
                                rst->rsi->sgrproj_info[tile_idx].xqd, tmpbuf);
+  dst_p = dst + h_start + v_start * dst_stride;
   for (i = 0; i < (v_end - v_start); ++i) {
     for (j = 0; j < (h_end - h_start); ++j) {
-      data_p[i * stride + j] =
+      dst_p[i * dst_stride + j] =
           clip_pixel_highbd((int)dat[i * (h_end - h_start) + j], bit_depth);
     }
   }
@@ -811,15 +916,17 @@
 static void loop_sgrproj_filter_highbd(uint8_t *data8, int width, int height,
                                        int stride, RestorationInternal *rst,
                                        uint8_t *tmpdata8, int tmpstride,
-                                       int bit_depth) {
+                                       int bit_depth, uint8_t *dst8,
+                                       int dst_stride) {
   int tile_idx;
   uint16_t *data = CONVERT_TO_SHORTPTR(data8);
   uint8_t *tmpbuf = aom_malloc(SGRPROJ_TMPBUF_SIZE);
+  uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
   (void)tmpdata8;
   (void)tmpstride;
   for (tile_idx = 0; tile_idx < rst->ntiles; ++tile_idx) {
     loop_sgrproj_filter_tile_highbd(data, tile_idx, width, height, stride, rst,
-                                    bit_depth, tmpbuf);
+                                    bit_depth, tmpbuf, dst, dst_stride);
   }
   aom_free(tmpbuf);
 }
@@ -892,7 +999,8 @@
 }
 
 void av1_domaintxfmrf_restoration_highbd(uint16_t *dgd, int width, int height,
-                                         int stride, int param, int bit_depth) {
+                                         int stride, int param, int bit_depth,
+                                         uint16_t *dst, int dst_stride) {
   int32_t dat[RESTORATION_TILEPELS_MAX];
   int i, j, t;
   for (i = 0; i < height; ++i) {
@@ -909,73 +1017,85 @@
   }
   for (i = 0; i < height; ++i) {
     for (j = 0; j < width; ++j) {
-      dgd[i * stride + j] = clip_pixel_highbd(dat[i * width + j], bit_depth);
+      dst[i * dst_stride + j] =
+          clip_pixel_highbd(dat[i * width + j], bit_depth);
     }
   }
 }
 
-static void loop_domaintxfmrf_filter_tile_highbd(uint16_t *data, int tile_idx,
-                                                 int width, int height,
-                                                 int stride,
-                                                 RestorationInternal *rst,
-                                                 int bit_depth, void *tmpbuf) {
+static void loop_domaintxfmrf_filter_tile_highbd(
+    uint16_t *data, int tile_idx, int width, int height, int stride,
+    RestorationInternal *rst, int bit_depth, uint16_t *dst, int dst_stride) {
   const int tile_width = rst->tile_width >> rst->subsampling_x;
   const int tile_height = rst->tile_height >> rst->subsampling_y;
   int h_start, h_end, v_start, v_end;
-  (void)tmpbuf;
 
-  if (rst->rsi->domaintxfmrf_info[tile_idx].level == 0) return;
+  if (rst->rsi->domaintxfmrf_info[tile_idx].level == 0) {
+    loop_copy_tile_highbd(data, tile_idx, 0, 0, width, height, stride, rst, dst,
+                          dst_stride);
+    return;
+  }
   av1_get_rest_tile_limits(tile_idx, 0, 0, rst->nhtiles, rst->nvtiles,
                            tile_width, tile_height, width, height, 0, 0,
                            &h_start, &h_end, &v_start, &v_end);
   av1_domaintxfmrf_restoration_highbd(
       data + h_start + v_start * stride, h_end - h_start, v_end - v_start,
-      stride, rst->rsi->domaintxfmrf_info[tile_idx].sigma_r, bit_depth);
+      stride, rst->rsi->domaintxfmrf_info[tile_idx].sigma_r, bit_depth,
+      dst + h_start + v_start * dst_stride, dst_stride);
 }
 
 static void loop_domaintxfmrf_filter_highbd(uint8_t *data8, int width,
                                             int height, int stride,
                                             RestorationInternal *rst,
                                             uint8_t *tmpdata, int tmpstride,
-                                            int bit_depth) {
+                                            int bit_depth, uint8_t *dst8,
+                                            int dst_stride) {
   int tile_idx;
   uint16_t *data = CONVERT_TO_SHORTPTR(data8);
+  uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
   (void)tmpdata;
   (void)tmpstride;
   for (tile_idx = 0; tile_idx < rst->ntiles; ++tile_idx) {
     loop_domaintxfmrf_filter_tile_highbd(data, tile_idx, width, height, stride,
-                                         rst, bit_depth, NULL);
+                                         rst, bit_depth, dst, dst_stride);
   }
 }
 
 static void loop_switchable_filter_highbd(uint8_t *data8, int width, int height,
                                           int stride, RestorationInternal *rst,
                                           uint8_t *tmpdata8, int tmpstride,
-                                          int bit_depth) {
+                                          int bit_depth, uint8_t *dst8,
+                                          int dst_stride) {
   uint16_t *data = CONVERT_TO_SHORTPTR(data8);
   uint16_t *tmpdata = CONVERT_TO_SHORTPTR(tmpdata8);
   uint8_t *tmpbuf = aom_malloc(SGRPROJ_TMPBUF_SIZE);
+  uint16_t *dst = CONVERT_TO_SHORTPTR(dst8);
   int i, tile_idx;
-  uint16_t *data_p, *tmpdata_p;
 
   // Initialize tmp buffer
-  data_p = data;
-  tmpdata_p = tmpdata;
+  uint16_t *data_p = data;
+  uint16_t *tmpdata_p = tmpdata;
   for (i = 0; i < height; ++i) {
     memcpy(tmpdata_p, data_p, sizeof(*data_p) * width);
     data_p += stride;
     tmpdata_p += tmpstride;
   }
+  copy_border_highbd(data, width, height, stride, dst, dst_stride);
   for (tile_idx = 0; tile_idx < rst->ntiles; ++tile_idx) {
-    if (rst->rsi->restoration_type[tile_idx] == RESTORE_WIENER) {
+    if (rst->rsi->restoration_type[tile_idx] == RESTORE_NONE) {
+      loop_copy_tile_highbd(data, tile_idx, 0, 0, width, height, stride, rst,
+                            dst, dst_stride);
+    } else if (rst->rsi->restoration_type[tile_idx] == RESTORE_WIENER) {
       loop_wiener_filter_tile_highbd(data, tile_idx, width, height, stride, rst,
-                                     tmpdata, tmpstride, bit_depth);
+                                     tmpdata, tmpstride, bit_depth, dst,
+                                     dst_stride);
     } else if (rst->rsi->restoration_type[tile_idx] == RESTORE_SGRPROJ) {
       loop_sgrproj_filter_tile_highbd(data, tile_idx, width, height, stride,
-                                      rst, bit_depth, tmpbuf);
+                                      rst, bit_depth, tmpbuf, dst, dst_stride);
     } else if (rst->rsi->restoration_type[tile_idx] == RESTORE_DOMAINTXFMRF) {
       loop_domaintxfmrf_filter_tile_highbd(data, tile_idx, width, height,
-                                           stride, rst, bit_depth, tmpbuf);
+                                           stride, rst, bit_depth, dst,
+                                           dst_stride);
     }
   }
   aom_free(tmpbuf);
@@ -983,7 +1103,8 @@
 #endif  // CONFIG_AOM_HIGHBITDEPTH
 
 void av1_loop_restoration_rows(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
-                               int start_mi_row, int end_mi_row, int y_only) {
+                               int start_mi_row, int end_mi_row, int y_only,
+                               YV12_BUFFER_CONFIG *dst) {
   const int ywidth = frame->y_crop_width;
   const int ystride = frame->y_stride;
   const int uvwidth = frame->uv_crop_width;
@@ -1009,14 +1130,23 @@
       restore_funcs_highbd[cm->rst_internal.rsi->frame_restoration_type];
 #endif  // CONFIG_AOM_HIGHBITDEPTH
   YV12_BUFFER_CONFIG tmp_buf;
-
-  if (cm->rst_internal.rsi->frame_restoration_type == RESTORE_NONE) return;
-
-  memset(&tmp_buf, 0, sizeof(YV12_BUFFER_CONFIG));
+  YV12_BUFFER_CONFIG dst_;
 
   yend = AOMMIN(yend, cm->height);
   uvend = AOMMIN(uvend, cm->subsampling_y ? (cm->height + 1) >> 1 : cm->height);
 
+  if (cm->rst_internal.rsi->frame_restoration_type == RESTORE_NONE) {
+    if (dst) {
+      if (y_only)
+        aom_yv12_copy_y(frame, dst);
+      else
+        aom_yv12_copy_frame(frame, dst);
+    }
+    return;
+  }
+
+  memset(&tmp_buf, 0, sizeof(YV12_BUFFER_CONFIG));
+
   if (aom_realloc_frame_buffer(
           &tmp_buf, cm->width, cm->height, cm->subsampling_x, cm->subsampling_y,
 #if CONFIG_AOM_HIGHBITDEPTH
@@ -1028,19 +1158,32 @@
 
   if (y_only == 0)
     y_only = override_y_only[cm->rst_internal.rsi->frame_restoration_type];
+  if (!dst) {
+    dst = &dst_;
+    memset(dst, 0, sizeof(YV12_BUFFER_CONFIG));
+    if (aom_realloc_frame_buffer(
+            dst, cm->width, cm->height, cm->subsampling_x, cm->subsampling_y,
+#if CONFIG_AOM_HIGHBITDEPTH
+            cm->use_highbitdepth,
+#endif
+            AOM_BORDER_IN_PIXELS, cm->byte_alignment, NULL, NULL, NULL) < 0)
+      aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
+                         "Failed to allocate restoration dst buffer");
+  }
 
 #if CONFIG_AOM_HIGHBITDEPTH
   if (cm->use_highbitdepth)
     restore_func_highbd(frame->y_buffer + ystart * ystride, ywidth,
                         yend - ystart, ystride, &cm->rst_internal,
                         tmp_buf.y_buffer + ystart * tmp_buf.y_stride,
-                        tmp_buf.y_stride, cm->bit_depth);
+                        tmp_buf.y_stride, cm->bit_depth,
+                        dst->y_buffer + ystart * dst->y_stride, dst->y_stride);
   else
 #endif  // CONFIG_AOM_HIGHBITDEPTH
     restore_func(frame->y_buffer + ystart * ystride, ywidth, yend - ystart,
                  ystride, &cm->rst_internal,
-                 tmp_buf.y_buffer + ystart * tmp_buf.y_stride,
-                 tmp_buf.y_stride);
+                 tmp_buf.y_buffer + ystart * tmp_buf.y_stride, tmp_buf.y_stride,
+                 dst->y_buffer + ystart * dst->y_stride, dst->y_stride);
   if (!y_only) {
     cm->rst_internal.subsampling_x = cm->subsampling_x;
     cm->rst_internal.subsampling_y = cm->subsampling_y;
@@ -1049,31 +1192,45 @@
       restore_func_highbd(frame->u_buffer + uvstart * uvstride, uvwidth,
                           uvend - uvstart, uvstride, &cm->rst_internal,
                           tmp_buf.u_buffer + uvstart * tmp_buf.uv_stride,
-                          tmp_buf.uv_stride, cm->bit_depth);
+                          tmp_buf.uv_stride, cm->bit_depth,
+                          dst->u_buffer + uvstart * dst->uv_stride,
+                          dst->uv_stride);
       restore_func_highbd(frame->v_buffer + uvstart * uvstride, uvwidth,
                           uvend - uvstart, uvstride, &cm->rst_internal,
                           tmp_buf.v_buffer + uvstart * tmp_buf.uv_stride,
-                          tmp_buf.uv_stride, cm->bit_depth);
+                          tmp_buf.uv_stride, cm->bit_depth,
+                          dst->v_buffer + uvstart * dst->uv_stride,
+                          dst->uv_stride);
     } else {
 #endif  // CONFIG_AOM_HIGHBITDEPTH
       restore_func(frame->u_buffer + uvstart * uvstride, uvwidth,
                    uvend - uvstart, uvstride, &cm->rst_internal,
                    tmp_buf.u_buffer + uvstart * tmp_buf.uv_stride,
-                   tmp_buf.uv_stride);
+                   tmp_buf.uv_stride, dst->u_buffer + uvstart * dst->uv_stride,
+                   dst->uv_stride);
       restore_func(frame->v_buffer + uvstart * uvstride, uvwidth,
                    uvend - uvstart, uvstride, &cm->rst_internal,
                    tmp_buf.v_buffer + uvstart * tmp_buf.uv_stride,
-                   tmp_buf.uv_stride);
+                   tmp_buf.uv_stride, dst->v_buffer + uvstart * dst->uv_stride,
+                   dst->uv_stride);
 #if CONFIG_AOM_HIGHBITDEPTH
     }
 #endif  // CONFIG_AOM_HIGHBITDEPTH
   }
+
   aom_free_frame_buffer(&tmp_buf);
+  if (dst == &dst_) {
+    if (y_only)
+      aom_yv12_copy_y(dst, frame);
+    else
+      aom_yv12_copy_frame(dst, frame);
+    aom_free_frame_buffer(dst);
+  }
 }
 
 void av1_loop_restoration_frame(YV12_BUFFER_CONFIG *frame, AV1_COMMON *cm,
                                 RestorationInfo *rsi, int y_only,
-                                int partial_frame) {
+                                int partial_frame, YV12_BUFFER_CONFIG *dst) {
   int start_mi_row, end_mi_row, mi_rows_to_filter;
   if (rsi->frame_restoration_type != RESTORE_NONE) {
     start_mi_row = 0;
@@ -1087,6 +1244,6 @@
     av1_loop_restoration_init(&cm->rst_internal, rsi,
                               cm->frame_type == KEY_FRAME, cm->width,
                               cm->height);
-    av1_loop_restoration_rows(frame, cm, start_mi_row, end_mi_row, y_only);
+    av1_loop_restoration_rows(frame, cm, start_mi_row, end_mi_row, y_only, dst);
   }
 }
diff --git a/av1/common/restoration.h b/av1/common/restoration.h
index 63e78a1..2c5f32f 100644
--- a/av1/common/restoration.h
+++ b/av1/common/restoration.h
@@ -192,19 +192,22 @@
 void av1_selfguided_restoration(int64_t *dgd, int width, int height, int stride,
                                 int bit_depth, int r, int eps, void *tmpbuf);
 void av1_domaintxfmrf_restoration(uint8_t *dgd, int width, int height,
-                                  int stride, int param);
+                                  int stride, int param, uint8_t *dst,
+                                  int dst_stride);
 #if CONFIG_AOM_HIGHBITDEPTH
 void av1_domaintxfmrf_restoration_highbd(uint16_t *dgd, int width, int height,
-                                         int stride, int param, int bit_depth);
+                                         int stride, int param, int bit_depth,
+                                         uint16_t *dst, int dst_stride);
 #endif  // CONFIG_AOM_HIGHBITDEPTH
 void decode_xq(int *xqd, int *xq);
 void av1_loop_restoration_init(RestorationInternal *rst, RestorationInfo *rsi,
                                int kf, int width, int height);
 void av1_loop_restoration_frame(YV12_BUFFER_CONFIG *frame, struct AV1Common *cm,
                                 RestorationInfo *rsi, int y_only,
-                                int partial_frame);
+                                int partial_frame, YV12_BUFFER_CONFIG *dst);
 void av1_loop_restoration_rows(YV12_BUFFER_CONFIG *frame, struct AV1Common *cm,
-                               int start_mi_row, int end_mi_row, int y_only);
+                               int start_mi_row, int end_mi_row, int y_only,
+                               YV12_BUFFER_CONFIG *dst);
 void av1_loop_restoration_precal();
 #ifdef __cplusplus
 }  // extern "C"
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 304dc59..d70eaf1 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -4518,7 +4518,7 @@
     av1_loop_restoration_init(&cm->rst_internal, &cm->rst_info,
                               cm->frame_type == KEY_FRAME, cm->width,
                               cm->height);
-    av1_loop_restoration_rows(new_fb, cm, 0, cm->mi_rows, 0);
+    av1_loop_restoration_rows(new_fb, cm, 0, cm->mi_rows, 0, NULL);
   }
 #endif  // CONFIG_LOOP_RESTORATION
 
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index f2f031f..3b95405 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -3432,7 +3432,7 @@
     av1_loop_restoration_init(&cm->rst_internal, &cm->rst_info,
                               cm->frame_type == KEY_FRAME, cm->width,
                               cm->height);
-    av1_loop_restoration_rows(cm->frame_to_show, cm, 0, cm->mi_rows, 0);
+    av1_loop_restoration_rows(cm->frame_to_show, cm, 0, cm->mi_rows, 0, NULL);
   }
 #endif  // CONFIG_LOOP_RESTORATION
 
diff --git a/av1/encoder/pickrst.c b/av1/encoder/pickrst.c
index 64687a2..ed4a849 100644
--- a/av1/encoder/pickrst.c
+++ b/av1/encoder/pickrst.c
@@ -32,25 +32,26 @@
 typedef double (*search_restore_type)(const YV12_BUFFER_CONFIG *src,
                                       AV1_COMP *cpi, int filter_level,
                                       int partial_frame, RestorationInfo *info,
-                                      double *best_tile_cost);
+                                      double *best_tile_cost,
+                                      YV12_BUFFER_CONFIG *dst_frame);
 
 const int frame_level_restore_bits[RESTORE_TYPES] = { 2, 2, 3, 3, 2 };
 
 static int64_t sse_restoration_tile(const YV12_BUFFER_CONFIG *src,
-                                    AV1_COMMON *const cm, int h_start,
+                                    const YV12_BUFFER_CONFIG *dst,
+                                    const AV1_COMMON *cm, int h_start,
                                     int width, int v_start, int height) {
   int64_t filt_err;
 #if CONFIG_AOM_HIGHBITDEPTH
   if (cm->use_highbitdepth) {
-    filt_err = aom_highbd_get_y_sse_part(src, cm->frame_to_show, h_start, width,
-                                         v_start, height);
+    filt_err =
+        aom_highbd_get_y_sse_part(src, dst, h_start, width, v_start, height);
   } else {
-    filt_err = aom_get_y_sse_part(src, cm->frame_to_show, h_start, width,
-                                  v_start, height);
+    filt_err = aom_get_y_sse_part(src, dst, h_start, width, v_start, height);
   }
 #else
-  filt_err = aom_get_y_sse_part(src, cm->frame_to_show, h_start, width, v_start,
-                                height);
+  (void)cm;
+  filt_err = aom_get_y_sse_part(src, dst, h_start, width, v_start, height);
 #endif  // CONFIG_AOM_HIGHBITDEPTH
   return filt_err;
 }
@@ -58,7 +59,8 @@
 static int64_t try_restoration_tile(const YV12_BUFFER_CONFIG *src,
                                     AV1_COMP *const cpi, RestorationInfo *rsi,
                                     int partial_frame, int tile_idx,
-                                    int subtile_idx, int subtile_bits) {
+                                    int subtile_idx, int subtile_bits,
+                                    YV12_BUFFER_CONFIG *dst_frame) {
   AV1_COMMON *const cm = &cpi->common;
   int64_t filt_err;
   int tile_width, tile_height, nhtiles, nvtiles;
@@ -67,37 +69,36 @@
                                          &tile_height, &nhtiles, &nvtiles);
   (void)ntiles;
 
-  av1_loop_restoration_frame(cm->frame_to_show, cm, rsi, 1, partial_frame);
+  av1_loop_restoration_frame(cm->frame_to_show, cm, rsi, 1, partial_frame,
+                             dst_frame);
   av1_get_rest_tile_limits(tile_idx, subtile_idx, subtile_bits, nhtiles,
                            nvtiles, tile_width, tile_height, cm->width,
                            cm->height, 0, 0, &h_start, &h_end, &v_start,
                            &v_end);
-  filt_err = sse_restoration_tile(src, cm, h_start, h_end - h_start, v_start,
-                                  v_end - v_start);
+  filt_err = sse_restoration_tile(src, dst_frame, cm, h_start, h_end - h_start,
+                                  v_start, v_end - v_start);
 
-  // Re-instate the unfiltered frame
-  aom_yv12_copy_y(&cpi->last_frame_db, cm->frame_to_show);
   return filt_err;
 }
 
 static int64_t try_restoration_frame(const YV12_BUFFER_CONFIG *src,
                                      AV1_COMP *const cpi, RestorationInfo *rsi,
-                                     int partial_frame) {
+                                     int partial_frame,
+                                     YV12_BUFFER_CONFIG *dst_frame) {
   AV1_COMMON *const cm = &cpi->common;
   int64_t filt_err;
-  av1_loop_restoration_frame(cm->frame_to_show, cm, rsi, 1, partial_frame);
+  av1_loop_restoration_frame(cm->frame_to_show, cm, rsi, 1, partial_frame,
+                             dst_frame);
 #if CONFIG_AOM_HIGHBITDEPTH
   if (cm->use_highbitdepth) {
-    filt_err = aom_highbd_get_y_sse(src, cm->frame_to_show);
+    filt_err = aom_highbd_get_y_sse(src, dst_frame);
   } else {
-    filt_err = aom_get_y_sse(src, cm->frame_to_show);
+    filt_err = aom_get_y_sse(src, dst_frame);
   }
 #else
-  filt_err = aom_get_y_sse(src, cm->frame_to_show);
+  filt_err = aom_get_y_sse(src, dst_frame);
 #endif  // CONFIG_AOM_HIGHBITDEPTH
 
-  // Re-instate the unfiltered frame
-  aom_yv12_copy_y(&cpi->last_frame_db, cm->frame_to_show);
   return filt_err;
 }
 
@@ -237,7 +238,8 @@
 
 static double search_sgrproj(const YV12_BUFFER_CONFIG *src, AV1_COMP *cpi,
                              int filter_level, int partial_frame,
-                             RestorationInfo *info, double *best_tile_cost) {
+                             RestorationInfo *info, double *best_tile_cost,
+                             YV12_BUFFER_CONFIG *dst_frame) {
   SgrprojInfo *sgrproj_info = info->sgrproj_info;
   double err, cost_norestore, cost_sgrproj;
   int bits;
@@ -268,8 +270,8 @@
     av1_get_rest_tile_limits(tile_idx, 0, 0, nhtiles, nvtiles, tile_width,
                              tile_height, cm->width, cm->height, 0, 0, &h_start,
                              &h_end, &v_start, &v_end);
-    err = sse_restoration_tile(src, cm, h_start, h_end - h_start, v_start,
-                               v_end - v_start);
+    err = sse_restoration_tile(src, cm->frame_to_show, cm, h_start,
+                               h_end - h_start, v_start, v_end - v_start);
     // #bits when a tile is not restored
     bits = av1_cost_bit(RESTORE_NONE_SGRPROJ_PROB, 0);
     cost_norestore = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
@@ -285,7 +287,8 @@
 #endif  // CONFIG_AOM_HIGHBITDEPTH
         &rsi.sgrproj_info[tile_idx].ep, rsi.sgrproj_info[tile_idx].xqd, tmpbuf);
     rsi.sgrproj_info[tile_idx].level = 1;
-    err = try_restoration_tile(src, cpi, &rsi, partial_frame, tile_idx, 0, 0);
+    err = try_restoration_tile(src, cpi, &rsi, partial_frame, tile_idx, 0, 0,
+                               dst_frame);
     bits = SGRPROJ_BITS << AV1_PROB_COST_SHIFT;
     bits += av1_cost_bit(RESTORE_NONE_SGRPROJ_PROB, 1);
     cost_sgrproj = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
@@ -313,7 +316,7 @@
       bits += (SGRPROJ_BITS << AV1_PROB_COST_SHIFT);
     }
   }
-  err = try_restoration_frame(src, cpi, &rsi, partial_frame);
+  err = try_restoration_frame(src, cpi, &rsi, partial_frame, dst_frame);
   cost_sgrproj = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
 
   aom_free(rsi.sgrproj_info);
@@ -363,7 +366,7 @@
   const int second_p_step = 2;
   const int third_p_range = second_p_step >> 1;
   const int third_p_step = 1;
-  int i, p, best_p0, best_p = -1;
+  int p, best_p0, best_p = -1;
   int64_t best_sse = INT64_MAX, sse;
   if (bit_depth == 8) {
     uint8_t *tmp = (uint8_t *)aom_malloc(width * height * sizeof(*tmp));
@@ -371,10 +374,8 @@
     uint8_t *src = src8;
     // First phase
     for (p = first_p_step / 2; p < DOMAINTXFMRF_PARAMS; p += first_p_step) {
-      for (i = 0; i < height; ++i) {
-        memcpy(&tmp[i * width], &dgd[i * dgd_stride], width * sizeof(dgd[0]));
-      }
-      av1_domaintxfmrf_restoration(tmp, width, height, width, p);
+      av1_domaintxfmrf_restoration(dgd, width, height, dgd_stride, p, tmp,
+                                   width);
       sse = compute_sse(tmp, width, height, width, src, src_stride);
       if (sse < best_sse || best_p == -1) {
         best_p = p;
@@ -386,10 +387,8 @@
     for (p = best_p0 - second_p_range; p <= best_p0 + second_p_range;
          p += second_p_step) {
       if (p < 0 || p == best_p || p >= DOMAINTXFMRF_PARAMS) continue;
-      for (i = 0; i < height; ++i) {
-        memcpy(&tmp[i * width], &dgd[i * dgd_stride], width * sizeof(dgd[0]));
-      }
-      av1_domaintxfmrf_restoration(tmp, width, height, width, p);
+      av1_domaintxfmrf_restoration(dgd, width, height, dgd_stride, p, tmp,
+                                   width);
       sse = compute_sse(tmp, width, height, width, src, src_stride);
       if (sse < best_sse) {
         best_p = p;
@@ -401,10 +400,8 @@
     for (p = best_p0 - third_p_range; p <= best_p0 + third_p_range;
          p += third_p_step) {
       if (p < 0 || p == best_p || p >= DOMAINTXFMRF_PARAMS) continue;
-      for (i = 0; i < height; ++i) {
-        memcpy(&tmp[i * width], &dgd[i * dgd_stride], width * sizeof(dgd[0]));
-      }
-      av1_domaintxfmrf_restoration(tmp, width, height, width, p);
+      av1_domaintxfmrf_restoration(dgd, width, height, dgd_stride, p, tmp,
+                                   width);
       sse = compute_sse(tmp, width, height, width, src, src_stride);
       if (sse < best_sse) {
         best_p = p;
@@ -419,11 +416,8 @@
     uint16_t *src = CONVERT_TO_SHORTPTR(src8);
     // First phase
     for (p = first_p_step / 2; p < DOMAINTXFMRF_PARAMS; p += first_p_step) {
-      for (i = 0; i < height; ++i) {
-        memcpy(&tmp[i * width], &dgd[i * dgd_stride], width * sizeof(dgd[0]));
-      }
-      av1_domaintxfmrf_restoration_highbd(tmp, width, height, width, p,
-                                          bit_depth);
+      av1_domaintxfmrf_restoration_highbd(dgd, width, height, dgd_stride, p,
+                                          bit_depth, tmp, width);
       sse = compute_sse_highbd(tmp, width, height, width, src, src_stride);
       if (sse < best_sse || best_p == -1) {
         best_p = p;
@@ -435,11 +429,8 @@
     for (p = best_p0 - second_p_range; p <= best_p0 + second_p_range;
          p += second_p_step) {
       if (p < 0 || p == best_p || p >= DOMAINTXFMRF_PARAMS) continue;
-      for (i = 0; i < height; ++i) {
-        memcpy(&tmp[i * width], &dgd[i * dgd_stride], width * sizeof(dgd[0]));
-      }
-      av1_domaintxfmrf_restoration_highbd(tmp, width, height, width, p,
-                                          bit_depth);
+      av1_domaintxfmrf_restoration_highbd(dgd, width, height, dgd_stride, p,
+                                          bit_depth, tmp, width);
       sse = compute_sse_highbd(tmp, width, height, width, src, src_stride);
       if (sse < best_sse) {
         best_p = p;
@@ -451,11 +442,8 @@
     for (p = best_p0 - third_p_range; p <= best_p0 + third_p_range;
          p += third_p_step) {
       if (p < 0 || p == best_p || p >= DOMAINTXFMRF_PARAMS) continue;
-      for (i = 0; i < height; ++i) {
-        memcpy(&tmp[i * width], &dgd[i * dgd_stride], width * sizeof(dgd[0]));
-      }
-      av1_domaintxfmrf_restoration_highbd(tmp, width, height, width, p,
-                                          bit_depth);
+      av1_domaintxfmrf_restoration_highbd(dgd, width, height, dgd_stride, p,
+                                          bit_depth, tmp, width);
       sse = compute_sse_highbd(tmp, width, height, width, src, src_stride);
       if (sse < best_sse) {
         best_p = p;
@@ -472,8 +460,8 @@
 
 static double search_domaintxfmrf(const YV12_BUFFER_CONFIG *src, AV1_COMP *cpi,
                                   int filter_level, int partial_frame,
-                                  RestorationInfo *info,
-                                  double *best_tile_cost) {
+                                  RestorationInfo *info, double *best_tile_cost,
+                                  YV12_BUFFER_CONFIG *dst_frame) {
   DomaintxfmrfInfo *domaintxfmrf_info = info->domaintxfmrf_info;
   double cost_norestore, cost_domaintxfmrf;
   int64_t err;
@@ -504,8 +492,8 @@
     av1_get_rest_tile_limits(tile_idx, 0, 0, nhtiles, nvtiles, tile_width,
                              tile_height, cm->width, cm->height, 0, 0, &h_start,
                              &h_end, &v_start, &v_end);
-    err = sse_restoration_tile(src, cm, h_start, h_end - h_start, v_start,
-                               v_end - v_start);
+    err = sse_restoration_tile(src, cm->frame_to_show, cm, h_start,
+                               h_end - h_start, v_start, v_end - v_start);
     // #bits when a tile is not restored
     bits = av1_cost_bit(RESTORE_NONE_DOMAINTXFMRF_PROB, 0);
     cost_norestore = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
@@ -523,7 +511,8 @@
         &rsi.domaintxfmrf_info[tile_idx].sigma_r);
 
     rsi.domaintxfmrf_info[tile_idx].level = 1;
-    err = try_restoration_tile(src, cpi, &rsi, partial_frame, tile_idx, 0, 0);
+    err = try_restoration_tile(src, cpi, &rsi, partial_frame, tile_idx, 0, 0,
+                               dst_frame);
     bits = DOMAINTXFMRF_PARAMS_BITS << AV1_PROB_COST_SHIFT;
     bits += av1_cost_bit(RESTORE_NONE_DOMAINTXFMRF_PROB, 1);
     cost_domaintxfmrf = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
@@ -552,7 +541,7 @@
       bits += (DOMAINTXFMRF_PARAMS_BITS << AV1_PROB_COST_SHIFT);
     }
   }
-  err = try_restoration_frame(src, cpi, &rsi, partial_frame);
+  err = try_restoration_frame(src, cpi, &rsi, partial_frame, dst_frame);
   cost_domaintxfmrf = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
 
   aom_free(rsi.domaintxfmrf_info);
@@ -862,7 +851,8 @@
 
 static double search_wiener(const YV12_BUFFER_CONFIG *src, AV1_COMP *cpi,
                             int filter_level, int partial_frame,
-                            RestorationInfo *info, double *best_tile_cost) {
+                            RestorationInfo *info, double *best_tile_cost,
+                            YV12_BUFFER_CONFIG *dst_frame) {
   WienerInfo *wiener_info = info->wiener_info;
   AV1_COMMON *const cm = &cpi->common;
   RestorationInfo rsi;
@@ -908,8 +898,8 @@
     av1_get_rest_tile_limits(tile_idx, 0, 0, nhtiles, nvtiles, tile_width,
                              tile_height, width, height, 0, 0, &h_start, &h_end,
                              &v_start, &v_end);
-    err = sse_restoration_tile(src, cm, h_start, h_end - h_start, v_start,
-                               v_end - v_start);
+    err = sse_restoration_tile(src, cm->frame_to_show, cm, h_start,
+                               h_end - h_start, v_start, v_end - v_start);
     // #bits when a tile is not restored
     bits = av1_cost_bit(RESTORE_NONE_WIENER_PROB, 0);
     cost_norestore = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
@@ -946,7 +936,8 @@
     }
 
     rsi.wiener_info[tile_idx].level = 1;
-    err = try_restoration_tile(src, cpi, &rsi, partial_frame, tile_idx, 0, 0);
+    err = try_restoration_tile(src, cpi, &rsi, partial_frame, tile_idx, 0, 0,
+                               dst_frame);
     bits = WIENER_FILT_BITS << AV1_PROB_COST_SHIFT;
     bits += av1_cost_bit(RESTORE_NONE_WIENER_PROB, 1);
     cost_wiener = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
@@ -979,7 +970,7 @@
       }
     }
   }
-  err = try_restoration_frame(src, cpi, &rsi, partial_frame);
+  err = try_restoration_frame(src, cpi, &rsi, partial_frame, dst_frame);
   cost_wiener = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
 
   aom_free(rsi.wiener_info);
@@ -990,7 +981,8 @@
 
 static double search_norestore(const YV12_BUFFER_CONFIG *src, AV1_COMP *cpi,
                                int filter_level, int partial_frame,
-                               RestorationInfo *info, double *best_tile_cost) {
+                               RestorationInfo *info, double *best_tile_cost,
+                               YV12_BUFFER_CONFIG *dst_frame) {
   double err, cost_norestore;
   int bits;
   MACROBLOCK *x = &cpi->td.mb;
@@ -1000,6 +992,7 @@
   const int ntiles = av1_get_rest_ntiles(cm->width, cm->height, &tile_width,
                                          &tile_height, &nhtiles, &nvtiles);
   (void)info;
+  (void)dst_frame;
 
   //  Make a copy of the unfiltered / processed recon buffer
   aom_yv12_copy_y(cm->frame_to_show, &cpi->last_frame_uf);
@@ -1011,14 +1004,15 @@
     av1_get_rest_tile_limits(tile_idx, 0, 0, nhtiles, nvtiles, tile_width,
                              tile_height, cm->width, cm->height, 0, 0, &h_start,
                              &h_end, &v_start, &v_end);
-    err = sse_restoration_tile(src, cm, h_start, h_end - h_start, v_start,
-                               v_end - v_start);
+    err = sse_restoration_tile(src, cm->frame_to_show, cm, h_start,
+                               h_end - h_start, v_start, v_end - v_start);
     best_tile_cost[tile_idx] =
         RDCOST_DBL(x->rdmult, x->rddiv,
                    (cpi->switchable_restore_cost[RESTORE_NONE] >> 4), err);
   }
   // RD cost associated with no restoration
-  err = sse_restoration_tile(src, cm, 0, cm->width, 0, cm->height);
+  err = sse_restoration_tile(src, cm->frame_to_show, cm, 0, cm->width, 0,
+                             cm->height);
   bits = frame_level_restore_bits[RESTORE_NONE] << AV1_PROB_COST_SHIFT;
   cost_norestore = RDCOST_DBL(x->rdmult, x->rddiv, (bits >> 4), err);
   aom_yv12_copy_y(&cpi->last_frame_uf, cm->frame_to_show);
@@ -1071,6 +1065,7 @@
   double *tile_cost[RESTORE_SWITCHABLE_TYPES];
   double best_cost_restore;
   RestorationType r, best_restore;
+  YV12_BUFFER_CONFIG dst_frame;
 
   const int ntiles =
       av1_get_rest_ntiles(cm->width, cm->height, NULL, NULL, NULL, NULL);
@@ -1091,6 +1086,17 @@
   for (r = 0; r < RESTORE_SWITCHABLE_TYPES; r++)
     tile_cost[r] = (double *)aom_malloc(sizeof(*tile_cost[0]) * ntiles);
 
+  memset(&dst_frame, 0, sizeof(YV12_BUFFER_CONFIG));
+  if (aom_realloc_frame_buffer(&dst_frame, cm->width, cm->height,
+                               cm->subsampling_x, cm->subsampling_y,
+#if CONFIG_AOM_HIGHBITDEPTH
+                               cm->use_highbitdepth,
+#endif
+                               AOM_BORDER_IN_PIXELS, cm->byte_alignment, NULL,
+                               NULL, NULL) < 0)
+    aom_internal_error(&cm->error, AOM_CODEC_MEM_ERROR,
+                       "Failed to allocate restoration dst buffer");
+
   lf->sharpness_level = cm->frame_type == KEY_FRAME ? 0 : cpi->oxcf.sharpness;
 
   if (method == LPF_PICK_MINIMAL_LPF && lf->filter_level) {
@@ -1131,9 +1137,9 @@
                                 &cost_restore[RESTORE_NONE]);
   }
   for (r = 0; r < RESTORE_SWITCHABLE_TYPES; ++r) {
-    cost_restore[r] = search_restore_fun[r](src, cpi, lf->filter_level,
-                                            method == LPF_PICK_FROM_SUBIMAGE,
-                                            &cm->rst_info, tile_cost[r]);
+    cost_restore[r] = search_restore_fun[r](
+        src, cpi, lf->filter_level, method == LPF_PICK_FROM_SUBIMAGE,
+        &cm->rst_info, tile_cost[r], &dst_frame);
   }
   cost_restore[RESTORE_SWITCHABLE] = search_switchable_restoration(
       cpi, lf->filter_level, method == LPF_PICK_FROM_SUBIMAGE, &cm->rst_info,