Adding upstream version 0.37.0.upstream/0.37.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1203 insertions, 0 deletions

diff --git a/video/repack.c b/video/repack.c
new file mode 100644
index 0000000..ce3703a
--- /dev/null
+++ b/video/repack.c
@@ -0,0 +1,1203 @@
+/*
+ * This file is part of mpv.
+ *
+ * mpv is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * mpv is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with mpv.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <math.h>
+
+#include <libavutil/bswap.h>
+#include <libavutil/pixfmt.h>
+
+#include "common/common.h"
+#include "repack.h"
+#include "video/csputils.h"
+#include "video/fmt-conversion.h"
+#include "video/img_format.h"
+#include "video/mp_image.h"
+
+enum repack_step_type {
+    REPACK_STEP_FLOAT,
+    REPACK_STEP_REPACK,
+    REPACK_STEP_ENDIAN,
+};
+
+struct repack_step {
+    enum repack_step_type type;
+    // 0=input, 1=output
+    struct mp_image *buf[2];
+    bool user_buf[2]; // user_buf[n]==true if buf[n] = user src/dst buffer
+    struct mp_imgfmt_desc fmt[2];
+    struct mp_image *tmp; // output buffer, if needed
+};
+
+struct mp_repack {
+    bool pack;                  // if false, this is for unpacking
+    int flags;
+    int imgfmt_user;            // original mp format (unchanged endian)
+    int imgfmt_a;               // original mp format (possibly packed format,
+                                // swapped endian)
+    int imgfmt_b;               // equivalent unpacked/planar format
+    struct mp_imgfmt_desc fmt_a;// ==imgfmt_a
+    struct mp_imgfmt_desc fmt_b;// ==imgfmt_b
+
+    void (*repack)(struct mp_repack *rp,
+                   struct mp_image *a, int a_x, int a_y,
+                   struct mp_image *b, int b_x, int b_y, int w);
+
+    bool passthrough_y;         // possible luma plane optimization for e.g. nv12
+    int endian_size;            // endian swap; 0=none, 2/4=swap word size
+
+    // For packed_repack.
+    int components[4];          // b[n] = mp_image.planes[components[n]]
+    //  pack:   a is dst, b is src
+    //  unpack: a is src, b is dst
+    void (*packed_repack_scanline)(void *a, void *b[], int w);
+
+    // Fringe RGB/YUV.
+    uint8_t comp_size;
+    uint8_t comp_map[6];
+    uint8_t comp_shifts[3];
+    uint8_t *comp_lut;
+    void (*repack_fringe_yuv)(void *dst, void *src[], int w, uint8_t *c);
+
+    // F32 repacking.
+    int f32_comp_size;
+    float f32_m[4], f32_o[4];
+    uint32_t f32_pmax[4];
+    enum mp_csp f32_csp_space;
+    enum mp_csp_levels f32_csp_levels;
+
+    // REPACK_STEP_REPACK: if true, need to copy this plane
+    bool copy_buf[4];
+
+    struct repack_step steps[4];
+    int num_steps;
+
+    bool configured;
+};
+
+// depth = number of LSB in use
+static int find_gbrp_format(int depth, int num_planes)
+{
+    if (num_planes != 3 && num_planes != 4)
+        return 0;
+    struct mp_regular_imgfmt desc = {
+        .component_type = MP_COMPONENT_TYPE_UINT,
+        .forced_csp = MP_CSP_RGB,
+        .component_size = depth > 8 ? 2 : 1,
+        .component_pad = depth - (depth > 8 ? 16 : 8),
+        .num_planes = num_planes,
+        .planes = { {1, {2}}, {1, {3}}, {1, {1}}, {1, {4}} },
+    };
+    return mp_find_regular_imgfmt(&desc);
+}
+
+// depth = number of LSB in use
+static int find_yuv_format(int depth, int num_planes)
+{
+    if (num_planes < 1 || num_planes > 4)
+        return 0;
+    struct mp_regular_imgfmt desc = {
+        .component_type = MP_COMPONENT_TYPE_UINT,
+        .component_size = depth > 8 ? 2 : 1,
+        .component_pad = depth - (depth > 8 ? 16 : 8),
+        .num_planes = num_planes,
+        .planes = { {1, {1}}, {1, {2}}, {1, {3}}, {1, {4}} },
+    };
+    if (num_planes == 2)
+        desc.planes[1].components[0] = 4;
+    return mp_find_regular_imgfmt(&desc);
+}
+
+// Copy one line on the plane p.
+static void copy_plane(struct mp_image *dst, int dst_x, int dst_y,
+                       struct mp_image *src, int src_x, int src_y,
+                       int w, int p)
+{
+    // Number of lines on this plane.
+    int h = (1 << dst->fmt.chroma_ys) - (1 << dst->fmt.ys[p]) + 1;
+    size_t size = mp_image_plane_bytes(dst, p, dst_x, w);
+
+    assert(dst->fmt.bpp[p] == src->fmt.bpp[p]);
+
+    for (int y = 0; y < h; y++) {
+        void *pd = mp_image_pixel_ptr_ny(dst, p, dst_x, dst_y + y);
+        void *ps = mp_image_pixel_ptr_ny(src, p, src_x, src_y + y);
+        memcpy(pd, ps, size);
+    }
+}
+
+// Swap endian for one line.
+static void swap_endian(struct mp_image *dst, int dst_x, int dst_y,
+                        struct mp_image *src, int src_x, int src_y,
+                        int w, int endian_size)
+{
+    assert(src->fmt.num_planes == dst->fmt.num_planes);
+
+    for (int p = 0; p < dst->fmt.num_planes; p++) {
+        int xs = dst->fmt.xs[p];
+        int bpp = dst->fmt.bpp[p] / 8;
+        int words_per_pixel = bpp / endian_size;
+        int num_words = ((w + (1 << xs) - 1) >> xs) * words_per_pixel;
+        // Number of lines on this plane.
+        int h = (1 << dst->fmt.chroma_ys) - (1 << dst->fmt.ys[p]) + 1;
+
+        assert(src->fmt.bpp[p] == bpp * 8);
+
+        for (int y = 0; y < h; y++) {
+            void *s = mp_image_pixel_ptr_ny(src, p, src_x, src_y + y);
+            void *d = mp_image_pixel_ptr_ny(dst, p, dst_x, dst_y + y);
+            switch (endian_size) {
+            case 2:
+                for (int x = 0; x < num_words; x++)
+                    ((uint16_t *)d)[x] = av_bswap16(((uint16_t *)s)[x]);
+                break;
+            case 4:
+                for (int x = 0; x < num_words; x++)
+                    ((uint32_t *)d)[x] = av_bswap32(((uint32_t *)s)[x]);
+                break;
+            default:
+                MP_ASSERT_UNREACHABLE();
+            }
+        }
+    }
+}
+
+// PA = PAck, copy planar input to single packed array
+// UN = UNpack, copy packed input to planar output
+// Naming convention:
+//  pa_/un_ prefix to identify conversion direction.
+//  Left (LSB, lowest byte address) -> Right (MSB, highest byte address).
+//      (This is unusual; MSB to LSB is more commonly used to describe formats,
+//       but our convention makes more sense for byte access in little endian.)
+//  "c" identifies a color component.
+//  "z" identifies known zero padding.
+//  "x" identifies uninitialized padding.
+//  A component is followed by its size in bits.
+//  Size can be omitted for multiple uniform components (c8c8c8 == ccc8).
+// Unpackers will often use "x" for padding, because they ignore it, while
+// packers will use "z" because they write zero.
+
+#define PA_WORD_4(name, packed_t, plane_t, sh_c0, sh_c1, sh_c2, sh_c3)      \
+    static void name(void *dst, void *src[], int w) {                       \
+        for (int x = 0; x < w; x++) {                                       \
+            ((packed_t *)dst)[x] =                                          \
+                ((packed_t)((plane_t *)src[0])[x] << (sh_c0)) |             \
+                ((packed_t)((plane_t *)src[1])[x] << (sh_c1)) |             \
+                ((packed_t)((plane_t *)src[2])[x] << (sh_c2)) |             \
+                ((packed_t)((plane_t *)src[3])[x] << (sh_c3));              \
+        }                                                                   \
+    }
+
+#define UN_WORD_4(name, packed_t, plane_t, sh_c0, sh_c1, sh_c2, sh_c3, mask)\
+    static void name(void *src, void *dst[], int w) {                       \
+        for (int x = 0; x < w; x++) {                                       \
+            packed_t c = ((packed_t *)src)[x];                              \
+            ((plane_t *)dst[0])[x] = (c >> (sh_c0)) & (mask);               \
+            ((plane_t *)dst[1])[x] = (c >> (sh_c1)) & (mask);               \
+            ((plane_t *)dst[2])[x] = (c >> (sh_c2)) & (mask);               \
+            ((plane_t *)dst[3])[x] = (c >> (sh_c3)) & (mask);               \
+        }                                                                   \
+    }
+
+
+#define PA_WORD_3(name, packed_t, plane_t, sh_c0, sh_c1, sh_c2, pad)        \
+    static void name(void *dst, void *src[], int w) {                       \
+        for (int x = 0; x < w; x++) {                                       \
+            ((packed_t *)dst)[x] = (pad) |                                  \
+                ((packed_t)((plane_t *)src[0])[x] << (sh_c0)) |             \
+                ((packed_t)((plane_t *)src[1])[x] << (sh_c1)) |             \
+                ((packed_t)((plane_t *)src[2])[x] << (sh_c2));              \
+        }                                                                   \
+    }
+
+UN_WORD_4(un_cccc8,  uint32_t, uint8_t,  0, 8,  16, 24, 0xFFu)
+PA_WORD_4(pa_cccc8,  uint32_t, uint8_t,  0, 8,  16, 24)
+// Not sure if this is a good idea; there may be no alignment guarantee.
+UN_WORD_4(un_cccc16,  uint64_t, uint16_t,  0, 16,  32, 48, 0xFFFFu)
+PA_WORD_4(pa_cccc16,  uint64_t, uint16_t,  0, 16,  32, 48)
+
+#define UN_WORD_3(name, packed_t, plane_t, sh_c0, sh_c1, sh_c2, mask)       \
+    static void name(void *src, void *dst[], int w) {                       \
+        for (int x = 0; x < w; x++) {                                       \
+            packed_t c = ((packed_t *)src)[x];                              \
+            ((plane_t *)dst[0])[x] = (c >> (sh_c0)) & (mask);               \
+            ((plane_t *)dst[1])[x] = (c >> (sh_c1)) & (mask);               \
+            ((plane_t *)dst[2])[x] = (c >> (sh_c2)) & (mask);               \
+        }                                                                   \
+    }
+
+UN_WORD_3(un_ccc8x8,  uint32_t, uint8_t,  0, 8,  16, 0xFFu)
+PA_WORD_3(pa_ccc8z8,  uint32_t, uint8_t,  0, 8,  16, 0)
+UN_WORD_3(un_x8ccc8,  uint32_t, uint8_t,  8, 16, 24, 0xFFu)
+PA_WORD_3(pa_z8ccc8,  uint32_t, uint8_t,  8, 16, 24, 0)
+UN_WORD_3(un_ccc10x2, uint32_t, uint16_t, 0, 10, 20, 0x3FFu)
+PA_WORD_3(pa_ccc10z2, uint32_t, uint16_t, 0, 10, 20, 0)
+UN_WORD_3(un_ccc16x16, uint64_t, uint16_t, 0, 16, 32, 0xFFFFu)
+PA_WORD_3(pa_ccc16z16, uint64_t, uint16_t, 0, 16, 32, 0)
+
+#define PA_WORD_2(name, packed_t, plane_t, sh_c0, sh_c1, pad)               \
+    static void name(void *dst, void *src[], int w) {                       \
+        for (int x = 0; x < w; x++) {                                       \
+            ((packed_t *)dst)[x] = (pad) |                                  \
+                ((packed_t)((plane_t *)src[0])[x] << (sh_c0)) |             \
+                ((packed_t)((plane_t *)src[1])[x] << (sh_c1));              \
+        }                                                                   \
+    }
+
+#define UN_WORD_2(name, packed_t, plane_t, sh_c0, sh_c1, mask)              \
+    static void name(void *src, void *dst[], int w) {                       \
+        for (int x = 0; x < w; x++) {                                       \
+            packed_t c = ((packed_t *)src)[x];                              \
+            ((plane_t *)dst[0])[x] = (c >> (sh_c0)) & (mask);               \
+            ((plane_t *)dst[1])[x] = (c >> (sh_c1)) & (mask);               \
+        }                                                                   \
+    }
+
+UN_WORD_2(un_cc8,  uint16_t, uint8_t,  0, 8,  0xFFu)
+PA_WORD_2(pa_cc8,  uint16_t, uint8_t,  0, 8,  0)
+UN_WORD_2(un_cc16, uint32_t, uint16_t, 0, 16, 0xFFFFu)
+PA_WORD_2(pa_cc16, uint32_t, uint16_t, 0, 16, 0)
+
+#define PA_SEQ_3(name, comp_t)                                              \
+    static void name(void *dst, void *src[], int w) {                       \
+        comp_t *r = dst;                                                    \
+        for (int x = 0; x < w; x++) {                                       \
+            *r++ = ((comp_t *)src[0])[x];                                   \
+            *r++ = ((comp_t *)src[1])[x];                                   \
+            *r++ = ((comp_t *)src[2])[x];                                   \
+        }                                                                   \
+    }
+
+#define UN_SEQ_3(name, comp_t)                                              \
+    static void name(void *src, void *dst[], int w) {                       \
+        comp_t *r = src;                                                    \
+        for (int x = 0; x < w; x++) {                                       \
+            ((comp_t *)dst[0])[x] = *r++;                                   \
+            ((comp_t *)dst[1])[x] = *r++;                                   \
+            ((comp_t *)dst[2])[x] = *r++;                                   \
+        }                                                                   \
+    }
+
+UN_SEQ_3(un_ccc8,  uint8_t)
+PA_SEQ_3(pa_ccc8,  uint8_t)
+UN_SEQ_3(un_ccc16, uint16_t)
+PA_SEQ_3(pa_ccc16, uint16_t)
+
+// "regular": single packed plane, all components have same width (except padding)
+struct regular_repacker {
+    int packed_width;       // number of bits of the packed pixel
+    int component_width;    // number of bits for a single component
+    int prepadding;         // number of bits of LSB padding
+    int num_components;     // number of components that can be accessed
+    void (*pa_scanline)(void *a, void *b[], int w);
+    void (*un_scanline)(void *a, void *b[], int w);
+};
+
+static const struct regular_repacker regular_repackers[] = {
+    {32, 8,  0, 3, pa_ccc8z8,   un_ccc8x8},
+    {32, 8,  8, 3, pa_z8ccc8,   un_x8ccc8},
+    {32, 8,  0, 4, pa_cccc8,    un_cccc8},
+    {64, 16, 0, 4, pa_cccc16,   un_cccc16},
+    {64, 16, 0, 3, pa_ccc16z16, un_ccc16x16},
+    {24, 8,  0, 3, pa_ccc8,     un_ccc8},
+    {48, 16, 0, 3, pa_ccc16,    un_ccc16},
+    {16, 8,  0, 2, pa_cc8,      un_cc8},
+    {32, 16, 0, 2, pa_cc16,     un_cc16},
+    {32, 10, 0, 3, pa_ccc10z2,  un_ccc10x2},
+};
+
+static void packed_repack(struct mp_repack *rp,
+                          struct mp_image *a, int a_x, int a_y,
+                          struct mp_image *b, int b_x, int b_y, int w)
+{
+    uint32_t *pa = mp_image_pixel_ptr(a, 0, a_x, a_y);
+
+    void *pb[4] = {0};
+    for (int p = 0; p < b->num_planes; p++) {
+        int s = rp->components[p];
+        pb[p] = mp_image_pixel_ptr(b, s, b_x, b_y);
+    }
+
+    rp->packed_repack_scanline(pa, pb, w);
+}
+
+// Tries to set a packer/unpacker for component-wise byte aligned formats.
+static void setup_packed_packer(struct mp_repack *rp)
+{
+    struct mp_imgfmt_desc desc = mp_imgfmt_get_desc(rp->imgfmt_a);
+    if (!(desc.flags & MP_IMGFLAG_HAS_COMPS) ||
+        !(desc.flags & MP_IMGFLAG_TYPE_UINT) ||
+        !(desc.flags & MP_IMGFLAG_NE) ||
+        desc.num_planes != 1)
+        return;
+
+    int num_real_components = 0;
+    int components[4] = {0};
+    for (int n = 0; n < MP_NUM_COMPONENTS; n++) {
+        if (!desc.comps[n].size)
+            continue;
+        if (desc.comps[n].size != desc.comps[0].size ||
+            desc.comps[n].pad != desc.comps[0].pad ||
+            desc.comps[n].offset % desc.comps[0].size)
+            return;
+        int item = desc.comps[n].offset / desc.comps[0].size;
+        if (item >= 4)
+            return;
+        components[item] = n + 1;
+        num_real_components++;
+    }
+
+    int depth = desc.comps[0].size + MPMIN(0, desc.comps[0].pad);
+
+    static const int reorder_gbrp[] = {0, 3, 1, 2, 4};
+    static const int reorder_yuv[] = {0, 1, 2, 3, 4};
+    int planar_fmt = 0;
+    const int *reorder = NULL;
+    if (desc.flags & MP_IMGFLAG_COLOR_YUV) {
+        planar_fmt = find_yuv_format(depth, num_real_components);
+        reorder = reorder_yuv;
+    } else {
+        planar_fmt = find_gbrp_format(depth, num_real_components);
+        reorder = reorder_gbrp;
+    }
+    if (!planar_fmt)
+        return;
+
+    for (int i = 0; i < MP_ARRAY_SIZE(regular_repackers); i++) {
+        const struct regular_repacker *pa = &regular_repackers[i];
+
+        // The following may assume little endian (because some repack backends
+        // use word access, while the metadata here uses byte access).
+
+        int prepad = components[0] ? 0 : 8;
+        int first_comp = components[0] ? 0 : 1;
+        void (*repack_cb)(void *pa, void *pb[], int w) =
+            rp->pack ? pa->pa_scanline : pa->un_scanline;
+
+        if (pa->packed_width != desc.bpp[0] ||
+            pa->component_width != depth ||
+            pa->num_components != num_real_components ||
+            pa->prepadding != prepad ||
+            !repack_cb)
+            continue;
+
+        rp->repack = packed_repack;
+        rp->packed_repack_scanline = repack_cb;
+        rp->imgfmt_b = planar_fmt;
+        for (int n = 0; n < num_real_components; n++) {
+            // Determine permutation that maps component order between the two
+            // formats, with has_alpha special case (see above).
+            int c = reorder[components[first_comp + n]];
+            rp->components[n] = c == 4 ? num_real_components - 1 : c - 1;
+        }
+        return;
+    }
+}
+
+#define PA_SHIFT_LUT8(name, packed_t)                                       \
+    static void name(void *dst, void *src[], int w, uint8_t *lut,           \
+                     uint8_t s0, uint8_t s1, uint8_t s2) {                  \
+        for (int x = 0; x < w; x++) {                                       \
+            ((packed_t *)dst)[x] =                                          \
+                (lut[((uint8_t *)src[0])[x] + 256 * 0] << s0) |             \
+                (lut[((uint8_t *)src[1])[x] + 256 * 1] << s1) |             \
+                (lut[((uint8_t *)src[2])[x] + 256 * 2] << s2);              \
+        }                                                                   \
+    }
+
+
+#define UN_SHIFT_LUT8(name, packed_t)                                       \
+    static void name(void *src, void *dst[], int w, uint8_t *lut,           \
+                     uint8_t s0, uint8_t s1, uint8_t s2) {                  \
+        for (int x = 0; x < w; x++) {                                       \
+            packed_t c = ((packed_t *)src)[x];                              \
+            ((uint8_t *)dst[0])[x] = lut[((c >> s0) & 0xFF) + 256 * 0];     \
+            ((uint8_t *)dst[1])[x] = lut[((c >> s1) & 0xFF) + 256 * 1];     \
+            ((uint8_t *)dst[2])[x] = lut[((c >> s2) & 0xFF) + 256 * 2];     \
+        }                                                                   \
+    }
+
+PA_SHIFT_LUT8(pa_shift_lut8_8,  uint8_t)
+PA_SHIFT_LUT8(pa_shift_lut8_16, uint16_t)
+UN_SHIFT_LUT8(un_shift_lut8_8,  uint8_t)
+UN_SHIFT_LUT8(un_shift_lut8_16, uint16_t)
+
+static void fringe_rgb_repack(struct mp_repack *rp,
+                              struct mp_image *a, int a_x, int a_y,
+                              struct mp_image *b, int b_x, int b_y, int w)
+{
+    void *pa = mp_image_pixel_ptr(a, 0, a_x, a_y);
+
+    void *pb[4] = {0};
+    for (int p = 0; p < b->num_planes; p++) {
+        int s = rp->components[p];
+        pb[p] = mp_image_pixel_ptr(b, s, b_x, b_y);
+    }
+
+    assert(rp->comp_size == 1 || rp->comp_size == 2);
+
+    void (*repack)(void *pa, void *pb[], int w, uint8_t *lut,
+                   uint8_t s0, uint8_t s1, uint8_t s2) = NULL;
+    if (rp->pack) {
+        repack = rp->comp_size == 1 ? pa_shift_lut8_8 : pa_shift_lut8_16;
+    } else {
+        repack = rp->comp_size == 1 ? un_shift_lut8_8 : un_shift_lut8_16;
+    }
+    repack(pa, pb, w, rp->comp_lut,
+           rp->comp_shifts[0], rp->comp_shifts[1], rp->comp_shifts[2]);
+}
+
+static void setup_fringe_rgb_packer(struct mp_repack *rp)
+{
+    struct mp_imgfmt_desc desc = mp_imgfmt_get_desc(rp->imgfmt_a);
+    if (!(desc.flags & MP_IMGFLAG_HAS_COMPS))
+        return;
+
+    if (desc.bpp[0] > 16 || (desc.bpp[0] % 8u) ||
+        mp_imgfmt_get_forced_csp(rp->imgfmt_a) != MP_CSP_RGB ||
+        desc.num_planes != 1 || desc.comps[3].size)
+        return;
+
+    int depth = desc.comps[0].size;
+    for (int n = 0; n < 3; n++) {
+        struct mp_imgfmt_comp_desc *c = &desc.comps[n];
+
+        if (c->size < 1 || c->size > 8 || c->pad)
+            return;
+
+        if (rp->flags & REPACK_CREATE_ROUND_DOWN) {
+            depth = MPMIN(depth, c->size);
+        } else {
+            depth = MPMAX(depth, c->size);
+        }
+    }
+    if (rp->flags & REPACK_CREATE_EXPAND_8BIT)
+        depth = 8;
+
+    rp->imgfmt_b = find_gbrp_format(depth, 3);
+    if (!rp->imgfmt_b)
+        return;
+    rp->comp_lut = talloc_array(rp, uint8_t, 256 * 3);
+    rp->repack = fringe_rgb_repack;
+    for (int n = 0; n < 3; n++)
+        rp->components[n] = ((int[]){3, 1, 2})[n] - 1;
+
+    for (int n = 0; n < 3; n++) {
+        int bits = desc.comps[n].size;
+        rp->comp_shifts[n] = desc.comps[n].offset;
+        if (rp->comp_lut) {
+            uint8_t *lut = rp->comp_lut + 256 * n;
+            uint8_t zmax = (1 << depth) - 1;
+            uint8_t cmax = (1 << bits) - 1;
+            for (int v = 0; v < 256; v++) {
+                if (rp->pack) {
+                    lut[v] = (v * cmax + zmax / 2) / zmax;
+                } else {
+                    lut[v] = (v & cmax) * zmax / cmax;
+                }
+            }
+        }
+    }
+
+    rp->comp_size = (desc.bpp[0] + 7) / 8;
+    assert(rp->comp_size == 1 || rp->comp_size == 2);
+
+    if (desc.endian_shift) {
+        assert(rp->comp_size == 2 && (1 << desc.endian_shift) == 2);
+        rp->endian_size = 2;
+    }
+}
+
+static void unpack_pal(struct mp_repack *rp,
+                       struct mp_image *a, int a_x, int a_y,
+                       struct mp_image *b, int b_x, int b_y, int w)
+{
+    uint8_t *src = mp_image_pixel_ptr(a, 0, a_x, a_y);
+    uint32_t *pal = (void *)a->planes[1];
+
+    uint8_t *dst[4] = {0};
+    for (int p = 0; p < b->num_planes; p++)
+        dst[p] = mp_image_pixel_ptr(b, p, b_x, b_y);
+
+    for (int x = 0; x < w; x++) {
+        uint32_t c = pal[src[x]];
+        dst[0][x] = (c >>  8) & 0xFF; // G
+        dst[1][x] = (c >>  0) & 0xFF; // B
+        dst[2][x] = (c >> 16) & 0xFF; // R
+        dst[3][x] = (c >> 24) & 0xFF; // A
+    }
+}
+
+static void bitmap_repack(struct mp_repack *rp,
+                          struct mp_image *a, int a_x, int a_y,
+                          struct mp_image *b, int b_x, int b_y, int w)
+{
+    uint8_t *pa = mp_image_pixel_ptr(a, 0, a_x, a_y);
+    uint8_t *pb = mp_image_pixel_ptr(b, 0, b_x, b_y);
+
+    if (rp->pack) {
+        for (unsigned x = 0; x < w; x += 8) {
+            uint8_t d = 0;
+            int max_b = MPMIN(8, w - x);
+            for (int bp = 0; bp < max_b; bp++)
+                d |= (rp->comp_lut[pb[x + bp]]) << (7 - bp);
+            pa[x / 8] = d;
+        }
+    } else {
+        for (unsigned x = 0; x < w; x += 8) {
+            uint8_t d = pa[x / 8];
+            int max_b = MPMIN(8, w - x);
+            for (int bp = 0; bp < max_b; bp++)
+                pb[x + bp] = rp->comp_lut[d & (1 << (7 - bp))];
+        }
+    }
+}
+
+static void setup_misc_packer(struct mp_repack *rp)
+{
+    if (rp->imgfmt_a == IMGFMT_PAL8 && !rp->pack) {
+        int grap_fmt = find_gbrp_format(8, 4);
+        if (!grap_fmt)
+            return;
+        rp->imgfmt_b = grap_fmt;
+        rp->repack = unpack_pal;
+    } else {
+        enum AVPixelFormat avfmt = imgfmt2pixfmt(rp->imgfmt_a);
+        if (avfmt == AV_PIX_FMT_MONOWHITE || avfmt == AV_PIX_FMT_MONOBLACK) {
+            rp->comp_lut = talloc_array(rp, uint8_t, 256);
+            rp->imgfmt_b = IMGFMT_Y1;
+            int max = 1;
+            if (rp->flags & REPACK_CREATE_EXPAND_8BIT) {
+                rp->imgfmt_b = IMGFMT_Y8;
+                max = 255;
+            }
+            bool inv = avfmt == AV_PIX_FMT_MONOWHITE;
+            for (int n = 0; n < 256; n++) {
+                rp->comp_lut[n] = rp->pack ? (inv ^ (n >= (max + 1) / 2))
+                                           : ((inv ^ !!n) ? max : 0);
+            }
+            rp->repack = bitmap_repack;
+            return;
+        }
+    }
+}
+
+#define PA_P422(name, comp_t)                                               \
+    static void name(void *dst, void *src[], int w, uint8_t *c) {           \
+        for (int x = 0; x < w; x += 2) {                                    \
+            ((comp_t *)dst)[x * 2 + c[0]] = ((comp_t *)src[0])[x + 0];      \
+            ((comp_t *)dst)[x * 2 + c[1]] = ((comp_t *)src[0])[x + 1];      \
+            ((comp_t *)dst)[x * 2 + c[4]] = ((comp_t *)src[1])[x >> 1];     \
+            ((comp_t *)dst)[x * 2 + c[5]] = ((comp_t *)src[2])[x >> 1];     \
+        }                                                                   \
+    }
+
+
+#define UN_P422(name, comp_t)                                               \
+    static void name(void *src, void *dst[], int w, uint8_t *c) {           \
+        for (int x = 0; x < w; x += 2) {                                    \
+            ((comp_t *)dst[0])[x + 0]  = ((comp_t *)src)[x * 2 + c[0]];     \
+            ((comp_t *)dst[0])[x + 1]  = ((comp_t *)src)[x * 2 + c[1]];     \
+            ((comp_t *)dst[1])[x >> 1] = ((comp_t *)src)[x * 2 + c[4]];     \
+            ((comp_t *)dst[2])[x >> 1] = ((comp_t *)src)[x * 2 + c[5]];     \
+        }                                                                   \
+    }
+
+PA_P422(pa_p422_8,  uint8_t)
+PA_P422(pa_p422_16, uint16_t)
+UN_P422(un_p422_8,  uint8_t)
+UN_P422(un_p422_16, uint16_t)
+
+static void pa_p411_8(void *dst, void *src[], int w, uint8_t *c)
+{
+    for (int x = 0; x < w; x += 4) {
+        ((uint8_t *)dst)[x / 4 * 6 + c[0]] = ((uint8_t *)src[0])[x + 0];
+        ((uint8_t *)dst)[x / 4 * 6 + c[1]] = ((uint8_t *)src[0])[x + 1];
+        ((uint8_t *)dst)[x / 4 * 6 + c[2]] = ((uint8_t *)src[0])[x + 2];
+        ((uint8_t *)dst)[x / 4 * 6 + c[3]] = ((uint8_t *)src[0])[x + 3];
+        ((uint8_t *)dst)[x / 4 * 6 + c[4]] = ((uint8_t *)src[1])[x >> 2];
+        ((uint8_t *)dst)[x / 4 * 6 + c[5]] = ((uint8_t *)src[2])[x >> 2];
+    }
+}
+
+
+static void un_p411_8(void *src, void *dst[], int w, uint8_t *c)
+{
+    for (int x = 0; x < w; x += 4) {
+        ((uint8_t *)dst[0])[x + 0]  = ((uint8_t *)src)[x / 4 * 6 + c[0]];
+        ((uint8_t *)dst[0])[x + 1]  = ((uint8_t *)src)[x / 4 * 6 + c[1]];
+        ((uint8_t *)dst[0])[x + 2]  = ((uint8_t *)src)[x / 4 * 6 + c[2]];
+        ((uint8_t *)dst[0])[x + 3]  = ((uint8_t *)src)[x / 4 * 6 + c[3]];
+        ((uint8_t *)dst[1])[x >> 2] = ((uint8_t *)src)[x / 4 * 6 + c[4]];
+        ((uint8_t *)dst[2])[x >> 2] = ((uint8_t *)src)[x / 4 * 6 + c[5]];
+    }
+}
+
+static void fringe_yuv_repack(struct mp_repack *rp,
+                              struct mp_image *a, int a_x, int a_y,
+                              struct mp_image *b, int b_x, int b_y, int w)
+{
+    void *pa = mp_image_pixel_ptr(a, 0, a_x, a_y);
+
+    void *pb[4] = {0};
+    for (int p = 0; p < b->num_planes; p++)
+        pb[p] = mp_image_pixel_ptr(b, p, b_x, b_y);
+
+    rp->repack_fringe_yuv(pa, pb, w, rp->comp_map);
+}
+
+static void setup_fringe_yuv_packer(struct mp_repack *rp)
+{
+    struct mp_imgfmt_desc desc = mp_imgfmt_get_desc(rp->imgfmt_a);
+    if (!(desc.flags & MP_IMGFLAG_PACKED_SS_YUV) ||
+        mp_imgfmt_desc_get_num_comps(&desc) != 3 ||
+        desc.align_x > 4)
+        return;
+
+    uint8_t y_loc[4];
+    if (!mp_imgfmt_get_packed_yuv_locations(desc.id, y_loc))
+        return;
+
+    for (int n = 0; n < MP_NUM_COMPONENTS; n++) {
+        if (!desc.comps[n].size)
+            continue;
+        if (desc.comps[n].size != desc.comps[0].size ||
+            desc.comps[n].pad < 0 ||
+            desc.comps[n].offset % desc.comps[0].size)
+            return;
+        if (n == 1 || n == 2) {
+            rp->comp_map[4 + (n - 1)] =
+                desc.comps[n].offset / desc.comps[0].size;
+        }
+    }
+    for (int n = 0; n < desc.align_x; n++) {
+        if (y_loc[n] % desc.comps[0].size)
+            return;
+        rp->comp_map[n] = y_loc[n] / desc.comps[0].size;
+    }
+
+    if (desc.comps[0].size == 8 && desc.align_x == 2) {
+        rp->repack_fringe_yuv = rp->pack ? pa_p422_8 : un_p422_8;
+    } else if (desc.comps[0].size == 16 && desc.align_x == 2) {
+        rp->repack_fringe_yuv = rp->pack ? pa_p422_16 : un_p422_16;
+    } else if (desc.comps[0].size == 8 && desc.align_x == 4) {
+        rp->repack_fringe_yuv = rp->pack ? pa_p411_8 : un_p411_8;
+    }
+
+    if (!rp->repack_fringe_yuv)
+        return;
+
+    struct mp_regular_imgfmt yuvfmt = {
+        .component_type = MP_COMPONENT_TYPE_UINT,
+        // NB: same problem with P010 and not clearing padding.
+        .component_size = desc.comps[0].size / 8u,
+        .num_planes = 3,
+        .planes = { {1, {1}}, {1, {2}}, {1, {3}} },
+        .chroma_xs = desc.chroma_xs,
+        .chroma_ys = 0,
+    };
+    rp->imgfmt_b = mp_find_regular_imgfmt(&yuvfmt);
+    rp->repack = fringe_yuv_repack;
+
+    if (desc.endian_shift) {
+        rp->endian_size = 1 << desc.endian_shift;
+        assert(rp->endian_size == 2);
+    }
+}
+
+static void repack_nv(struct mp_repack *rp,
+                      struct mp_image *a, int a_x, int a_y,
+                      struct mp_image *b, int b_x, int b_y, int w)
+{
+    int xs = a->fmt.chroma_xs;
+
+    uint32_t *pa = mp_image_pixel_ptr(a, 1, a_x, a_y);
+
+    void *pb[2];
+    for (int p = 0; p < 2; p++) {
+        int s = rp->components[p];
+        pb[p] = mp_image_pixel_ptr(b, s, b_x, b_y);
+    }
+
+    rp->packed_repack_scanline(pa, pb, (w + (1 << xs) - 1) >> xs);
+}
+
+static void setup_nv_packer(struct mp_repack *rp)
+{
+    struct mp_regular_imgfmt desc;
+    if (!mp_get_regular_imgfmt(&desc, rp->imgfmt_a))
+        return;
+
+    // Check for NV.
+    if (desc.num_planes != 2)
+        return;
+    if (desc.planes[0].num_components != 1 || desc.planes[0].components[0] != 1)
+        return;
+    if (desc.planes[1].num_components != 2)
+        return;
+    int cr0 = desc.planes[1].components[0];
+    int cr1 = desc.planes[1].components[1];
+    if (cr0 > cr1)
+        MPSWAP(int, cr0, cr1);
+    if (cr0 != 2 || cr1 != 3)
+        return;
+
+    // Construct equivalent planar format.
+    struct mp_regular_imgfmt desc2 = desc;
+    desc2.num_planes = 3;
+    desc2.planes[1].num_components = 1;
+    desc2.planes[1].components[0] = 2;
+    desc2.planes[2].num_components = 1;
+    desc2.planes[2].components[0] = 3;
+    // For P010. Strangely this concept exists only for the NV format.
+    if (desc2.component_pad > 0)
+        desc2.component_pad = 0;
+
+    int planar_fmt = mp_find_regular_imgfmt(&desc2);
+    if (!planar_fmt)
+        return;
+
+    for (int i = 0; i < MP_ARRAY_SIZE(regular_repackers); i++) {
+        const struct regular_repacker *pa = &regular_repackers[i];
+
+        void (*repack_cb)(void *pa, void *pb[], int w) =
+            rp->pack ? pa->pa_scanline : pa->un_scanline;
+
+        if (pa->packed_width != desc.component_size * 2 * 8 ||
+            pa->component_width != desc.component_size * 8 ||
+            pa->num_components != 2 ||
+            pa->prepadding != 0 ||
+            !repack_cb)
+            continue;
+
+        rp->repack = repack_nv;
+        rp->passthrough_y = true;
+        rp->packed_repack_scanline = repack_cb;
+        rp->imgfmt_b = planar_fmt;
+        rp->components[0] = desc.planes[1].components[0] - 1;
+        rp->components[1] = desc.planes[1].components[1] - 1;
+        return;
+    }
+}
+
+#define PA_F32(name, packed_t)                                              \
+    static void name(void *dst, float *src, int w, float m, float o,        \
+                     uint32_t p_max) {                                      \
+        for (int x = 0; x < w; x++) {                                       \
+            ((packed_t *)dst)[x] =                                          \
+                MPCLAMP(lrint((src[x] + o) * m), 0, (packed_t)p_max);       \
+        }                                                                   \
+    }
+
+#define UN_F32(name, packed_t)                                              \
+    static void name(void *src, float *dst, int w, float m, float o,        \
+                     uint32_t unused) {                                     \
+        for (int x = 0; x < w; x++)                                         \
+            dst[x] = ((packed_t *)src)[x] * m + o;                          \
+    }
+
+PA_F32(pa_f32_8, uint8_t)
+UN_F32(un_f32_8, uint8_t)
+PA_F32(pa_f32_16, uint16_t)
+UN_F32(un_f32_16, uint16_t)
+
+// In all this, float counts as "unpacked".
+static void repack_float(struct mp_repack *rp,
+                         struct mp_image *a, int a_x, int a_y,
+                         struct mp_image *b, int b_x, int b_y, int w)
+{
+    assert(rp->f32_comp_size == 1 || rp->f32_comp_size == 2);
+
+    void (*packer)(void *a, float *b, int w, float fm, float fb, uint32_t max)
+        = rp->pack ? (rp->f32_comp_size == 1 ? pa_f32_8 : pa_f32_16)
+                   : (rp->f32_comp_size == 1 ? un_f32_8 : un_f32_16);
+
+    for (int p = 0; p < b->num_planes; p++) {
+        int h = (1 << b->fmt.chroma_ys) - (1 << b->fmt.ys[p]) + 1;
+        for (int y = 0; y < h; y++) {
+            void *pa = mp_image_pixel_ptr_ny(a, p, a_x, a_y + y);
+            void *pb = mp_image_pixel_ptr_ny(b, p, b_x, b_y + y);
+
+            packer(pa, pb, w >> b->fmt.xs[p], rp->f32_m[p], rp->f32_o[p],
+                   rp->f32_pmax[p]);
+        }
+    }
+}
+
+static void update_repack_float(struct mp_repack *rp)
+{
+    if (!rp->f32_comp_size)
+        return;
+
+    // Image in input format.
+    struct mp_image *ui =  rp->pack ? rp->steps[rp->num_steps - 1].buf[1]
+                                    : rp->steps[0].buf[0];
+    enum mp_csp csp = ui->params.color.space;
+    enum mp_csp_levels levels = ui->params.color.levels;
+    if (rp->f32_csp_space == csp && rp->f32_csp_levels == levels)
+        return;
+
+    // The fixed point format.
+    struct mp_regular_imgfmt desc = {0};
+    mp_get_regular_imgfmt(&desc, rp->imgfmt_b);
+    assert(desc.component_size);
+
+    int comp_bits = desc.component_size * 8 + MPMIN(desc.component_pad, 0);
+    for (int p = 0; p < desc.num_planes; p++) {
+        double m, o;
+        mp_get_csp_uint_mul(csp, levels, comp_bits, desc.planes[p].components[0],
+                            &m, &o);
+        rp->f32_m[p] = rp->pack ? 1.0 / m : m;
+        rp->f32_o[p] = rp->pack ? -o      : o;
+        rp->f32_pmax[p] = (1u << comp_bits) - 1;
+    }
+
+    rp->f32_csp_space = csp;
+    rp->f32_csp_levels = levels;
+}
+
+void repack_line(struct mp_repack *rp, int dst_x, int dst_y,
+                 int src_x, int src_y, int w)
+{
+    assert(rp->configured);
+
+    struct repack_step *first = &rp->steps[0];
+    struct repack_step *last = &rp->steps[rp->num_steps - 1];
+
+    assert(dst_x >= 0 && dst_y >= 0 && src_x >= 0 && src_y >= 0 && w >= 0);
+    assert(dst_x + w <= MP_ALIGN_UP(last->buf[1]->w, last->fmt[1].align_x));
+    assert(src_x + w <= MP_ALIGN_UP(first->buf[0]->w, first->fmt[0].align_x));
+    assert(dst_y < last->buf[1]->h);
+    assert(src_y < first->buf[0]->h);
+    assert(!(dst_x & (last->fmt[1].align_x - 1)));
+    assert(!(src_x & (first->fmt[0].align_x - 1)));
+    assert(!(w & ((1 << first->fmt[0].chroma_xs) - 1)));
+    assert(!(dst_y & (last->fmt[1].align_y - 1)));
+    assert(!(src_y & (first->fmt[0].align_y - 1)));
+
+    for (int n = 0; n < rp->num_steps; n++) {
+        struct repack_step *rs = &rp->steps[n];
+
+        // When writing to temporary buffers, always write to the start (maybe
+        // helps with locality).
+        int sx = rs->user_buf[0] ? src_x : 0;
+        int sy = rs->user_buf[0] ? src_y : 0;
+        int dx = rs->user_buf[1] ? dst_x : 0;
+        int dy = rs->user_buf[1] ? dst_y : 0;
+
+        struct mp_image *buf_a = rs->buf[rp->pack];
+        struct mp_image *buf_b = rs->buf[!rp->pack];
+        int a_x = rp->pack ? dx : sx;
+        int a_y = rp->pack ? dy : sy;
+        int b_x = rp->pack ? sx : dx;
+        int b_y = rp->pack ? sy : dy;
+
+        switch (rs->type) {
+        case REPACK_STEP_REPACK: {
+            if (rp->repack)
+                rp->repack(rp, buf_a, a_x, a_y, buf_b, b_x, b_y, w);
+
+            for (int p = 0; p < rs->fmt[0].num_planes; p++) {
+                if (rp->copy_buf[p])
+                    copy_plane(rs->buf[1], dx, dy, rs->buf[0], sx, sy, w, p);
+            }
+            break;
+        }
+        case REPACK_STEP_ENDIAN:
+            swap_endian(rs->buf[1], dx, dy, rs->buf[0], sx, sy, w,
+                        rp->endian_size);
+            break;
+        case REPACK_STEP_FLOAT:
+            repack_float(rp, buf_a, a_x, a_y, buf_b, b_x, b_y, w);
+            break;
+        }
+    }
+}
+
+static bool setup_format_ne(struct mp_repack *rp)
+{
+    if (!rp->imgfmt_b)
+        setup_nv_packer(rp);
+    if (!rp->imgfmt_b)
+        setup_misc_packer(rp);
+    if (!rp->imgfmt_b)
+        setup_packed_packer(rp);
+    if (!rp->imgfmt_b)
+        setup_fringe_rgb_packer(rp);
+    if (!rp->imgfmt_b)
+        setup_fringe_yuv_packer(rp);
+    if (!rp->imgfmt_b)
+        rp->imgfmt_b = rp->imgfmt_a; // maybe it was planar after all
+
+    struct mp_regular_imgfmt desc;
+    if (!mp_get_regular_imgfmt(&desc, rp->imgfmt_b))
+        return false;
+
+    // no weird stuff
+    if (desc.num_planes > 4)
+        return false;
+
+    // Endian swapping.
+    if (rp->imgfmt_a != rp->imgfmt_user &&
+        rp->imgfmt_a == mp_find_other_endian(rp->imgfmt_user))
+    {
+        struct mp_imgfmt_desc desc_a = mp_imgfmt_get_desc(rp->imgfmt_a);
+        struct mp_imgfmt_desc desc_u = mp_imgfmt_get_desc(rp->imgfmt_user);
+        rp->endian_size = 1 << desc_u.endian_shift;
+        if (!desc_a.endian_shift && rp->endian_size != 2 && rp->endian_size != 4)
+            return false;
+    }
+
+    // Accept only true planar formats (with known components and no padding).
+    for (int n = 0; n < desc.num_planes; n++) {
+        if (desc.planes[n].num_components != 1)
+            return false;
+        int c = desc.planes[n].components[0];
+        if (c < 1 || c > 4)
+            return false;
+    }
+
+    rp->fmt_a = mp_imgfmt_get_desc(rp->imgfmt_a);
+    rp->fmt_b = mp_imgfmt_get_desc(rp->imgfmt_b);
+
+    // This is if we did a pack step.
+
+    if (rp->flags & REPACK_CREATE_PLANAR_F32) {
+        // imgfmt_b with float32 component type.
+        struct mp_regular_imgfmt fdesc = desc;
+        fdesc.component_type = MP_COMPONENT_TYPE_FLOAT;
+        fdesc.component_size = 4;
+        fdesc.component_pad = 0;
+        int ffmt = mp_find_regular_imgfmt(&fdesc);
+        if (!ffmt)
+            return false;
+        if (ffmt != rp->imgfmt_b) {
+            if (desc.component_type != MP_COMPONENT_TYPE_UINT ||
+                (desc.component_size != 1 && desc.component_size != 2))
+                return false;
+            rp->f32_comp_size = desc.component_size;
+            rp->f32_csp_space = MP_CSP_COUNT;
+            rp->f32_csp_levels = MP_CSP_LEVELS_COUNT;
+            rp->steps[rp->num_steps++] = (struct repack_step) {
+                .type = REPACK_STEP_FLOAT,
+                .fmt = {
+                    mp_imgfmt_get_desc(ffmt),
+                    rp->fmt_b,
+                },
+            };
+        }
+    }
+
+    rp->steps[rp->num_steps++] = (struct repack_step) {
+        .type = REPACK_STEP_REPACK,
+        .fmt = { rp->fmt_b, rp->fmt_a },
+    };
+
+    if (rp->endian_size) {
+        rp->steps[rp->num_steps++] = (struct repack_step) {
+            .type = REPACK_STEP_ENDIAN,
+            .fmt = {
+                rp->fmt_a,
+                mp_imgfmt_get_desc(rp->imgfmt_user),
+            },
+        };
+    }
+
+    // Reverse if unpack (to reflect actual data flow)
+    if (!rp->pack) {
+        for (int n = 0; n < rp->num_steps / 2; n++) {
+            MPSWAP(struct repack_step, rp->steps[n],
+                   rp->steps[rp->num_steps - 1 - n]);
+        }
+        for (int n = 0; n < rp->num_steps; n++) {
+            struct repack_step *rs = &rp->steps[n];
+            MPSWAP(struct mp_imgfmt_desc, rs->fmt[0], rs->fmt[1]);
+        }
+    }
+
+    for (int n = 0; n < rp->num_steps - 1; n++)
+        assert(rp->steps[n].fmt[1].id == rp->steps[n + 1].fmt[0].id);
+
+    return true;
+}
+
+static void reset_params(struct mp_repack *rp)
+{
+    rp->num_steps = 0;
+    rp->imgfmt_b = 0;
+    rp->repack = NULL;
+    rp->passthrough_y = false;
+    rp->endian_size = 0;
+    rp->packed_repack_scanline = NULL;
+    rp->comp_size = 0;
+    talloc_free(rp->comp_lut);
+    rp->comp_lut = NULL;
+}
+
+static bool setup_format(struct mp_repack *rp)
+{
+    reset_params(rp);
+    rp->imgfmt_a = rp->imgfmt_user;
+    if (setup_format_ne(rp))
+        return true;
+    // Try reverse endian.
+    reset_params(rp);
+    rp->imgfmt_a = mp_find_other_endian(rp->imgfmt_user);
+    return rp->imgfmt_a && setup_format_ne(rp);
+}
+
+struct mp_repack *mp_repack_create_planar(int imgfmt, bool pack, int flags)
+{
+    struct mp_repack *rp = talloc_zero(NULL, struct mp_repack);
+    rp->imgfmt_user = imgfmt;
+    rp->pack = pack;
+    rp->flags = flags;
+
+    if (!setup_format(rp)) {
+        talloc_free(rp);
+        return NULL;
+    }
+
+    return rp;
+}
+
+int mp_repack_get_format_src(struct mp_repack *rp)
+{
+    return rp->steps[0].fmt[0].id;
+}
+
+int mp_repack_get_format_dst(struct mp_repack *rp)
+{
+    return rp->steps[rp->num_steps - 1].fmt[1].id;
+}
+
+int mp_repack_get_align_x(struct mp_repack *rp)
+{
+    // We really want the LCM between those, but since only one of them is
+    // packed (or they're the same format), and the chroma subsampling is the
+    // same for both, only the packed one matters.
+    return rp->fmt_a.align_x;
+}
+
+int mp_repack_get_align_y(struct mp_repack *rp)
+{
+    return rp->fmt_a.align_y; // should be the same for packed/planar formats
+}
+
+static void image_realloc(struct mp_image **img, int fmt, int w, int h)
+{
+    if (*img && (*img)->imgfmt == fmt && (*img)->w == w && (*img)->h == h)
+        return;
+    talloc_free(*img);
+    *img = mp_image_alloc(fmt, w, h);
+}
+
+bool repack_config_buffers(struct mp_repack *rp,
+                           int dst_flags, struct mp_image *dst,
+                           int src_flags, struct mp_image *src,
+                           bool *enable_passthrough)
+{
+    struct repack_step *rs_first = &rp->steps[0];
+    struct repack_step *rs_last = &rp->steps[rp->num_steps - 1];
+
+    rp->configured = false;
+
+    assert(dst && src);
+
+    int buf_w = MPMAX(dst->w, src->w);
+
+    assert(dst->imgfmt == rs_last->fmt[1].id);
+    assert(src->imgfmt == rs_first->fmt[0].id);
+
+    // Chain/allocate buffers.
+
+    for (int n = 0; n < rp->num_steps; n++)
+        rp->steps[n].buf[0] = rp->steps[n].buf[1] = NULL;
+
+    rs_first->buf[0] = src;
+    rs_last->buf[1] = dst;
+
+    for (int n = 0; n < rp->num_steps; n++) {
+        struct repack_step *rs = &rp->steps[n];
+
+        if (!rs->buf[0]) {
+            assert(n > 0);
+            rs->buf[0] = rp->steps[n - 1].buf[1];
+        }
+
+        if (rs->buf[1])
+            continue;
+
+        // Note: since repack_line() can have different src/dst offsets, we
+        //       can't do true in-place in general.
+        bool can_inplace = rs->type == REPACK_STEP_ENDIAN &&
+                           rs->buf[0] != src && rs->buf[0] != dst;
+        if (can_inplace) {
+            rs->buf[1] = rs->buf[0];
+            continue;
+        }
+
+        if (rs != rs_last) {
+            struct repack_step *next = &rp->steps[n + 1];
+            if (next->buf[0]) {
+                rs->buf[1] = next->buf[0];
+                continue;
+            }
+        }
+
+        image_realloc(&rs->tmp, rs->fmt[1].id, buf_w, rs->fmt[1].align_y);
+        if (!rs->tmp)
+            return false;
+        talloc_steal(rp, rs->tmp);
+        rs->buf[1] = rs->tmp;
+    }
+
+    for (int n = 0; n < rp->num_steps; n++) {
+        struct repack_step *rs = &rp->steps[n];
+        rs->user_buf[0] = rs->buf[0] == src || rs->buf[0] == dst;
+        rs->user_buf[1] = rs->buf[1] == src || rs->buf[1] == dst;
+    }
+
+    // If repacking is the only operation. It's also responsible for simply
+    // copying src to dst if absolutely no filtering is done.
+    bool may_passthrough =
+        rp->num_steps == 1 && rp->steps[0].type == REPACK_STEP_REPACK;
+
+    for (int p = 0; p < rp->fmt_b.num_planes; p++) {
+        // (All repack callbacks copy, except nv12 does not copy luma.)
+        bool repack_copies_plane = rp->repack && !(rp->passthrough_y && p == 0);
+
+        bool can_pt = may_passthrough && !repack_copies_plane &&
+                      enable_passthrough && enable_passthrough[p];
+
+        // Copy if needed, unless the repack callback does it anyway.
+        rp->copy_buf[p] = !repack_copies_plane && !can_pt;
+
+        if (enable_passthrough)
+            enable_passthrough[p] = can_pt && !rp->copy_buf[p];
+    }
+
+    if (enable_passthrough) {
+        for (int n = rp->fmt_b.num_planes; n < MP_MAX_PLANES; n++)
+            enable_passthrough[n] = false;
+    }
+
+    update_repack_float(rp);
+
+    rp->configured = true;
+
+    return true;
+}