shithub: dav1d

Download patch

ref: 65ba279b5393382a98ddd6844e0c0753f63e749f
parent: 0276455de73c4a520df12a3d6f80574b988d219a
author: Henrik Gramner <[email protected]>
date: Thu Jun 27 10:32:32 EDT 2019

Reduce the size of frame threading buffers

Avoid allocating significantly more memory than what is actually used.

--- a/src/cdef_apply_tmpl.c
+++ b/src/cdef_apply_tmpl.c
@@ -109,7 +109,7 @@
 
         if (edges & CDEF_HAVE_BOTTOM) {
             // backup pre-filter data for next iteration
-            backup2lines(f->lf.cdef_line_ptr[!tf], ptrs, f->cur.stride,
+            backup2lines(f->lf.cdef_line[!tf], ptrs, f->cur.stride,
                          8, f->bw * 4, layout);
         }
 
@@ -173,8 +173,8 @@
                 if (y_lvl) {
                     dsp->cdef.fb[0](bptrs[0], f->cur.stride[0], lr_bak[bit][0],
                                     (pixel *const [2]) {
-                                        &f->lf.cdef_line_ptr[tf][0][0][bx * 4],
-                                        &f->lf.cdef_line_ptr[tf][0][1][bx * 4],
+                                        &f->lf.cdef_line[tf][0][0][bx * 4],
+                                        &f->lf.cdef_line[tf][0][1][bx * 4],
                                     },
                                     adjust_strength(y_pri_lvl, variance),
                                     y_sec_lvl, y_pri_lvl ? dir : 0,
@@ -188,8 +188,8 @@
                         dsp->cdef.fb[uv_idx](bptrs[pl], f->cur.stride[1],
                                              lr_bak[bit][pl],
                                              (pixel *const [2]) {
-                                                 &f->lf.cdef_line_ptr[tf][pl][0][bx * 4 >> ss_hor],
-                                                 &f->lf.cdef_line_ptr[tf][pl][1][bx * 4 >> ss_hor],
+                                                 &f->lf.cdef_line[tf][pl][0][bx * 4 >> ss_hor],
+                                                 &f->lf.cdef_line[tf][pl][1][bx * 4 >> ss_hor],
                                              },
                                              uv_pri_lvl, uv_sec_lvl,
                                              uv_pri_lvl ? uvdir : 0,
--- a/src/decode.c
+++ b/src/decode.c
@@ -2289,6 +2289,14 @@
     memset(ctx->pal_sz, 0, sizeof(ctx->pal_sz));
 }
 
+// { Y+U+V, Y+U } * 4
+static const uint8_t ss_size_mul[4][2] = {
+    [DAV1D_PIXEL_LAYOUT_I400] = {  4, 4 },
+    [DAV1D_PIXEL_LAYOUT_I420] = {  6, 5 },
+    [DAV1D_PIXEL_LAYOUT_I422] = {  8, 6 },
+    [DAV1D_PIXEL_LAYOUT_I444] = { 12, 8 },
+};
+
 static void setup_tile(Dav1dTileState *const ts,
                        const Dav1dFrameContext *const f,
                        const uint8_t *const data, const size_t sz,
@@ -2302,8 +2310,11 @@
     const int row_sb_end = f->frame_hdr->tiling.row_start_sb[tile_row + 1];
     const int sb_shift = f->sb_shift;
 
-    ts->frame_thread.pal_idx = &f->frame_thread.pal_idx[tile_start_off * 2];
-    ts->frame_thread.cf = &((int32_t *) f->frame_thread.cf)[tile_start_off * 3];
+    const uint8_t *const size_mul = ss_size_mul[f->cur.p.layout];
+    ts->frame_thread.pal_idx =
+        &f->frame_thread.pal_idx[(size_t)tile_start_off * size_mul[1] / 4];
+    ts->frame_thread.cf = (uint8_t*)f->frame_thread.cf +
+        (((size_t)tile_start_off * size_mul[0]) >> !f->seq_hdr->hbd);
     dav1d_cdf_thread_copy(&ts->cdf, &f->in_cdf);
     ts->last_qidx = f->frame_hdr->quant.yac;
     memset(ts->last_delta_lf, 0, sizeof(ts->last_delta_lf));
@@ -2573,13 +2584,14 @@
     int retval = DAV1D_ERR(ENOMEM);
 
     if (f->n_tc > 1) {
-        if (f->frame_hdr->tiling.cols * f->sbh > f->tile_thread.titsati_sz) {
+        const int titsati_sz = f->frame_hdr->tiling.cols * f->sbh;
+        if (titsati_sz != f->tile_thread.titsati_sz) {
             freep(&f->tile_thread.task_idx_to_sby_and_tile_idx);
             f->tile_thread.task_idx_to_sby_and_tile_idx =
                 malloc(sizeof(*f->tile_thread.task_idx_to_sby_and_tile_idx) *
-                       f->frame_hdr->tiling.cols * f->sbh);
+                       titsati_sz);
             if (!f->tile_thread.task_idx_to_sby_and_tile_idx) goto error;
-            f->tile_thread.titsati_sz = f->frame_hdr->tiling.cols * f->sbh;
+            f->tile_thread.titsati_sz = titsati_sz;
         }
         if (f->tile_thread.titsati_init[0] != f->frame_hdr->tiling.cols ||
             f->tile_thread.titsati_init[1] != f->sbh ||
@@ -2606,31 +2618,51 @@
         }
     }
 
-    if (f->frame_hdr->tiling.cols * f->frame_hdr->tiling.rows > f->n_ts) {
-        f->ts = realloc(f->ts, f->frame_hdr->tiling.cols *
-                               f->frame_hdr->tiling.rows * sizeof(*f->ts));
-        if (!f->ts) goto error;
-        for (int n = f->n_ts;
-             n < f->frame_hdr->tiling.cols * f->frame_hdr->tiling.rows; n++)
-        {
-            Dav1dTileState *const ts = &f->ts[n];
-            if (pthread_mutex_init(&ts->tile_thread.lock, NULL)) goto error;
-            if (pthread_cond_init(&ts->tile_thread.cond, NULL)) {
+    const int n_ts = f->frame_hdr->tiling.cols * f->frame_hdr->tiling.rows;
+    if (n_ts != f->n_ts) {
+        if (n_ts > f->n_ts) {
+            Dav1dTileState *ts_new = realloc(f->ts, sizeof(*f->ts) * n_ts);
+            if (!ts_new) goto error;
+            f->ts = ts_new;
+            for (int n = f->n_ts; n < n_ts; n++) {
+                Dav1dTileState *const ts = &f->ts[n];
+                if (pthread_mutex_init(&ts->tile_thread.lock, NULL)) goto error;
+                if (pthread_cond_init(&ts->tile_thread.cond, NULL)) {
+                    pthread_mutex_destroy(&ts->tile_thread.lock);
+                    goto error;
+                }
+            }
+            f->n_ts = n_ts;
+        } else {
+            for (int n = n_ts; n < f->n_ts; n++) {
+                Dav1dTileState *const ts = &f->ts[n];
+                pthread_cond_destroy(&ts->tile_thread.cond);
                 pthread_mutex_destroy(&ts->tile_thread.lock);
-                goto error;
             }
-            f->n_ts = n + 1;
+            f->n_ts = n_ts;
+            Dav1dTileState *ts_new = realloc(f->ts, sizeof(*f->ts) * n_ts);
+            if (!ts_new) goto error;
+            f->ts = ts_new;
         }
         if (c->n_fc > 1) {
             freep(&f->frame_thread.tile_start_off);
             f->frame_thread.tile_start_off =
-                malloc(sizeof(*f->frame_thread.tile_start_off) *
-                       f->frame_hdr->tiling.cols * f->frame_hdr->tiling.rows);
+                malloc(sizeof(*f->frame_thread.tile_start_off) * n_ts);
             if (!f->frame_thread.tile_start_off) goto error;
         }
-        f->n_ts = f->frame_hdr->tiling.cols * f->frame_hdr->tiling.rows;
     }
 
+    const int a_sz = f->sb128w * f->frame_hdr->tiling.rows;
+    if (a_sz != f->a_sz) {
+        freep(&f->a);
+        f->a = malloc(sizeof(*f->a) * a_sz);
+        if (!f->a) goto error;
+        f->a_sz = a_sz;
+    }
+
+    const int num_sb128 = f->sb128w * f->sb128h;
+    const uint8_t *const size_mul = ss_size_mul[f->cur.p.layout];
+    const int hbd = !!f->seq_hdr->hbd;
     if (c->n_fc > 1) {
         int tile_idx = 0;
         for (int tile_row = 0; tile_row < f->frame_hdr->tiling.rows; tile_row++) {
@@ -2643,100 +2675,105 @@
                     f->frame_hdr->tiling.col_start_sb[tile_col] * f->sb_step * 4;
             }
         }
-    }
 
-    if (f->sb128w * f->frame_hdr->tiling.rows > f->a_sz) {
-        freep(&f->a);
-        f->a = malloc(f->sb128w * f->frame_hdr->tiling.rows * sizeof(*f->a));
-        if (!f->a) goto error;
-        f->a_sz = f->sb128w * f->frame_hdr->tiling.rows;
+        const int cf_sz = (num_sb128 * size_mul[0]) << hbd;
+        if (cf_sz != f->frame_thread.cf_sz) {
+            dav1d_freep_aligned(&f->frame_thread.cf);
+            f->frame_thread.cf =
+                dav1d_alloc_aligned((size_t)cf_sz * 128 * 128 / 2, 32);
+            if (!f->frame_thread.cf) goto error;
+            memset(f->frame_thread.cf, 0, (size_t)cf_sz * 128 * 128 / 2);
+            f->frame_thread.cf_sz = cf_sz;
+        }
+
+        if (f->frame_hdr->allow_screen_content_tools) {
+            if (num_sb128 != f->frame_thread.pal_sz) {
+                dav1d_freep_aligned(&f->frame_thread.pal);
+                f->frame_thread.pal =
+                    dav1d_alloc_aligned(sizeof(*f->frame_thread.pal) *
+                                        num_sb128 * 16 * 16, 32);
+                if (!f->frame_thread.pal)
+                    goto error;
+                f->frame_thread.pal_sz = num_sb128;
+            }
+
+            const int pal_idx_sz = num_sb128 * size_mul[1];
+            if (pal_idx_sz != f->frame_thread.pal_idx_sz) {
+                dav1d_freep_aligned(&f->frame_thread.pal_idx);
+                f->frame_thread.pal_idx =
+                    dav1d_alloc_aligned(sizeof(*f->frame_thread.pal_idx) *
+                                        pal_idx_sz * 128 * 128 / 4, 32);
+                if (!f->frame_thread.pal_idx)
+                    goto error;
+                f->frame_thread.pal_idx_sz = pal_idx_sz;
+            }
+        } else if (f->frame_thread.pal) {
+            dav1d_freep_aligned(&f->frame_thread.pal);
+            dav1d_freep_aligned(&f->frame_thread.pal_idx);
+            f->frame_thread.pal_sz = f->frame_thread.pal_idx_sz = 0;
+        }
     }
 
     // update allocation of block contexts for above
-    if (f->sb128w > f->lf.line_sz) {
-        dav1d_freep_aligned(&f->lf.cdef_line);
-
-        // note that we allocate all pixel arrays as if we were dealing with
-        // 10 bits/component data
-        uint16_t *ptr = f->lf.cdef_line =
-            dav1d_alloc_aligned(f->b4_stride * 4 * 12 * sizeof(uint16_t), 32);
+    const int line_sz = (int)f->b4_stride << hbd;
+    if (line_sz != f->lf.line_sz) {
+        dav1d_freep_aligned(&f->lf.cdef_line[0][0][0]);
+        uint8_t *ptr = dav1d_alloc_aligned(line_sz * 4 * 12, 32);
         if (!ptr) goto error;
 
         for (int pl = 0; pl <= 2; pl++) {
-            f->lf.cdef_line_ptr[0][pl][0] = ptr + f->b4_stride * 4 * 0;
-            f->lf.cdef_line_ptr[0][pl][1] = ptr + f->b4_stride * 4 * 1;
-            f->lf.cdef_line_ptr[1][pl][0] = ptr + f->b4_stride * 4 * 2;
-            f->lf.cdef_line_ptr[1][pl][1] = ptr + f->b4_stride * 4 * 3;
-            ptr += f->b4_stride * 4 * 4;
+            f->lf.cdef_line[0][pl][0] = ptr + line_sz * 4 * 0;
+            f->lf.cdef_line[0][pl][1] = ptr + line_sz * 4 * 1;
+            f->lf.cdef_line[1][pl][0] = ptr + line_sz * 4 * 2;
+            f->lf.cdef_line[1][pl][1] = ptr + line_sz * 4 * 3;
+            ptr += line_sz * 4 * 4;
         }
 
-        f->lf.line_sz = f->sb128w;
+        f->lf.line_sz = line_sz;
     }
 
-    const ptrdiff_t lr_stride = (f->sr_cur.p.p.w + 31) & ~31;
-    if (lr_stride > f->lf.lr_line_sz) {
-        dav1d_freep_aligned(&f->lf.lr_lpf_line);
-
-        uint16_t *lr_ptr = f->lf.lr_lpf_line =
-            dav1d_alloc_aligned(lr_stride * 3 * 12 * sizeof(uint16_t), 32);
-
+    const int lr_line_sz = ((f->sr_cur.p.p.w + 31) & ~31) << hbd;
+    if (lr_line_sz != f->lf.lr_line_sz) {
+        dav1d_freep_aligned(&f->lf.lr_lpf_line[0]);
+        uint8_t *lr_ptr = dav1d_alloc_aligned(lr_line_sz * 3 * 12, 32);
         if (!lr_ptr) goto error;
 
         for (int pl = 0; pl <= 2; pl++) {
-            f->lf.lr_lpf_line_ptr[pl] = lr_ptr;
-            lr_ptr += lr_stride * 12;
+            f->lf.lr_lpf_line[pl] = lr_ptr;
+            lr_ptr += lr_line_sz * 12;
         }
 
-        f->lf.lr_line_sz = (int) lr_stride;
+        f->lf.lr_line_sz = lr_line_sz;
     }
 
     // update allocation for loopfilter masks
-    if (f->sb128w * f->sb128h > f->lf.mask_sz) {
+    if (num_sb128 != f->lf.mask_sz) {
         freep(&f->lf.mask);
         freep(&f->lf.level);
-        freep(&f->frame_thread.b);
-        f->lf.mask = malloc(f->sb128w * f->sb128h * sizeof(*f->lf.mask));
+        f->lf.mask = malloc(sizeof(*f->lf.mask) * num_sb128);
         // over-allocate by 3 bytes since some of the SIMD implementations
         // index this from the level type and can thus over-read by up to 3
-        f->lf.level = malloc(3 + f->sb128w * f->sb128h * 32 * 32 *
-                             sizeof(*f->lf.level));
+        f->lf.level = malloc(sizeof(*f->lf.level) * num_sb128 * 32 * 32 + 3);
         if (!f->lf.mask || !f->lf.level) goto error;
         if (c->n_fc > 1) {
             freep(&f->frame_thread.b);
             freep(&f->frame_thread.cbi);
-            dav1d_freep_aligned(&f->frame_thread.cf);
-            dav1d_freep_aligned(&f->frame_thread.pal_idx);
-            dav1d_freep_aligned(&f->frame_thread.pal);
             f->frame_thread.b = malloc(sizeof(*f->frame_thread.b) *
-                                       f->sb128w * f->sb128h * 32 * 32);
-            f->frame_thread.pal =
-                dav1d_alloc_aligned(sizeof(*f->frame_thread.pal) *
-                                    f->sb128w * f->sb128h * 16 * 16, 32);
-            f->frame_thread.pal_idx =
-                dav1d_alloc_aligned(sizeof(*f->frame_thread.pal_idx) *
-                                    f->sb128w * f->sb128h * 128 * 128 * 2, 32);
+                                       num_sb128 * 32 * 32);
             f->frame_thread.cbi = malloc(sizeof(*f->frame_thread.cbi) *
-                                         f->sb128w * f->sb128h * 32 * 32);
-            f->frame_thread.cf =
-                dav1d_alloc_aligned(sizeof(int32_t) * 3 *
-                                    f->sb128w * f->sb128h * 128 * 128, 32);
-            if (!f->frame_thread.b || !f->frame_thread.pal_idx ||
-                !f->frame_thread.pal || !f->frame_thread.cbi ||
-                !f->frame_thread.cf)
-            {
-                goto error;
-            }
-            memset(f->frame_thread.cf, 0,
-                   sizeof(int32_t) * 3 * f->sb128w * f->sb128h * 128 * 128);
+                                         num_sb128 * 32 * 32);
+            if (!f->frame_thread.b || !f->frame_thread.cbi) goto error;
         }
-        f->lf.mask_sz = f->sb128w * f->sb128h;
+        f->lf.mask_sz = num_sb128;
     }
+
     f->sr_sb128w = (f->sr_cur.p.p.w + 127) >> 7;
-    if (f->sr_sb128w * f->sb128h > f->lf.lr_mask_sz) {
+    const int lr_mask_sz = f->sr_sb128w * f->sb128h;
+    if (lr_mask_sz != f->lf.lr_mask_sz) {
         freep(&f->lf.lr_mask);
-        f->lf.lr_mask = malloc(f->sr_sb128w * f->sb128h * sizeof(*f->lf.lr_mask));
+        f->lf.lr_mask = malloc(sizeof(*f->lf.lr_mask) * lr_mask_sz);
         if (!f->lf.lr_mask) goto error;
-        f->lf.lr_mask_sz = f->sr_sb128w * f->sb128h;
+        f->lf.lr_mask_sz = lr_mask_sz;
     }
     if (f->frame_hdr->loopfilter.sharpness != f->lf.last_sharpness) {
         dav1d_calc_eih(&f->lf.lim_lut, f->frame_hdr->loopfilter.sharpness);
@@ -2743,26 +2780,26 @@
         f->lf.last_sharpness = f->frame_hdr->loopfilter.sharpness;
     }
     dav1d_calc_lf_values(f->lf.lvl, f->frame_hdr, (int8_t[4]) { 0, 0, 0, 0 });
-    memset(f->lf.mask, 0, sizeof(*f->lf.mask) * f->sb128w * f->sb128h);
+    memset(f->lf.mask, 0, sizeof(*f->lf.mask) * num_sb128);
 
-    if (f->sbh * f->sb128w * 128 > f->ipred_edge_sz) {
+    const int ipred_edge_sz = f->sbh * f->sb128w << hbd;
+    if (ipred_edge_sz != f->ipred_edge_sz) {
         dav1d_freep_aligned(&f->ipred_edge[0]);
-        uint16_t *ptr = f->ipred_edge[0] =
-            dav1d_alloc_aligned(f->sb128w * 128 * f->sbh * 3 * sizeof(uint16_t), 32);
-        if (!f->ipred_edge[0]) goto error;
-        f->ipred_edge_sz = f->sbh * f->sb128w * 128;
-        f->ipred_edge[1] = &ptr[f->ipred_edge_sz];
-        f->ipred_edge[2] = &ptr[f->ipred_edge_sz * 2];
+        uint8_t *ptr = f->ipred_edge[0] =
+            dav1d_alloc_aligned(ipred_edge_sz * 128 * 3, 32);
+        if (!ptr) goto error;
+        f->ipred_edge[1] = ptr + ipred_edge_sz * 128 * 1;
+        f->ipred_edge[2] = ptr + ipred_edge_sz * 128 * 2;
+        f->ipred_edge_sz = ipred_edge_sz;
     }
 
-    if (f->sb128h * f->frame_hdr->tiling.cols > f->lf.re_sz) {
+    const int re_sz = f->sb128h * f->frame_hdr->tiling.cols;
+    if (re_sz != f->lf.re_sz) {
         freep(&f->lf.tx_lpf_right_edge[0]);
-        f->lf.tx_lpf_right_edge[0] = malloc((f->sb128h * 32 * 2) *
-                                            f->frame_hdr->tiling.cols);
+        f->lf.tx_lpf_right_edge[0] = malloc(re_sz * 32 * 2);
         if (!f->lf.tx_lpf_right_edge[0]) goto error;
-        f->lf.tx_lpf_right_edge[1] = f->lf.tx_lpf_right_edge[0] +
-                                     f->sb128h * 32 * f->frame_hdr->tiling.cols;
-        f->lf.re_sz = f->sb128h * f->frame_hdr->tiling.cols;
+        f->lf.tx_lpf_right_edge[1] = f->lf.tx_lpf_right_edge[0] + re_sz * 32;
+        f->lf.re_sz = re_sz;
     }
 
     // init ref mvs
@@ -3010,8 +3047,9 @@
             {
                 Dav1dTileState *const ts = &f->ts[tile_idx];
                 const int tile_start_off = f->frame_thread.tile_start_off[tile_idx];
-                ts->frame_thread.pal_idx = &f->frame_thread.pal_idx[tile_start_off * 2];
-                ts->frame_thread.cf = &((int32_t *) f->frame_thread.cf)[tile_start_off * 3];
+                ts->frame_thread.pal_idx = &f->frame_thread.pal_idx[tile_start_off * size_mul[1] / 4];
+                ts->frame_thread.cf = (uint8_t*)f->frame_thread.cf +
+                    ((tile_start_off * size_mul[0]) >> !f->seq_hdr->hbd);
                 if (f->n_tc > 0) {
                     unsigned row_sb_start = f->frame_hdr->tiling.row_start_sb[ts->tiling.row];
                     atomic_init(&ts->progress, row_sb_start);
--- a/src/internal.h
+++ b/src/internal.h
@@ -196,12 +196,12 @@
             int16_t eob[3 /* plane */];
             uint8_t txtp[3 /* plane */];
         } *cbi;
-        int8_t *txtp;
         // indexed using (t->by >> 1) * (f->b4_stride >> 1) + (t->bx >> 1)
         uint16_t (*pal)[3 /* plane */][8 /* idx */];
         // iterated over inside tile state
         uint8_t *pal_idx;
         coef *cf;
+        int pal_sz, pal_idx_sz, cf_sz;
         // start offsets per tile
         int *tile_start_off;
     } frame_thread;
@@ -217,10 +217,8 @@
         int last_sharpness;
         uint8_t lvl[8 /* seg_id */][4 /* dir */][8 /* ref */][2 /* is_gmv */];
         uint8_t *tx_lpf_right_edge[2];
-        pixel *cdef_line;
-        pixel *cdef_line_ptr[2 /* pre, post */][3 /* plane */][2 /* y */];
-        pixel *lr_lpf_line;
-        pixel *lr_lpf_line_ptr[3 /* plane */];
+        pixel *cdef_line[2 /* pre, post */][3 /* plane */][2 /* y */];
+        pixel *lr_lpf_line[3 /* plane */];
 
         // in-loop filter per-frame state keeping
         int tile_row; // for carry-over at tile row edges
--- a/src/lib.c
+++ b/src/lib.c
@@ -509,8 +509,8 @@
         free(f->lf.level);
         free(f->lf.tx_lpf_right_edge[0]);
         if (f->libaom_cm) dav1d_free_ref_mv_common(f->libaom_cm);
-        dav1d_free_aligned(f->lf.cdef_line);
-        dav1d_free_aligned(f->lf.lr_lpf_line);
+        dav1d_free_aligned(f->lf.cdef_line[0][0][0]);
+        dav1d_free_aligned(f->lf.lr_lpf_line[0]);
     }
     dav1d_free_aligned(c->fc);
     dav1d_data_unref_internal(&c->in);
--- a/src/lr_apply_tmpl.c
+++ b/src/lr_apply_tmpl.c
@@ -122,7 +122,7 @@
         const int w = f->bw << 2;
         const int row_h = imin((sby + 1) << (6 + f->seq_hdr->sb128), h - 1);
         const int y_stripe = (sby << (6 + f->seq_hdr->sb128)) - offset;
-        backup_lpf(f, f->lf.lr_lpf_line_ptr[0], lr_stride,
+        backup_lpf(f, f->lf.lr_lpf_line[0], lr_stride,
                    src[0] - offset * PXSTRIDE(src_stride[0]), src_stride[0],
                    0, f->seq_hdr->sb128, y_stripe, row_h, w, h, 0);
     }
@@ -137,12 +137,12 @@
             (sby << ((6 - ss_ver) + f->seq_hdr->sb128)) - offset_uv;
 
         if (restore_planes & LR_RESTORE_U) {
-            backup_lpf(f, f->lf.lr_lpf_line_ptr[1], lr_stride,
+            backup_lpf(f, f->lf.lr_lpf_line[1], lr_stride,
                        src[1] - offset_uv * PXSTRIDE(src_stride[1]), src_stride[1],
                        ss_ver, f->seq_hdr->sb128, y_stripe, row_h, w, h, ss_hor);
         }
         if (restore_planes & LR_RESTORE_V) {
-            backup_lpf(f, f->lf.lr_lpf_line_ptr[2], lr_stride,
+            backup_lpf(f, f->lf.lr_lpf_line[2], lr_stride,
                        src[2] - offset_uv * PXSTRIDE(src_stride[1]), src_stride[1],
                        ss_ver, f->seq_hdr->sb128, y_stripe, row_h, w, h, ss_hor);
         }
@@ -158,7 +158,7 @@
     const int chroma = !!plane;
     const int ss_ver = chroma & (f->sr_cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420);
     const int sbrow_has_bottom = (edges & LR_HAVE_BOTTOM);
-    const pixel *lpf = f->lf.lr_lpf_line_ptr[plane] + x;
+    const pixel *lpf = f->lf.lr_lpf_line[plane] + x;
     const ptrdiff_t p_stride = f->sr_cur.p.stride[chroma];
     const ptrdiff_t lpf_stride = sizeof(pixel) * ((f->sr_cur.p.p.w + 31) & ~31);
 
--- a/src/thread_task.c
+++ b/src/thread_task.c
@@ -44,7 +44,7 @@
         const int res = dav1d_decode_frame(f);
         if (res)
             memset(f->frame_thread.cf, 0,
-                   sizeof(int32_t) * 3 * f->lf.mask_sz * 128 * 128);
+                   (size_t)f->frame_thread.cf_sz * 128 * 128 / 2);
 
         pthread_mutex_lock(&f->frame_thread.td.lock);
         f->n_tile_data = 0;