diff --git a/av1/common/alloccommon.c b/av1/common/alloccommon.c
index 67ad9f1..b135bfb 100644
--- a/av1/common/alloccommon.c
+++ b/av1/common/alloccommon.c
@@ -132,9 +132,15 @@
 }
 
 #if CONFIG_LOOP_RESTORATION
-// Assumes cm->rst_info[p].restoration_tilesize is already initialized
+// Assumes cm->rst_info[p].restoration_unit_size is already initialized
 void av1_alloc_restoration_buffers(AV1_COMMON *cm) {
-  int p;
+  for (int p = 0; p < MAX_MB_PLANE; ++p)
+    av1_alloc_restoration_struct(cm, &cm->rst_info[p], p > 0);
+  aom_free(cm->rst_tmpbuf);
+  CHECK_MEM_ERROR(cm, cm->rst_tmpbuf,
+                  (int32_t *)aom_memalign(16, RESTORATION_TMPBUF_SIZE));
+
+#if CONFIG_STRIPED_LOOP_RESTORATION
 #if CONFIG_FRAME_SUPERRES
   int width = cm->superres_upscaled_width;
   int height = cm->superres_upscaled_height;
@@ -142,18 +148,9 @@
   int width = cm->width;
   int height = cm->height;
 #endif  // CONFIG_FRAME_SUPERRES
-  av1_alloc_restoration_struct(cm, &cm->rst_info[0], width, height);
-  for (p = 1; p < MAX_MB_PLANE; ++p)
-    av1_alloc_restoration_struct(cm, &cm->rst_info[p],
-                                 ROUND_POWER_OF_TWO(width, cm->subsampling_x),
-                                 ROUND_POWER_OF_TWO(height, cm->subsampling_y));
-  aom_free(cm->rst_tmpbuf);
-  CHECK_MEM_ERROR(cm, cm->rst_tmpbuf,
-                  (int32_t *)aom_memalign(16, RESTORATION_TMPBUF_SIZE));
 
-#if CONFIG_STRIPED_LOOP_RESTORATION
   // Allocate internal storage for the loop restoration stripe boundary lines
-  for (p = 0; p < MAX_MB_PLANE; ++p) {
+  for (int p = 0; p < MAX_MB_PLANE; ++p) {
     int w = p == 0 ? width : ROUND_POWER_OF_TWO(width, cm->subsampling_x);
     int align_bits = 5;  // align for efficiency
     int stride = ALIGN_POWER_OF_TWO(w + 2 * RESTORATION_EXTRA_HORZ, align_bits);
diff --git a/av1/common/restoration.c b/av1/common/restoration.c
index eb103f3..9c09b5d 100644
--- a/av1/common/restoration.c
+++ b/av1/common/restoration.c
@@ -16,6 +16,9 @@
 #include "./aom_dsp_rtcd.h"
 #include "./aom_scale_rtcd.h"
 #include "av1/common/onyxc_int.h"
+#if CONFIG_FRAME_SUPERRES
+#include "av1/common/resize.h"
+#endif
 #include "av1/common/restoration.h"
 #include "aom_dsp/aom_dsp_common.h"
 #include "aom_mem/aom_mem.h"
@@ -45,15 +48,91 @@
 #endif
 };
 
-int av1_alloc_restoration_struct(AV1_COMMON *cm, RestorationInfo *rst_info,
-                                 int width, int height) {
-  const int ntiles = av1_get_rest_ntiles(
-      width, height, rst_info->restoration_tilesize, NULL, NULL);
-  aom_free(rst_info->unit_info);
-  CHECK_MEM_ERROR(
-      cm, rst_info->unit_info,
-      (RestorationUnitInfo *)aom_malloc(sizeof(*rst_info->unit_info) * ntiles));
-  return ntiles;
+#if CONFIG_MAX_TILE
+static void tile_width_and_height(const AV1_COMMON *cm, int is_uv, int sb_w,
+                                  int sb_h, int *px_w, int *px_h) {
+  const int scaled_sb_w = sb_w << MAX_MIB_SIZE_LOG2;
+  const int scaled_sb_h = sb_h << MAX_MIB_SIZE_LOG2;
+
+  const int ss_x = is_uv && cm->subsampling_x;
+  const int ss_y = is_uv && cm->subsampling_y;
+
+  *px_w = (scaled_sb_w + ss_x) >> ss_x;
+  *px_h = (scaled_sb_h + ss_y) >> ss_y;
+#if CONFIG_FRAME_SUPERRES
+  if (!av1_superres_unscaled(cm)) {
+    av1_calculate_unscaled_superres_size(px_w, px_h,
+                                         cm->superres_scale_denominator);
+  }
+#endif  // CONFIG_FRAME_SUPERRES
+}
+#endif  // CONFIG_MAX_TILE
+
+// Count horizontal or vertical units per tile (use a width or height for
+// tile_size, respectively). We basically want to divide the tile size by the
+// size of a restoration unit. Rather than rounding up unconditionally as you
+// might expect, we round to nearest, which models the way a right or bottom
+// restoration unit can extend to up to 150% its normal width or height. The
+// max with 1 is to deal with tiles that are smaller than half of a restoration
+// unit.
+static int count_units_in_tile(int unit_size, int tile_size) {
+  return AOMMAX((tile_size + (unit_size >> 1)) / unit_size, 1);
+}
+
+void av1_alloc_restoration_struct(AV1_COMMON *cm, RestorationInfo *rsi,
+                                  int is_uv) {
+#if CONFIG_MAX_TILE
+  // We need to allocate enough space for restoration units to cover the
+  // largest tile. Without CONFIG_MAX_TILE, this is always the tile at the
+  // top-left and we can use av1_get_tile_rect. With CONFIG_MAX_TILE, we have
+  // to do the computation ourselves, iterating over the tiles and keeping
+  // track of the largest width and height, then upscaling.
+  int max_sb_w = 0;
+  int max_sb_h = 0;
+  for (int i = 0; i < cm->tile_cols; ++i) {
+    const int sb_w = cm->tile_col_start_sb[i + 1] - cm->tile_col_start_sb[i];
+    max_sb_w = AOMMAX(max_sb_w, sb_w);
+  }
+  for (int i = 0; i < cm->tile_rows; ++i) {
+    const int sb_h = cm->tile_row_start_sb[i + 1] - cm->tile_row_start_sb[i];
+    max_sb_h = AOMMAX(max_sb_h, sb_h);
+  }
+
+  int max_tile_w, max_tile_h;
+  tile_width_and_height(cm, is_uv, max_sb_w, max_sb_h, &max_tile_w,
+                        &max_tile_h);
+#else
+  TileInfo tile_info;
+  av1_tile_init(&tile_info, cm, 0, 0);
+
+  const AV1PixelRect tile_rect = av1_get_tile_rect(&tile_info, cm, is_uv);
+  assert(tile_rect.left == 0 && tile_rect.top == 0);
+
+  const int max_tile_w = tile_rect.right;
+  const int max_tile_h = tile_rect.bottom;
+#endif  // CONFIG_MAX_TILE
+
+  // To calculate hpertile and vpertile (horizontal and vertical units per
+  // tile), we basically want to divide the largest tile width or height by the
+  // size of a restoration unit. Rather than rounding up unconditionally as you
+  // might expect, we round to nearest, which models the way a right or bottom
+  // restoration unit can extend to up to 150% its normal width or height. The
+  // max with 1 is to deal with tiles that are smaller than half of a
+  // restoration unit.
+  const int unit_size = rsi->restoration_unit_size;
+  const int hpertile = count_units_in_tile(unit_size, max_tile_w);
+  const int vpertile = count_units_in_tile(unit_size, max_tile_h);
+
+  rsi->units_per_tile = hpertile * vpertile;
+  rsi->horz_units_per_tile = hpertile;
+  rsi->vert_units_per_tile = vpertile;
+
+  const int ntiles = cm->tile_rows * cm->tile_cols;
+  const int nunits = ntiles * rsi->units_per_tile;
+
+  aom_free(rsi->unit_info);
+  CHECK_MEM_ERROR(cm, rsi->unit_info, (RestorationUnitInfo *)aom_malloc(
+                                          sizeof(*rsi->unit_info) * nunits));
 }
 
 void av1_free_restoration_struct(RestorationInfo *rst_info) {
@@ -1405,28 +1484,31 @@
   { RESTORATION_BORDER_HORZ, RESTORATION_BORDER_VERT }
 };
 
-static RestorationTileLimits get_rest_tile_limits(int tile_idx, int nhtiles,
-                                                  int nvtiles, int rtile_size,
-                                                  int im_width, int im_height,
-                                                  int subsampling_y) {
-  const int htile_idx = tile_idx % nhtiles;
-  const int vtile_idx = tile_idx / nhtiles;
-  RestorationTileLimits limits;
-  limits.h_start = htile_idx * rtile_size;
-  limits.v_start = vtile_idx * rtile_size;
-  limits.h_end =
-      (htile_idx < nhtiles - 1) ? limits.h_start + rtile_size : im_width;
-  limits.v_end =
-      (vtile_idx < nvtiles - 1) ? limits.v_start + rtile_size : im_height;
+typedef struct {
+  const RestorationInfo *rsi;
 #if CONFIG_STRIPED_LOOP_RESTORATION
-  // Offset the tile upwards to align with the restoration processing stripe
-  const int voffset = RESTORATION_TILE_OFFSET >> subsampling_y;
-  limits.v_start = AOMMAX(0, limits.v_start - voffset);
-  if (limits.v_end < im_height) limits.v_end -= voffset;
-#else
-  (void)subsampling_y;
+  RestorationLineBuffers *rlbs;
+  int ss_y;
 #endif
-  return limits;
+  int highbd, bit_depth;
+  uint8_t *data8, *dst8;
+  int data_stride, dst_stride;
+  int32_t *tmpbuf;
+} FilterFrameCtxt;
+
+static void filter_frame_on_unit(const RestorationTileLimits *limits,
+                                 int rest_unit_idx, void *priv) {
+  FilterFrameCtxt *ctxt = (FilterFrameCtxt *)priv;
+  const RestorationInfo *rsi = ctxt->rsi;
+
+  av1_loop_restoration_filter_unit(limits, &rsi->unit_info[rest_unit_idx],
+#if CONFIG_STRIPED_LOOP_RESTORATION
+                                   &rsi->boundaries, ctxt->rlbs, ctxt->ss_y,
+#endif
+                                   rsi->procunit_width, rsi->procunit_height,
+                                   ctxt->highbd, ctxt->bit_depth, ctxt->data8,
+                                   ctxt->data_stride, ctxt->dst8,
+                                   ctxt->dst_stride, ctxt->tmpbuf);
 }
 
 void av1_loop_restoration_filter_frame(YV12_BUFFER_CONFIG *frame,
@@ -1493,36 +1575,32 @@
     }
 
     const int is_uv = plane > 0;
-    const int ss_y = is_uv && cm->subsampling_y;
-
     const int plane_width = frame->crop_widths[is_uv];
     const int plane_height = frame->crop_heights[is_uv];
 
-    int nhtiles, nvtiles;
-    const int ntiles =
-        av1_get_rest_ntiles(plane_width, plane_height,
-                            prsi->restoration_tilesize, &nhtiles, &nvtiles);
-
     const struct restore_borders *borders =
         &restore_borders[prsi->frame_restoration_type];
     extend_frame(frame->buffers[plane], plane_width, plane_height,
                  frame->strides[is_uv], borders->hborder, borders->vborder,
                  highbd);
 
-    for (int tile_idx = 0; tile_idx < ntiles; ++tile_idx) {
-      RestorationTileLimits limits = get_rest_tile_limits(
-          tile_idx, nhtiles, nvtiles, prsi->restoration_tilesize, plane_width,
-          plane_height, ss_y);
-
-      av1_loop_restoration_filter_unit(
-          &limits, &prsi->unit_info[tile_idx],
+    FilterFrameCtxt ctxt;
+    ctxt.rsi = prsi;
 #if CONFIG_STRIPED_LOOP_RESTORATION
-          &prsi->boundaries, &rlbs, ss_y,
+    const int ss_y = is_uv && cm->subsampling_y;
+    ctxt.rlbs = &rlbs;
+    ctxt.ss_y = ss_y;
 #endif
-          prsi->procunit_width, prsi->procunit_height, highbd, bit_depth,
-          frame->buffers[plane], frame->strides[is_uv], dst->buffers[plane],
-          dst->strides[is_uv], cm->rst_tmpbuf);
-    }
+    ctxt.highbd = highbd;
+    ctxt.bit_depth = bit_depth;
+    ctxt.data8 = frame->buffers[plane];
+    ctxt.dst8 = dst->buffers[plane];
+    ctxt.data_stride = frame->strides[is_uv];
+    ctxt.dst_stride = dst->strides[is_uv];
+    ctxt.tmpbuf = cm->rst_tmpbuf;
+
+    av1_foreach_rest_unit_in_frame(cm, plane, NULL, filter_frame_on_unit,
+                                   &ctxt);
   }
 
   if (dst == &dst_) {
@@ -1536,25 +1614,54 @@
 }
 
 static void foreach_rest_unit_in_tile(const AV1PixelRect *tile_rect,
-                                      int nunits_x, int nunits_y, int unit_size,
-                                      int plane_w, int plane_h, int ss_y,
+                                      int tile_row, int tile_col, int tile_cols,
+                                      int hunits_per_tile, int units_per_tile,
+                                      int unit_size, int ss_y,
                                       rest_unit_visitor_t on_rest_unit,
                                       void *priv) {
-  const int col0 = (tile_rect->left + unit_size - 1) / unit_size;
-  const int col1 =
-      AOMMIN((tile_rect->right + unit_size - 1) / unit_size, nunits_x);
-  const int row0 = (tile_rect->top + unit_size - 1) / unit_size;
-  const int row1 =
-      AOMMIN((tile_rect->bottom + unit_size - 1) / unit_size, nunits_y);
+  const int tile_w = tile_rect->right - tile_rect->left;
+  const int tile_h = tile_rect->bottom - tile_rect->top;
+  const int ext_size = unit_size * 3 / 2;
 
-  for (int i = row0; i < row1; ++i) {
-    for (int j = col0; j < col1; ++j) {
-      const int rtile_idx = i * nunits_x + j;
-      RestorationTileLimits limits = get_rest_tile_limits(
-          rtile_idx, nunits_x, nunits_y, unit_size, plane_w, plane_h, ss_y);
+  const int tile_idx = tile_col + tile_row * tile_cols;
+  const int unit_idx0 = tile_idx * units_per_tile;
 
-      on_rest_unit(&limits, rtile_idx, priv);
+  int y0 = 0, i = 0;
+  while (y0 < tile_h) {
+    int remaining_h = tile_h - y0;
+    int h = (remaining_h < ext_size) ? remaining_h : unit_size;
+
+    RestorationTileLimits limits;
+    limits.v_start = tile_rect->top + y0;
+    limits.v_end = tile_rect->top + y0 + h;
+    assert(limits.v_end <= tile_rect->bottom);
+#if CONFIG_STRIPED_LOOP_RESTORATION
+    // Offset the tile upwards to align with the restoration processing stripe
+    const int voffset = RESTORATION_TILE_OFFSET >> ss_y;
+    limits.v_start = AOMMAX(0, limits.v_start - voffset);
+    if (limits.v_end < tile_rect->bottom) limits.v_end -= voffset;
+#else
+    (void)ss_y;
+#endif
+
+    int x0 = 0, j = 0;
+    while (x0 < tile_w) {
+      int remaining_w = tile_w - x0;
+      int w = (remaining_w < ext_size) ? remaining_w : unit_size;
+
+      limits.h_start = tile_rect->left + x0;
+      limits.h_end = tile_rect->left + x0 + w;
+      assert(limits.h_end <= tile_rect->right);
+
+      const int unit_idx = unit_idx0 + i * hunits_per_tile + j;
+      on_rest_unit(&limits, unit_idx, priv);
+
+      x0 += w;
+      ++j;
     }
+
+    y0 += h;
+    ++i;
   }
 }
 
@@ -1563,24 +1670,9 @@
                                     rest_unit_visitor_t on_rest_unit,
                                     void *priv) {
   const int is_uv = plane > 0;
-  const int ss_x = is_uv && cm->subsampling_x;
   const int ss_y = is_uv && cm->subsampling_y;
 
-#if CONFIG_FRAME_SUPERRES
-  const int frame_w = cm->superres_upscaled_width;
-  const int frame_h = cm->superres_upscaled_height;
-#else
-  const int frame_w = cm->width;
-  const int frame_h = cm->height;
-#endif
-
-  const int plane_w = (frame_w + ss_x) >> ss_x;
-  const int plane_h = (frame_h + ss_y) >> ss_y;
-
-  const int unit_size = cm->rst_info[plane].restoration_tilesize;
-
-  int nunits_x, nunits_y;
-  av1_get_rest_ntiles(plane_w, plane_h, unit_size, &nunits_x, &nunits_y);
+  const RestorationInfo *rsi = &cm->rst_info[plane];
 
   TileInfo tile_info;
   for (int tile_row = 0; tile_row < cm->tile_rows; ++tile_row) {
@@ -1588,78 +1680,121 @@
     for (int tile_col = 0; tile_col < cm->tile_cols; ++tile_col) {
       av1_tile_set_col(&tile_info, cm, tile_col);
 
-      on_tile(tile_row, tile_col, priv);
+      if (on_tile) on_tile(tile_row, tile_col, priv);
 
       AV1PixelRect tile_rect = av1_get_tile_rect(&tile_info, cm, is_uv);
-      foreach_rest_unit_in_tile(&tile_rect, nunits_x, nunits_y, unit_size,
-                                plane_w, plane_h, ss_y, on_rest_unit, priv);
+      foreach_rest_unit_in_tile(&tile_rect, tile_row, tile_col, cm->tile_cols,
+                                rsi->horz_units_per_tile, rsi->units_per_tile,
+                                rsi->restoration_unit_size, ss_y, on_rest_unit,
+                                priv);
     }
   }
 }
 
+#if CONFIG_MAX_TILE
+// Get the horizontal or vertical index of the tile containing mi_x. For a
+// horizontal index, mi_x should be the left-most column for some block in mi
+// units and tile_x_start_sb should be cm->tile_col_start_sb. The return value
+// will be "tile_col" for the tile containing that block.
+//
+// For a vertical index, mi_x should be the block's top row and tile_x_start_sb
+// should be cm->tile_row_start_sb. The return value will be "tile_row" for the
+// tile containing the block.
+static int get_tile_idx(const int *tile_x_start_sb, int mi_x) {
+  int sb_x = mi_x << MAX_MIB_SIZE_LOG2;
+
+  for (int i = 0; i < MAX_TILE_COLS; ++i) {
+    if (tile_x_start_sb[i + 1] > sb_x) return i;
+  }
+
+  // This shouldn't happen if tile_x_start_sb has been filled in
+  // correctly.
+  assert(0);
+  return 0;
+}
+#endif
+
 int av1_loop_restoration_corners_in_sb(const struct AV1Common *cm, int plane,
                                        int mi_row, int mi_col, BLOCK_SIZE bsize,
                                        int *rcol0, int *rcol1, int *rrow0,
-                                       int *rrow1, int *nhtiles) {
-  assert(rcol0 && rcol1 && rrow0 && rrow1 && nhtiles);
+                                       int *rrow1, int *tile_tl_idx) {
+  assert(rcol0 && rcol1 && rrow0 && rrow1);
 
   if (bsize != cm->sb_size) return 0;
 
+  const int is_uv = plane > 0;
+
+// Which tile contains the superblock? Find that tile's top-left in mi-units,
+// together with the tile's size in pixels.
+#if CONFIG_MAX_TILE
+  const int tile_row = get_tile_idx(cm->tile_row_start_sb, mi_row);
+  const int tile_col = get_tile_idx(cm->tile_col_start_sb, mi_col);
+
+  const int sb_t = cm->tile_row_start_sb[tile_row];
+  const int sb_l = cm->tile_col_start_sb[tile_col];
+  const int sb_b = cm->tile_row_start_sb[tile_row + 1];
+  const int sb_r = cm->tile_col_start_sb[tile_col + 1];
+
+  int tile_w, tile_h;
+  tile_width_and_height(cm, is_uv, sb_r - sb_l, sb_t - sb_b, &tile_w, &tile_h);
+
+  const int mi_top = sb_t << MAX_MIB_SIZE_LOG2;
+  const int mi_left = sb_l << MAX_MIB_SIZE_LOG2;
+#else
+  const int tile_row = mi_row / cm->tile_height;
+  const int tile_col = mi_col / cm->tile_width;
+
+  TileInfo tile_info;
+  av1_tile_init(&tile_info, cm, tile_row, tile_col);
+
+  const AV1PixelRect tile_rect = av1_get_tile_rect(&tile_info, cm, is_uv);
+  const int tile_w = tile_rect.right - tile_rect.left;
+  const int tile_h = tile_rect.bottom - tile_rect.top;
+
+  const int mi_top = tile_info.mi_row_start;
+  const int mi_left = tile_info.mi_col_start;
+#endif  // CONFIG_MAX_TILE
+
+  // Compute the mi-unit corners of the superblock relative to the top-left of
+  // the tile
+  const int mi_rel_row0 = mi_row - mi_top;
+  const int mi_rel_col0 = mi_col - mi_left;
+  const int mi_rel_row1 = mi_rel_row0 + mi_size_high[bsize];
+  const int mi_rel_col1 = mi_rel_col0 + mi_size_wide[bsize];
+
 #if CONFIG_FRAME_SUPERRES
-  const int frame_w = cm->superres_upscaled_width;
-  const int frame_h = cm->superres_upscaled_height;
-  const int mi_to_px = MI_SIZE * SCALE_NUMERATOR;
+  const int mi_to_num = MI_SIZE * SCALE_NUMERATOR;
   const int denom = cm->superres_scale_denominator;
 #else
-  const int frame_w = cm->width;
-  const int frame_h = cm->height;
-  const int mi_to_px = MI_SIZE;
+  const int mi_to_num = MI_SIZE;
   const int denom = 1;
 #endif  // CONFIG_FRAME_SUPERRES
 
-  const int ss_x = plane > 0 && cm->subsampling_x != 0;
-  const int ss_y = plane > 0 && cm->subsampling_y != 0;
+  const RestorationInfo *rsi = &cm->rst_info[plane];
+  const int size = rsi->restoration_unit_size;
+  const int rnd = size * denom - 1;
 
-  const int ss_frame_w = (frame_w + ss_x) >> ss_x;
-  const int ss_frame_h = (frame_h + ss_y) >> ss_y;
+  // Calculate the number of restoration units in this tile (which might be
+  // strictly less than rsi->horz_units_per_tile and rsi->vert_units_per_tile)
+  const int horz_units = count_units_in_tile(size, tile_w);
+  const int vert_units = count_units_in_tile(size, tile_h);
 
-  const int rtile_size = cm->rst_info[plane].restoration_tilesize;
+  // rcol0/rrow0 should be the first column/row of restoration units (relative
+  // to the top-left of the tile) that doesn't start left/below of
+  // mi_col/mi_row. For this calculation, we need to round up the division (if
+  // the sb starts at rtile column 10.1, the first matching rtile has column
+  // index 11)
+  *rcol0 = (mi_rel_col0 * mi_to_num + rnd) / (size * denom);
+  *rrow0 = (mi_rel_row0 * mi_to_num + rnd) / (size * denom);
 
-  int nvtiles;
-  av1_get_rest_ntiles(ss_frame_w, ss_frame_h, rtile_size, nhtiles, &nvtiles);
+  // rel_col1/rel_row1 is the equivalent calculation, but for the superblock
+  // below-right. If we're at the bottom or right of the tile, this restoration
+  // unit might not exist, in which case we'll clamp accordingly.
+  *rcol1 = AOMMIN((mi_rel_col1 * mi_to_num + rnd) / (size * denom), horz_units);
+  *rrow1 = AOMMIN((mi_rel_row1 * mi_to_num + rnd) / (size * denom), vert_units);
 
-  const int rnd = rtile_size * denom - 1;
-
-  // rcol0/rrow0 should be the first column/row of rtiles that doesn't start
-  // left/below of mi_col/mi_row. For this calculation, we need to round up the
-  // division (if the sb starts at rtile column 10.1, the first matching rtile
-  // has column index 11)
-  *rcol0 = (mi_col * mi_to_px + rnd) / (rtile_size * denom);
-  *rrow0 = (mi_row * mi_to_px + rnd) / (rtile_size * denom);
-
-  // rcol1/rrow1 is the equivalent calculation, but for the superblock
-  // below-right. There are some slightly strange boundary effects. First, we
-  // need to clamp to nhtiles/nvtiles for the case where it appears there are,
-  // say, 2.4 restoration tiles horizontally. There we need a maximum mi_row1
-  // of 2 because tile 1 gets extended.
-  //
-  // Second, if mi_col1 >= cm->mi_cols then we must manually set *rcol1 to
-  // nhtiles. This is needed whenever the frame's width rounded up to the next
-  // toplevel superblock is smaller than nhtiles * rtile_w. The same logic is
-  // needed for rows.
-  const int mi_row1 = mi_row + mi_size_high[bsize];
-  const int mi_col1 = mi_col + mi_size_wide[bsize];
-
-  if (mi_col1 >= cm->mi_cols)
-    *rcol1 = *nhtiles;
-  else
-    *rcol1 =
-        AOMMIN(*nhtiles, (mi_col1 * mi_to_px + rnd) / (rtile_size * denom));
-
-  if (mi_row1 >= cm->mi_rows)
-    *rrow1 = nvtiles;
-  else
-    *rrow1 = AOMMIN(nvtiles, (mi_row1 * mi_to_px + rnd) / (rtile_size * denom));
+  const int tile_idx = tile_col + tile_row * cm->tile_cols;
+  *tile_tl_idx = tile_idx * rsi->units_per_tile;
 
   return *rcol0 < *rcol1 && *rrow0 < *rrow1;
 }
diff --git a/av1/common/restoration.h b/av1/common/restoration.h
index 6a77f2b..51e2d81 100644
--- a/av1/common/restoration.h
+++ b/av1/common/restoration.h
@@ -234,8 +234,19 @@
 
 typedef struct {
   RestorationType frame_restoration_type;
-  int restoration_tilesize;
+  int restoration_unit_size;
   int procunit_width, procunit_height;
+
+  // Fields below here are allocated and initialised by
+  // av1_alloc_restoration_struct. (horz_)units_per_tile give the number of
+  // restoration units in (one row of) the largest tile in the frame. The data
+  // in unit_info is laid out with units_per_tile entries for each tile, which
+  // have stride horz_units_per_tile.
+  //
+  // Even if there are tiles of different sizes, the data in unit_info is laid
+  // out as if all tiles are of full size.
+  int units_per_tile;
+  int vert_units_per_tile, horz_units_per_tile;
   RestorationUnitInfo *unit_info;
 #if CONFIG_STRIPED_LOOP_RESTORATION
   RestorationStripeBoundaries boundaries;
@@ -259,20 +270,6 @@
   wiener_info->vfilter[6] = wiener_info->hfilter[6] = WIENER_FILT_TAP0_MIDV;
 }
 
-static INLINE int av1_get_rest_ntiles(int width, int height, int tilesize,
-                                      int *nhtiles, int *nvtiles) {
-  int nhtiles_, nvtiles_;
-  const int tile_width = (tilesize < 0) ? width : AOMMIN(tilesize, width);
-  const int tile_height = (tilesize < 0) ? height : AOMMIN(tilesize, height);
-  assert(tile_width > 0 && tile_height > 0);
-
-  nhtiles_ = (width + (tile_width >> 1)) / tile_width;
-  nvtiles_ = (height + (tile_height >> 1)) / tile_height;
-  if (nhtiles) *nhtiles = nhtiles_;
-  if (nvtiles) *nvtiles = nvtiles_;
-  return (nhtiles_ * nvtiles_);
-}
-
 typedef struct { int h_start, h_end, v_start, v_end; } RestorationTileLimits;
 
 extern const sgr_params_type sgr_params[SGRPROJ_PARAMS];
@@ -280,9 +277,8 @@
 extern const int32_t x_by_xplus1[256];
 extern const int32_t one_by_x[MAX_NELEM];
 
-int av1_alloc_restoration_struct(struct AV1Common *cm,
-                                 RestorationInfo *rst_info, int width,
-                                 int height);
+void av1_alloc_restoration_struct(struct AV1Common *cm, RestorationInfo *rsi,
+                                  int is_uv);
 void av1_free_restoration_struct(RestorationInfo *rst_info);
 
 void extend_frame(uint8_t *data, int width, int height, int stride,
@@ -344,14 +340,14 @@
 // loop restoration tile.
 //
 // If the block is a top-level superblock, the function writes to
-// *rcol0, *rcol1, *rrow0, *rrow1. The rectangle of indices given by
-// [*rcol0, *rcol1) x [*rrow0, *rrow1) will point at the set of rtiles
-// whose top left corners lie in the superblock. Note that the set is
-// only nonempty if *rcol0 < *rcol1 and *rrow0 < *rrow1.
+// *rcol0, *rcol1, *rrow0, *rrow1. The rectangle of restoration unit
+// indices given by [*rcol0, *rcol1) x [*rrow0, *rrow1) are relative
+// to the current tile, whose starting index is returned as
+// *tile_tl_idx.
 int av1_loop_restoration_corners_in_sb(const struct AV1Common *cm, int plane,
                                        int mi_row, int mi_col, BLOCK_SIZE bsize,
                                        int *rcol0, int *rcol1, int *rrow0,
-                                       int *rrow1, int *nhtiles);
+                                       int *rrow1, int *tile_tl_idx);
 
 void av1_loop_restoration_save_boundary_lines(const YV12_BUFFER_CONFIG *frame,
                                               struct AV1Common *cm);
diff --git a/av1/decoder/decodeframe.c b/av1/decoder/decodeframe.c
index 7d86a53..cd14201 100644
--- a/av1/decoder/decodeframe.c
+++ b/av1/decoder/decodeframe.c
@@ -1287,13 +1287,14 @@
 #endif  // CONFIG_CDEF
 #if CONFIG_LOOP_RESTORATION
   for (int plane = 0; plane < MAX_MB_PLANE; ++plane) {
-    int rcol0, rcol1, rrow0, rrow1, nhtiles;
+    int rcol0, rcol1, rrow0, rrow1, tile_tl_idx;
     if (av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize,
                                            &rcol0, &rcol1, &rrow0, &rrow1,
-                                           &nhtiles)) {
+                                           &tile_tl_idx)) {
+      const int rstride = cm->rst_info[plane].horz_units_per_tile;
       for (int rrow = rrow0; rrow < rrow1; ++rrow) {
         for (int rcol = rcol0; rcol < rcol1; ++rcol) {
-          int rtile_idx = rcol + rrow * nhtiles;
+          const int rtile_idx = tile_tl_idx + rcol + rrow * rstride;
           loop_restoration_read_sb_coeffs(cm, xd, r, plane, rtile_idx);
         }
       }
@@ -1389,30 +1390,31 @@
           aom_rb_read_bit(rb) ? RESTORE_SWITCHABLE : RESTORE_NONE;
     }
   }
-  cm->rst_info[0].restoration_tilesize = RESTORATION_TILESIZE_MAX;
-  cm->rst_info[1].restoration_tilesize = RESTORATION_TILESIZE_MAX;
-  cm->rst_info[2].restoration_tilesize = RESTORATION_TILESIZE_MAX;
+  cm->rst_info[0].restoration_unit_size = RESTORATION_TILESIZE_MAX;
+  cm->rst_info[1].restoration_unit_size = RESTORATION_TILESIZE_MAX;
+  cm->rst_info[2].restoration_unit_size = RESTORATION_TILESIZE_MAX;
   if (cm->rst_info[0].frame_restoration_type != RESTORE_NONE ||
       cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
       cm->rst_info[2].frame_restoration_type != RESTORE_NONE) {
-    cm->rst_info[0].restoration_tilesize = RESTORATION_TILESIZE_MAX >> 2;
-    cm->rst_info[1].restoration_tilesize = RESTORATION_TILESIZE_MAX >> 2;
-    cm->rst_info[2].restoration_tilesize = RESTORATION_TILESIZE_MAX >> 2;
+    cm->rst_info[0].restoration_unit_size = RESTORATION_TILESIZE_MAX >> 2;
+    cm->rst_info[1].restoration_unit_size = RESTORATION_TILESIZE_MAX >> 2;
+    cm->rst_info[2].restoration_unit_size = RESTORATION_TILESIZE_MAX >> 2;
     rsi = &cm->rst_info[0];
-    rsi->restoration_tilesize <<= aom_rb_read_bit(rb);
-    if (rsi->restoration_tilesize != (RESTORATION_TILESIZE_MAX >> 2)) {
-      rsi->restoration_tilesize <<= aom_rb_read_bit(rb);
+    rsi->restoration_unit_size <<= aom_rb_read_bit(rb);
+    if (rsi->restoration_unit_size != (RESTORATION_TILESIZE_MAX >> 2)) {
+      rsi->restoration_unit_size <<= aom_rb_read_bit(rb);
     }
   }
   int s = AOMMIN(cm->subsampling_x, cm->subsampling_y);
   if (s && (cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
             cm->rst_info[2].frame_restoration_type != RESTORE_NONE)) {
-    cm->rst_info[1].restoration_tilesize =
-        cm->rst_info[0].restoration_tilesize >> (aom_rb_read_bit(rb) * s);
+    cm->rst_info[1].restoration_unit_size =
+        cm->rst_info[0].restoration_unit_size >> (aom_rb_read_bit(rb) * s);
   } else {
-    cm->rst_info[1].restoration_tilesize = cm->rst_info[0].restoration_tilesize;
+    cm->rst_info[1].restoration_unit_size =
+        cm->rst_info[0].restoration_unit_size;
   }
-  cm->rst_info[2].restoration_tilesize = cm->rst_info[1].restoration_tilesize;
+  cm->rst_info[2].restoration_unit_size = cm->rst_info[1].restoration_unit_size;
 
   cm->rst_info[0].procunit_width = cm->rst_info[0].procunit_height =
       RESTORATION_PROC_UNIT_SIZE;
diff --git a/av1/encoder/bitstream.c b/av1/encoder/bitstream.c
index 4a41eb7..da53814 100644
--- a/av1/encoder/bitstream.c
+++ b/av1/encoder/bitstream.c
@@ -2675,13 +2675,14 @@
 #endif
 #if CONFIG_LOOP_RESTORATION
   for (int plane = 0; plane < MAX_MB_PLANE; ++plane) {
-    int rcol0, rcol1, rrow0, rrow1, nhtiles;
+    int rcol0, rcol1, rrow0, rrow1, tile_tl_idx;
     if (av1_loop_restoration_corners_in_sb(cm, plane, mi_row, mi_col, bsize,
                                            &rcol0, &rcol1, &rrow0, &rrow1,
-                                           &nhtiles)) {
+                                           &tile_tl_idx)) {
+      const int rstride = cm->rst_info[plane].horz_units_per_tile;
       for (int rrow = rrow0; rrow < rrow1; ++rrow) {
         for (int rcol = rcol0; rcol < rcol1; ++rcol) {
-          int rtile_idx = rcol + rrow * nhtiles;
+          const int rtile_idx = tile_tl_idx + rcol + rrow * rstride;
           const RestorationUnitInfo *rui =
               &cm->rst_info[plane].unit_info[rtile_idx];
           loop_restoration_write_sb_coeffs(cm, xd, rui, w, plane);
@@ -2767,29 +2768,29 @@
       cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
       cm->rst_info[2].frame_restoration_type != RESTORE_NONE) {
     aom_wb_write_bit(
-        wb, rsi->restoration_tilesize != (RESTORATION_TILESIZE_MAX >> 2));
-    if (rsi->restoration_tilesize != (RESTORATION_TILESIZE_MAX >> 2)) {
+        wb, rsi->restoration_unit_size != (RESTORATION_TILESIZE_MAX >> 2));
+    if (rsi->restoration_unit_size != (RESTORATION_TILESIZE_MAX >> 2)) {
       aom_wb_write_bit(
-          wb, rsi->restoration_tilesize != (RESTORATION_TILESIZE_MAX >> 1));
+          wb, rsi->restoration_unit_size != (RESTORATION_TILESIZE_MAX >> 1));
     }
   }
   int s = AOMMIN(cm->subsampling_x, cm->subsampling_y);
   if (s && (cm->rst_info[1].frame_restoration_type != RESTORE_NONE ||
             cm->rst_info[2].frame_restoration_type != RESTORE_NONE)) {
     aom_wb_write_bit(wb,
-                     cm->rst_info[1].restoration_tilesize !=
-                         cm->rst_info[0].restoration_tilesize);
-    assert(cm->rst_info[1].restoration_tilesize ==
-               cm->rst_info[0].restoration_tilesize ||
-           cm->rst_info[1].restoration_tilesize ==
-               (cm->rst_info[0].restoration_tilesize >> s));
-    assert(cm->rst_info[2].restoration_tilesize ==
-           cm->rst_info[1].restoration_tilesize);
+                     cm->rst_info[1].restoration_unit_size !=
+                         cm->rst_info[0].restoration_unit_size);
+    assert(cm->rst_info[1].restoration_unit_size ==
+               cm->rst_info[0].restoration_unit_size ||
+           cm->rst_info[1].restoration_unit_size ==
+               (cm->rst_info[0].restoration_unit_size >> s));
+    assert(cm->rst_info[2].restoration_unit_size ==
+           cm->rst_info[1].restoration_unit_size);
   } else if (!s) {
-    assert(cm->rst_info[1].restoration_tilesize ==
-           cm->rst_info[0].restoration_tilesize);
-    assert(cm->rst_info[2].restoration_tilesize ==
-           cm->rst_info[1].restoration_tilesize);
+    assert(cm->rst_info[1].restoration_unit_size ==
+           cm->rst_info[0].restoration_unit_size);
+    assert(cm->rst_info[2].restoration_unit_size ==
+           cm->rst_info[1].restoration_unit_size);
   }
 }
 
diff --git a/av1/encoder/encoder.c b/av1/encoder/encoder.c
index d883f96..d75642b 100644
--- a/av1/encoder/encoder.c
+++ b/av1/encoder/encoder.c
@@ -4171,8 +4171,8 @@
 
 #if CONFIG_LOOP_RESTORATION
 #define COUPLED_CHROMA_FROM_LUMA_RESTORATION 0
-static void set_restoration_tilesize(int width, int height, int sx, int sy,
-                                     RestorationInfo *rst) {
+static void set_restoration_unit_size(int width, int height, int sx, int sy,
+                                      RestorationInfo *rst) {
   (void)width;
   (void)height;
   (void)sx;
@@ -4183,9 +4183,9 @@
   int s = 0;
 #endif  // !COUPLED_CHROMA_FROM_LUMA_RESTORATION
 
-  rst[0].restoration_tilesize = (RESTORATION_TILESIZE_MAX >> 1);
-  rst[1].restoration_tilesize = rst[0].restoration_tilesize >> s;
-  rst[2].restoration_tilesize = rst[1].restoration_tilesize;
+  rst[0].restoration_unit_size = (RESTORATION_TILESIZE_MAX >> 1);
+  rst[1].restoration_unit_size = rst[0].restoration_unit_size >> s;
+  rst[2].restoration_unit_size = rst[1].restoration_unit_size;
 
   rst[0].procunit_width = rst[0].procunit_height = RESTORATION_PROC_UNIT_SIZE;
   rst[1].procunit_width = rst[2].procunit_width =
@@ -4307,8 +4307,8 @@
   const int frame_width = cm->width;
   const int frame_height = cm->height;
 #endif
-  set_restoration_tilesize(frame_width, frame_height, cm->subsampling_x,
-                           cm->subsampling_y, cm->rst_info);
+  set_restoration_unit_size(frame_width, frame_height, cm->subsampling_x,
+                            cm->subsampling_y, cm->rst_info);
   for (int i = 0; i < MAX_MB_PLANE; ++i)
     cm->rst_info[i].frame_restoration_type = RESTORE_NONE;
 
diff --git a/av1/encoder/pickrst.c b/av1/encoder/pickrst.c
index 6b187bd..26330d9 100644
--- a/av1/encoder/pickrst.c
+++ b/av1/encoder/pickrst.c
@@ -1158,14 +1158,17 @@
   return RDCOST_DBL(rsc->x->rdmult, rsc->bits >> 4, rsc->sse);
 }
 
+static int rest_tiles_in_plane(const AV1_COMMON *cm, int plane) {
+  const RestorationInfo *rsi = &cm->rst_info[plane];
+  return cm->tile_rows * cm->tile_cols * rsi->units_per_tile;
+}
+
 void av1_pick_filter_restoration(const YV12_BUFFER_CONFIG *src, AV1_COMP *cpi) {
   AV1_COMMON *const cm = &cpi->common;
 
   int ntiles[2];
   for (int is_uv = 0; is_uv < 2; ++is_uv)
-    ntiles[is_uv] = av1_get_rest_ntiles(
-        src->crop_widths[is_uv], src->crop_heights[is_uv],
-        cm->rst_info[is_uv].restoration_tilesize, NULL, NULL);
+    ntiles[is_uv] = rest_tiles_in_plane(cm, is_uv);
 
   assert(ntiles[1] <= ntiles[0]);
   RestUnitSearchInfo *rusi =