diff --git a/av1/common/alloccommon.c b/av1/common/alloccommon.c
index 80f6b09..c37f1ea 100644
--- a/av1/common/alloccommon.c
+++ b/av1/common/alloccommon.c
@@ -93,11 +93,18 @@
 // Assumes cm->rst_info[p].restoration_tilesize is already initialized
 void av1_alloc_restoration_buffers(AV1_COMMON *cm) {
   int p;
-  av1_alloc_restoration_struct(cm, &cm->rst_info[0], cm->width, cm->height);
+#if CONFIG_FRAME_SUPERRES
+  int width = cm->superres_upscaled_width;
+  int height = cm->superres_upscaled_height;
+#else
+  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(cm->width, cm->subsampling_x),
-        ROUND_POWER_OF_TWO(cm->height, cm->subsampling_y));
+    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_internal.tmpbuf);
   CHECK_MEM_ERROR(cm, cm->rst_internal.tmpbuf,
                   (int32_t *)aom_memalign(16, RESTORATION_TMPBUF_SIZE));
