diff mbox series

[FFmpeg-devel,v2,1/3] swscale/la: Optimize hscale functions with lasx.

Message ID 20220903022329.23371-2-chenhao@loongson.cn
State Superseded
Headers show
Series [FFmpeg-devel,v2,1/3] swscale/la: Optimize hscale functions with lasx. | expand

Checks

Context Check Description
yinshiyou/make_fate_loongarch64 success Make fate finished
yinshiyou/make_loongarch64 warning New warnings during build
andriy/make_x86 success Make finished
andriy/make_fate_x86 success Make fate finished

Commit Message

Hao Chen Sept. 3, 2022, 2:23 a.m. UTC
ffmpeg -i 1_h264_1080p_30fps_3Mbps.mp4 -f rawvideo -s 640x480 -y /dev/null -an
before: 101fps
after:  138fps

Signed-off-by: Hao Chen <chenhao@loongson.cn>
---
 libswscale/loongarch/Makefile                 |   3 +
 libswscale/loongarch/input_lasx.c             | 202 ++++
 libswscale/loongarch/swscale_init_loongarch.c |  50 +
 libswscale/loongarch/swscale_lasx.c           | 972 ++++++++++++++++++
 libswscale/loongarch/swscale_loongarch.h      |  50 +
 libswscale/swscale.c                          |   2 +
 libswscale/swscale_internal.h                 |   2 +
 libswscale/utils.c                            |  13 +-
 8 files changed, 1293 insertions(+), 1 deletion(-)
 create mode 100644 libswscale/loongarch/Makefile
 create mode 100644 libswscale/loongarch/input_lasx.c
 create mode 100644 libswscale/loongarch/swscale_init_loongarch.c
 create mode 100644 libswscale/loongarch/swscale_lasx.c
 create mode 100644 libswscale/loongarch/swscale_loongarch.h

Comments

Andreas Rheinhardt Sept. 3, 2022, 12:31 p.m. UTC | #1
Hao Chen:
> ffmpeg -i 1_h264_1080p_30fps_3Mbps.mp4 -f rawvideo -s 640x480 -y /dev/null -an
> before: 101fps
> after:  138fps
> 
> Signed-off-by: Hao Chen <chenhao@loongson.cn>
> ---
>  libswscale/loongarch/Makefile                 |   3 +
>  libswscale/loongarch/input_lasx.c             | 202 ++++
>  libswscale/loongarch/swscale_init_loongarch.c |  50 +
>  libswscale/loongarch/swscale_lasx.c           | 972 ++++++++++++++++++
>  libswscale/loongarch/swscale_loongarch.h      |  50 +
>  libswscale/swscale.c                          |   2 +
>  libswscale/swscale_internal.h                 |   2 +
>  libswscale/utils.c                            |  13 +-
>  8 files changed, 1293 insertions(+), 1 deletion(-)
>  create mode 100644 libswscale/loongarch/Makefile
>  create mode 100644 libswscale/loongarch/input_lasx.c
>  create mode 100644 libswscale/loongarch/swscale_init_loongarch.c
>  create mode 100644 libswscale/loongarch/swscale_lasx.c
>  create mode 100644 libswscale/loongarch/swscale_loongarch.h
> 
> diff --git a/libswscale/loongarch/Makefile b/libswscale/loongarch/Makefile
> new file mode 100644
> index 0000000000..586a1717b6
> --- /dev/null
> +++ b/libswscale/loongarch/Makefile
> @@ -0,0 +1,3 @@
> +OBJS-$(CONFIG_SWSCALE)      += loongarch/swscale_init_loongarch.o
> +LASX-OBJS-$(CONFIG_SWSCALE) += loongarch/swscale_lasx.o \
> +                               loongarch/input_lasx.o   \
> diff --git a/libswscale/loongarch/input_lasx.c b/libswscale/loongarch/input_lasx.c
> new file mode 100644
> index 0000000000..c3060ea6a3
> --- /dev/null
> +++ b/libswscale/loongarch/input_lasx.c
> @@ -0,0 +1,202 @@
> +/*
> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> + * Contributed by Hao Chen(chenhao@loongson.cn)
> + *
> + * This file is part of FFmpeg.
> + *
> + * FFmpeg 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.
> + *
> + * FFmpeg 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 FFmpeg; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include "swscale_loongarch.h"
> +#include "libavutil/loongarch/loongson_intrinsics.h"
> +
> +void planar_rgb_to_uv_lasx(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4],
> +                           int width, int32_t *rgb2yuv)
> +{
> +    int i;
> +    uint16_t *dstU   = (uint16_t *)_dstU;
> +    uint16_t *dstV   = (uint16_t *)_dstV;
> +    int set          = 0x4001 << (RGB2YUV_SHIFT - 7);
> +    int len          = width - 15;
> +    int32_t tem_ru   = rgb2yuv[RU_IDX], tem_gu = rgb2yuv[GU_IDX];
> +    int32_t tem_bu = rgb2yuv[BU_IDX], tem_rv   = rgb2yuv[RV_IDX];
> +    int32_t tem_gv = rgb2yuv[GV_IDX], tem_bv = rgb2yuv[BV_IDX];
> +    int shift        = RGB2YUV_SHIFT - 6;
> +    const uint8_t *src0 = src[0], *src1 = src[1], *src2 = src[2];
> +    __m256i ru, gu, bu, rv, gv, bv;
> +    __m256i mask = {0x0D0C090805040100, 0x1D1C191815141110,
> +                    0x0D0C090805040100, 0x1D1C191815141110};
> +    __m256i temp = __lasx_xvreplgr2vr_w(set);
> +    __m256i sra  = __lasx_xvreplgr2vr_w(shift);
> +
> +    ru = __lasx_xvreplgr2vr_w(tem_ru);
> +    gu = __lasx_xvreplgr2vr_w(tem_gu);
> +    bu = __lasx_xvreplgr2vr_w(tem_bu);
> +    rv = __lasx_xvreplgr2vr_w(tem_rv);
> +    gv = __lasx_xvreplgr2vr_w(tem_gv);
> +    bv = __lasx_xvreplgr2vr_w(tem_bv);
> +    for (i = 0; i < len; i += 16) {
> +        __m256i _g, _b, _r;
> +        __m256i g_l, g_h, b_l, b_h, r_l, r_h;
> +        __m256i v_l, v_h, u_l, u_h, u_lh, v_lh;
> +
> +        _g  = __lasx_xvldx(src0, i);

According to
https://patchwork.ffmpeg.org/project/ffmpeg/list/?series=7366 this
patchset creates new warnings and as I have explained in
https://ffmpeg.org/pipermail/ffmpeg-devel/2022-August/300682.html this
is (most likely) due to lasxintrin.h and lsxintrin.h not accepting
pointers to void in the load-functions. The above __lasx_xvldx() is
affected by this. Could you please fix this issue and provide an updated
toolchain able to compile lsx and lasx?

> +        _b  = __lasx_xvldx(src1, i);
> +        _r  = __lasx_xvldx(src2, i);
> +        g_l = __lasx_vext2xv_wu_bu(_g);
> +        b_l = __lasx_vext2xv_wu_bu(_b);
> +        r_l = __lasx_vext2xv_wu_bu(_r);
> +        _g  = __lasx_xvpermi_d(_g, 0x01);
> +        _b  = __lasx_xvpermi_d(_b, 0x01);
> +        _r  = __lasx_xvpermi_d(_r, 0x01);
> +        g_h = __lasx_vext2xv_wu_bu(_g);
> +        b_h = __lasx_vext2xv_wu_bu(_b);
> +        r_h = __lasx_vext2xv_wu_bu(_r);
> +        u_l  = __lasx_xvmadd_w(temp, ru, r_l);
> +        u_h  = __lasx_xvmadd_w(temp, ru, r_h);
> +        v_l  = __lasx_xvmadd_w(temp, rv, r_l);
> +        v_h  = __lasx_xvmadd_w(temp, rv, r_h);
> +        u_l  = __lasx_xvmadd_w(u_l, gu, g_l);
> +        u_l  = __lasx_xvmadd_w(u_l, bu, b_l);
> +        u_h  = __lasx_xvmadd_w(u_h, gu, g_h);
> +        u_h  = __lasx_xvmadd_w(u_h, bu, b_h);
> +        v_l  = __lasx_xvmadd_w(v_l, gv, g_l);
> +        v_l  = __lasx_xvmadd_w(v_l, bv, b_l);
> +        v_h  = __lasx_xvmadd_w(v_h, gv, g_h);
> +        v_h  = __lasx_xvmadd_w(v_h, bv, b_h);
> +        u_l  = __lasx_xvsra_w(u_l, sra);
> +        u_h  = __lasx_xvsra_w(u_h, sra);
> +        v_l  = __lasx_xvsra_w(v_l, sra);
> +        v_h  = __lasx_xvsra_w(v_h, sra);
> +        u_lh = __lasx_xvshuf_b(u_h, u_l, mask);
> +        v_lh = __lasx_xvshuf_b(v_h, v_l, mask);
> +        u_lh = __lasx_xvpermi_d(u_lh, 0xD8);
> +        v_lh = __lasx_xvpermi_d(v_lh, 0xD8);
> +        __lasx_xvst(u_lh, (dstU + i), 0);
> +        __lasx_xvst(v_lh, (dstV + i), 0);
> +    }
> +    if (width - i >= 8) {
> +        __m256i _g, _b, _r;
> +        __m256i g_l, b_l, r_l;
> +        __m256i v_l, u_l, u, v;
> +
> +        _g  = __lasx_xvldrepl_d((src0 + i), 0);
> +        _b  = __lasx_xvldrepl_d((src1 + i), 0);
> +        _r  = __lasx_xvldrepl_d((src2 + i), 0);
> +        g_l = __lasx_vext2xv_wu_bu(_g);
> +        b_l = __lasx_vext2xv_wu_bu(_b);
> +        r_l = __lasx_vext2xv_wu_bu(_r);
> +        u_l = __lasx_xvmadd_w(temp, ru, r_l);
> +        v_l = __lasx_xvmadd_w(temp, rv, r_l);
> +        u_l = __lasx_xvmadd_w(u_l, gu, g_l);
> +        u_l = __lasx_xvmadd_w(u_l, bu, b_l);
> +        v_l = __lasx_xvmadd_w(v_l, gv, g_l);
> +        v_l = __lasx_xvmadd_w(v_l, bv, b_l);
> +        u_l = __lasx_xvsra_w(u_l, sra);
> +        v_l = __lasx_xvsra_w(v_l, sra);
> +        u   = __lasx_xvshuf_b(u_l, u_l, mask);
> +        v   = __lasx_xvshuf_b(v_l, v_l, mask);
> +        __lasx_xvstelm_d(u, (dstU + i), 0, 0);
> +        __lasx_xvstelm_d(u, (dstU + i), 8, 2);
> +        __lasx_xvstelm_d(v, (dstV + i), 0, 0);
> +        __lasx_xvstelm_d(v, (dstV + i), 8, 2);
> +        i += 8;
> +    }
> +    for (; i < width; i++) {
> +        int g = src[0][i];
> +        int b = src[1][i];
> +        int r = src[2][i];
> +
> +        dstU[i] = (tem_ru * r + tem_gu * g + tem_bu * b + set) >> shift;
> +        dstV[i] = (tem_rv * r + tem_gv * g + tem_bv * b + set) >> shift;
> +    }
> +}
> +
> +void planar_rgb_to_y_lasx(uint8_t *_dst, const uint8_t *src[4], int width,
> +                          int32_t *rgb2yuv)
> +{
> +    int i;
> +    int shift        = (RGB2YUV_SHIFT - 6);
> +    int set          = 0x801 << (RGB2YUV_SHIFT - 7);
> +    int len          = width - 15;
> +    uint16_t *dst    = (uint16_t *)_dst;
> +    int32_t tem_ry   = rgb2yuv[RY_IDX], tem_gy = rgb2yuv[GY_IDX];
> +    int32_t tem_by   = rgb2yuv[BY_IDX];
> +    const uint8_t *src0 = src[0], *src1 = src[1], *src2 = src[2];
> +    __m256i mask = {0x0D0C090805040100, 0x1D1C191815141110,
> +                    0x0D0C090805040100, 0x1D1C191815141110};
> +    __m256i temp = __lasx_xvreplgr2vr_w(set);
> +    __m256i sra  = __lasx_xvreplgr2vr_w(shift);
> +    __m256i ry   = __lasx_xvreplgr2vr_w(tem_ry);
> +    __m256i gy   = __lasx_xvreplgr2vr_w(tem_gy);
> +    __m256i by   = __lasx_xvreplgr2vr_w(tem_by);
> +
> +    for (i = 0; i < len; i += 16) {
> +        __m256i _g, _b, _r;
> +        __m256i g_l, g_h, b_l, b_h, r_l, r_h;
> +        __m256i y_l, y_h, y_lh;
> +
> +        _g  = __lasx_xvldx(src0, i);
> +        _b  = __lasx_xvldx(src1, i);
> +        _r  = __lasx_xvldx(src2, i);
> +        g_l = __lasx_vext2xv_wu_bu(_g);
> +        b_l = __lasx_vext2xv_wu_bu(_b);
> +        r_l = __lasx_vext2xv_wu_bu(_r);
> +        _g  = __lasx_xvpermi_d(_g, 0x01);
> +        _b  = __lasx_xvpermi_d(_b, 0x01);
> +        _r  = __lasx_xvpermi_d(_r, 0x01);
> +        g_h = __lasx_vext2xv_wu_bu(_g);
> +        b_h = __lasx_vext2xv_wu_bu(_b);
> +        r_h = __lasx_vext2xv_wu_bu(_r);
> +        y_l  = __lasx_xvmadd_w(temp, ry, r_l);
> +        y_h  = __lasx_xvmadd_w(temp, ry, r_h);
> +        y_l  = __lasx_xvmadd_w(y_l, gy, g_l);
> +        y_l  = __lasx_xvmadd_w(y_l, by, b_l);
> +        y_h  = __lasx_xvmadd_w(y_h, gy, g_h);
> +        y_h  = __lasx_xvmadd_w(y_h, by, b_h);
> +        y_l  = __lasx_xvsra_w(y_l, sra);
> +        y_h  = __lasx_xvsra_w(y_h, sra);
> +        y_lh = __lasx_xvshuf_b(y_h, y_l, mask);
> +        y_lh = __lasx_xvpermi_d(y_lh, 0xD8);
> +        __lasx_xvst(y_lh, (dst + i), 0);
> +    }
> +    if (width - i >= 8) {
> +        __m256i _g, _b, _r;
> +        __m256i g_l, b_l, r_l;
> +        __m256i y_l, y;
> +
> +        _g  = __lasx_xvldrepl_d((src0 + i), 0);
> +        _b  = __lasx_xvldrepl_d((src1 + i), 0);
> +        _r  = __lasx_xvldrepl_d((src2 + i), 0);
> +        g_l = __lasx_vext2xv_wu_bu(_g);
> +        b_l = __lasx_vext2xv_wu_bu(_b);
> +        r_l = __lasx_vext2xv_wu_bu(_r);
> +        y_l = __lasx_xvmadd_w(temp, ry, r_l);
> +        y_l = __lasx_xvmadd_w(y_l, gy, g_l);
> +        y_l = __lasx_xvmadd_w(y_l, by, b_l);
> +        y_l = __lasx_xvsra_w(y_l, sra);
> +        y = __lasx_xvshuf_b(y_l, y_l, mask);
> +        __lasx_xvstelm_d(y, (dst + i), 0, 0);
> +        __lasx_xvstelm_d(y, (dst + i), 8, 2);
> +        i += 8;
> +    }
> +    for (; i < width; i++) {
> +        int g = src[0][i];
> +        int b = src[1][i];
> +        int r = src[2][i];
> +
> +        dst[i] = (tem_ry * r + tem_gy * g + tem_by * b + set) >> shift;
> +    }
> +}
> diff --git a/libswscale/loongarch/swscale_init_loongarch.c b/libswscale/loongarch/swscale_init_loongarch.c
> new file mode 100644
> index 0000000000..197dc6e1e7
> --- /dev/null
> +++ b/libswscale/loongarch/swscale_init_loongarch.c
> @@ -0,0 +1,50 @@
> +/*
> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> + * Contributed by Hao Chen(chenhao@loongson.cn)
> + *
> + * This file is part of FFmpeg.
> + *
> + * FFmpeg 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.
> + *
> + * FFmpeg 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 FFmpeg; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include "swscale_loongarch.h"
> +#include "libswscale/swscale_internal.h"
> +#include "libavutil/loongarch/cpu.h"
> +
> +av_cold void ff_sws_init_swscale_loongarch(SwsContext *c)
> +{
> +    int cpu_flags = av_get_cpu_flags();
> +    if (have_lasx(cpu_flags)) {
> +        if (c->srcBpc == 8) {
> +            if (c->dstBpc <= 14) {
> +                c->hyScale = c->hcScale = ff_hscale_8_to_15_lasx;
> +            } else {
> +                c->hyScale = c->hcScale = ff_hscale_8_to_19_lasx;
> +            }
> +        } else {
> +            c->hyScale = c->hcScale = c->dstBpc > 14 ? ff_hscale_16_to_19_lasx
> +                                                     : ff_hscale_16_to_15_lasx;
> +        }
> +        switch (c->srcFormat) {
> +        case AV_PIX_FMT_GBRAP:
> +        case AV_PIX_FMT_GBRP:
> +            {
> +                c->readChrPlanar = planar_rgb_to_uv_lasx;
> +                c->readLumPlanar = planar_rgb_to_y_lasx;
> +            }
> +            break;
> +        }
> +    }
> +}
> diff --git a/libswscale/loongarch/swscale_lasx.c b/libswscale/loongarch/swscale_lasx.c
> new file mode 100644
> index 0000000000..3e0bae2cc2
> --- /dev/null
> +++ b/libswscale/loongarch/swscale_lasx.c
> @@ -0,0 +1,972 @@
> +/*
> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> + * Contributed by Hao Chen(chenhao@loongson.cn)
> + *
> + * This file is part of FFmpeg.
> + *
> + * FFmpeg 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.
> + *
> + * FFmpeg 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 FFmpeg; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#include "swscale_loongarch.h"
> +#include "libavutil/loongarch/loongson_intrinsics.h"
> +#include "libavutil/intreadwrite.h"
> +
> +#define SCALE_8_16(_sh)                                               \
> +{                                                                     \
> +    src0    = __lasx_xvldrepl_d(src + filterPos[0], 0);               \
> +    src1    = __lasx_xvldrepl_d(src + filterPos[1], 0);               \
> +    src2    = __lasx_xvldrepl_d(src + filterPos[2], 0);               \
> +    src3    = __lasx_xvldrepl_d(src + filterPos[3], 0);               \
> +    src4    = __lasx_xvldrepl_d(src + filterPos[4], 0);               \
> +    src5    = __lasx_xvldrepl_d(src + filterPos[5], 0);               \
> +    src6    = __lasx_xvldrepl_d(src + filterPos[6], 0);               \
> +    src7    = __lasx_xvldrepl_d(src + filterPos[7], 0);               \
> +    src8    = __lasx_xvldrepl_d(src + filterPos[8], 0);               \
> +    src9    = __lasx_xvldrepl_d(src + filterPos[9], 0);               \
> +    src10   = __lasx_xvldrepl_d(src + filterPos[10], 0);              \
> +    src11   = __lasx_xvldrepl_d(src + filterPos[11], 0);              \
> +    src12   = __lasx_xvldrepl_d(src + filterPos[12], 0);              \
> +    src13   = __lasx_xvldrepl_d(src + filterPos[13], 0);              \
> +    src14   = __lasx_xvldrepl_d(src + filterPos[14], 0);              \
> +    src15   = __lasx_xvldrepl_d(src + filterPos[15], 0);              \
> +    DUP4_ARG2(__lasx_xvld, filter, 0, filter, 32, filter, 64,         \
> +              filter, 96, filter0, filter1, filter2, filter3);        \
> +    DUP4_ARG2(__lasx_xvld, filter, 128, filter, 160,                  \
> +              filter, 192, filter, 224, filter4,                      \
> +              filter5, filter6, filter7);                             \
> +    DUP4_ARG2(__lasx_xvilvl_d, src1, src0, src3, src2,                \
> +              src5, src4, src7, src6, src0, src2, src4, src6);        \
> +    DUP4_ARG2(__lasx_xvilvl_d, src9, src8, src11, src10,              \
> +              src13, src12, src15, src14, src8, src10, src12, src14); \
> +    DUP4_ARG1(__lasx_vext2xv_hu_bu, src0, src2, src4, src6,           \
> +              src0, src2, src4, src6);                                \
> +    DUP4_ARG1(__lasx_vext2xv_hu_bu, src8, src10, src12,               \
> +              src14, src8, src10, src12, src14);                      \
> +    DUP4_ARG2(__lasx_xvdp2_w_h, filter0, src0, filter1, src2,         \
> +              filter2, src4, filter3, src6, src0, src1, src2, src3);  \
> +    DUP4_ARG2(__lasx_xvdp2_w_h, filter4, src8, filter5, src10,        \
> +              filter6, src12, filter7, src14, src4, src5, src6, src7);\
> +    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
> +    src1 = __lasx_xvhaddw_d_w(src1, src1);                            \
> +    src2 = __lasx_xvhaddw_d_w(src2, src2);                            \
> +    src3 = __lasx_xvhaddw_d_w(src3, src3);                            \
> +    src4 = __lasx_xvhaddw_d_w(src4, src4);                            \
> +    src5 = __lasx_xvhaddw_d_w(src5, src5);                            \
> +    src6 = __lasx_xvhaddw_d_w(src6, src6);                            \
> +    src7 = __lasx_xvhaddw_d_w(src7, src7);                            \
> +    DUP4_ARG2(__lasx_xvpickev_w, src1, src0, src3, src2,              \
> +              src5, src4, src7, src6, src0, src1, src2, src3);        \
> +    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
> +    src1 = __lasx_xvhaddw_d_w(src1, src1);                            \
> +    src2 = __lasx_xvhaddw_d_w(src2, src2);                            \
> +    src3 = __lasx_xvhaddw_d_w(src3, src3);                            \
> +    src0 = __lasx_xvpickev_w(src1, src0);                             \
> +    src1 = __lasx_xvpickev_w(src3, src2);                             \
> +    src0 = __lasx_xvsrai_w(src0, _sh);                                \
> +    src1 = __lasx_xvsrai_w(src1, _sh);                                \
> +    src0 = __lasx_xvmin_w(src0, vmax);                                \
> +    src1 = __lasx_xvmin_w(src1, vmax);                                \
> +    src0 = __lasx_xvperm_w(src0, shuf);                               \
> +    src1 = __lasx_xvperm_w(src1, shuf);                               \
> +    src0 = __lasx_xvpickev_h(src1, src0);                             \
> +    src0 = __lasx_xvpermi_d(src0, 0xd8);                              \
> +    __lasx_xvst(src0, dst, 0);                                        \
> +    filterPos += 16;                                                  \
> +    filter    += 128;                                                 \
> +    dst       += 16;                                                  \
> +}
> +
> +#define SCALE_8_8(_sh)                                                \
> +{                                                                     \
> +    src0    = __lasx_xvldrepl_d(src + filterPos[0], 0);               \
> +    src1    = __lasx_xvldrepl_d(src + filterPos[1], 0);               \
> +    src2    = __lasx_xvldrepl_d(src + filterPos[2], 0);               \
> +    src3    = __lasx_xvldrepl_d(src + filterPos[3], 0);               \
> +    src4    = __lasx_xvldrepl_d(src + filterPos[4], 0);               \
> +    src5    = __lasx_xvldrepl_d(src + filterPos[5], 0);               \
> +    src6    = __lasx_xvldrepl_d(src + filterPos[6], 0);               \
> +    src7    = __lasx_xvldrepl_d(src + filterPos[7], 0);               \
> +    DUP4_ARG2(__lasx_xvld, filter, 0, filter, 32, filter, 64,         \
> +              filter, 96, filter0, filter1, filter2, filter3);        \
> +    filterPos += 8;                                                   \
> +    filter    += 64;                                                  \
> +    DUP4_ARG2(__lasx_xvilvl_d, src1, src0, src3, src2,                \
> +              src5, src4, src7, src6, src0, src2, src4, src6);        \
> +    DUP4_ARG1(__lasx_vext2xv_hu_bu, src0, src2, src4, src6,           \
> +              src0, src2, src4, src6);                                \
> +    DUP4_ARG2(__lasx_xvdp2_w_h, filter0, src0, filter1, src2,         \
> +              filter2, src4, filter3, src6, src0, src1, src2,src3);   \
> +    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
> +    src1 = __lasx_xvhaddw_d_w(src1, src1);                            \
> +    src2 = __lasx_xvhaddw_d_w(src2, src2);                            \
> +    src3 = __lasx_xvhaddw_d_w(src3, src3);                            \
> +    src0 = __lasx_xvpickev_w(src1, src0);                             \
> +    src1 = __lasx_xvpickev_w(src3, src2);                             \
> +    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
> +    src1 = __lasx_xvhaddw_d_w(src1, src1);                            \
> +    src0 = __lasx_xvpickev_w(src1, src0);                             \
> +    src0 = __lasx_xvsrai_w(src0, _sh);                                \
> +    src0 = __lasx_xvmin_w(src0, vmax);                                \
> +    src0 = __lasx_xvperm_w(src0, shuf);                               \
> +}
> +
> +#define SCALE_8_4(_sh)                                                    \
> +{                                                                         \
> +    src0    = __lasx_xvldrepl_d(src + filterPos[0], 0);                   \
> +    src1    = __lasx_xvldrepl_d(src + filterPos[1], 0);                   \
> +    src2    = __lasx_xvldrepl_d(src + filterPos[2], 0);                   \
> +    src3    = __lasx_xvldrepl_d(src + filterPos[3], 0);                   \
> +    filter0 = __lasx_xvld(filter, 0);                                     \
> +    filter1 = __lasx_xvld(filter, 32);                                    \
> +    filterPos += 4;                                                       \
> +    filter    += 32;                                                      \
> +    src0    = __lasx_xvilvl_d(src1, src0);                                \
> +    src2    = __lasx_xvilvl_d(src3, src2);                                \
> +    src0    = __lasx_vext2xv_hu_bu(src0);                                 \
> +    src2    = __lasx_vext2xv_hu_bu(src2);                                 \
> +    src0    = __lasx_xvdp2_w_h(src0, filter0);                            \
> +    src1    = __lasx_xvdp2_w_h(src2, filter1);                            \
> +    src0 = __lasx_xvhaddw_d_w(src0, src0);                                \
> +    src1 = __lasx_xvhaddw_d_w(src1, src1);                                \
> +    src0 = __lasx_xvpickev_w(src1, src0);                                 \
> +    src0 = __lasx_xvhaddw_d_w(src0, src0);                                \
> +    src0 = __lasx_xvpickev_w(src0, src0);                                 \
> +    src0 = __lasx_xvsrai_w(src0, _sh);                                    \
> +    src0 = __lasx_xvmin_w(src0, vmax);                                    \
> +    src0 = __lasx_xvperm_w(src0, shuf);                                   \
> +}
> +
> +#define SCALE_8_2(_sh)                                                \
> +{                                                                     \
> +    src0    = __lasx_xvldrepl_d(src + filterPos[0], 0);               \
> +    src1    = __lasx_xvldrepl_d(src + filterPos[1], 0);               \
> +    filter0 = __lasx_xvld(filter, 0);                                 \
> +    src0 = __lasx_xvilvl_d(src1, src0);                               \
> +    src0 = __lasx_vext2xv_hu_bu(src0);                                \
> +    src0 = __lasx_xvdp2_w_h(filter0, src0);                           \
> +    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
> +    src0 = __lasx_xvhaddw_q_d(src0, src0);                            \
> +    src0 = __lasx_xvsrai_w(src0, _sh);                                \
> +    src0 = __lasx_xvmin_w(src0, vmax);                                \
> +    dst[0] = __lasx_xvpickve2gr_w(src0, 0);                           \
> +    dst[1] = __lasx_xvpickve2gr_w(src0, 4);                           \
> +    filterPos += 2;                                                   \
> +    filter    += 16;                                                  \
> +    dst       += 2;                                                   \
> +}
> +
> +#define SCALE_4_16(_sh)                                               \
> +{                                                                     \
> +    src0    = __lasx_xvldrepl_w(src + filterPos[0], 0);               \
> +    src1    = __lasx_xvldrepl_w(src + filterPos[1], 0);               \
> +    src2    = __lasx_xvldrepl_w(src + filterPos[2], 0);               \
> +    src3    = __lasx_xvldrepl_w(src + filterPos[3], 0);               \
> +    src4    = __lasx_xvldrepl_w(src + filterPos[4], 0);               \
> +    src5    = __lasx_xvldrepl_w(src + filterPos[5], 0);               \
> +    src6    = __lasx_xvldrepl_w(src + filterPos[6], 0);               \
> +    src7    = __lasx_xvldrepl_w(src + filterPos[7], 0);               \
> +    src8    = __lasx_xvldrepl_w(src + filterPos[8], 0);               \
> +    src9    = __lasx_xvldrepl_w(src + filterPos[9], 0);               \
> +    src10   = __lasx_xvldrepl_w(src + filterPos[10], 0);              \
> +    src11   = __lasx_xvldrepl_w(src + filterPos[11], 0);              \
> +    src12   = __lasx_xvldrepl_w(src + filterPos[12], 0);              \
> +    src13   = __lasx_xvldrepl_w(src + filterPos[13], 0);              \
> +    src14   = __lasx_xvldrepl_w(src + filterPos[14], 0);              \
> +    src15   = __lasx_xvldrepl_w(src + filterPos[15], 0);              \
> +    DUP4_ARG2(__lasx_xvld, filter, 0, filter, 32, filter, 64,         \
> +              filter, 96, filter0, filter1, filter2, filter3);        \
> +    DUP4_ARG2(__lasx_xvilvl_w, src1, src0, src3, src2, src5,          \
> +              src4, src7, src6, src0, src2, src4, src6);              \
> +    DUP4_ARG2(__lasx_xvilvl_w, src9, src8, src11, src10, src13,       \
> +              src12, src15, src14, src8, src10, src12, src14);        \
> +    DUP4_ARG2(__lasx_xvilvl_d, src2, src0, src6, src4, src10,         \
> +                   src8, src14, src12, src0, src1, src2, src3);       \
> +    DUP4_ARG1(__lasx_vext2xv_hu_bu, src0, src1, src2, src3,           \
> +              src0, src1, src2, src3);                                \
> +    DUP4_ARG2(__lasx_xvdp2_w_h, filter0, src0, filter1, src1,         \
> +              filter2, src2, filter3, src3, src0, src1, src2, src3);  \
> +    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
> +    src1 = __lasx_xvhaddw_d_w(src1, src1);                            \
> +    src2 = __lasx_xvhaddw_d_w(src2, src2);                            \
> +    src3 = __lasx_xvhaddw_d_w(src3, src3);                            \
> +    src0 = __lasx_xvpickev_w(src1, src0);                             \
> +    src1 = __lasx_xvpickev_w(src3, src2);                             \
> +    src0 = __lasx_xvsrai_w(src0, _sh);                                \
> +    src1 = __lasx_xvsrai_w(src1, _sh);                                \
> +    src0 = __lasx_xvmin_w(src0, vmax);                                \
> +    src1 = __lasx_xvmin_w(src1, vmax);                                \
> +    src0 = __lasx_xvpickev_h(src1, src0);                             \
> +    src0 = __lasx_xvperm_w(src0, shuf);                               \
> +    __lasx_xvst(src0, dst, 0);                                        \
> +    filterPos += 16;                                                  \
> +    filter    += 64;                                                  \
> +    dst       += 16;                                                  \
> +}
> +
> +#define SCALE_4_8(_sh)                                                    \
> +{                                                                         \
> +    src0    = __lasx_xvldrepl_w(src + filterPos[0], 0);                   \
> +    src1    = __lasx_xvldrepl_w(src + filterPos[1], 0);                   \
> +    src2    = __lasx_xvldrepl_w(src + filterPos[2], 0);                   \
> +    src3    = __lasx_xvldrepl_w(src + filterPos[3], 0);                   \
> +    src4    = __lasx_xvldrepl_w(src + filterPos[4], 0);                   \
> +    src5    = __lasx_xvldrepl_w(src + filterPos[5], 0);                   \
> +    src6    = __lasx_xvldrepl_w(src + filterPos[6], 0);                   \
> +    src7    = __lasx_xvldrepl_w(src + filterPos[7], 0);                   \
> +    filter0 = __lasx_xvld(filter, 0);                                     \
> +    filter1 = __lasx_xvld(filter, 32);                                    \
> +    filterPos += 8;                                                       \
> +    filter    += 32;                                                      \
> +    DUP4_ARG2(__lasx_xvilvl_w, src1, src0, src3, src2, src5,              \
> +              src4, src7, src6, src0, src2, src4, src6);                  \
> +    src0 = __lasx_xvilvl_d(src2, src0);                                   \
> +    src1 = __lasx_xvilvl_d(src6, src4);                                   \
> +                                                                          \
> +    src0 = __lasx_vext2xv_hu_bu(src0);                                    \
> +    src1 = __lasx_vext2xv_hu_bu(src1);                                    \
> +    src0 = __lasx_xvdp2_w_h(filter0, src0);                               \
> +    src1 = __lasx_xvdp2_w_h(filter1, src1);                               \
> +    src0 = __lasx_xvhaddw_d_w(src0, src0);                                \
> +    src1 = __lasx_xvhaddw_d_w(src1, src1);                                \
> +    src0 = __lasx_xvpickev_w(src1, src0);                                 \
> +    src0 = __lasx_xvsrai_w(src0, _sh);                                    \
> +    src0 = __lasx_xvmin_w(src0, vmax);                                    \
> +}
> +
> +#define SCALE_4_4(_sh)                                                \
> +{                                                                     \
> +    src0    = __lasx_xvldrepl_w(src + filterPos[0], 0);               \
> +    src1    = __lasx_xvldrepl_w(src + filterPos[1], 0);               \
> +    src2    = __lasx_xvldrepl_w(src + filterPos[2], 0);               \
> +    src3    = __lasx_xvldrepl_w(src + filterPos[3], 0);               \
> +    filter0 = __lasx_xvld(filter, 0);                                 \
> +    filterPos += 4;                                                   \
> +    filter    += 16;                                                  \
> +    src0    = __lasx_xvilvl_w(src1, src0);                            \
> +    src1    = __lasx_xvilvl_w(src3, src2);                            \
> +                                                                      \
> +    src0 = __lasx_xvilvl_d(src1, src0);                               \
> +    src0 = __lasx_vext2xv_hu_bu(src0);                                \
> +    src0 = __lasx_xvdp2_w_h(filter0, src0);                           \
> +    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
> +    src0 = __lasx_xvsrai_w(src0, _sh);                                \
> +    src0 = __lasx_xvmin_w(src0, vmax);                                \
> +    src0 = __lasx_xvpickev_w(src0, src0);                             \
> +    src0 = __lasx_xvpermi_d(src0, 0xd8);                              \
> +}
> +
> +#define SCALE_4_2(_sh)                                                \
> +{                                                                     \
> +    src0    = __lasx_xvldrepl_w(src + filterPos[0], 0);               \
> +    src1    = __lasx_xvldrepl_w(src + filterPos[1], 0);               \
> +    filter0 = __lasx_xvld(filter, 0);                                 \
> +    src0 = __lasx_xvilvl_w(src1, src0);                               \
> +    src0 = __lasx_vext2xv_hu_bu(src0);                                \
> +    src0 = __lasx_xvdp2_w_h(filter0, src0);                           \
> +    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
> +    src0 = __lasx_xvsrai_w(src0, _sh);                                \
> +    src0 = __lasx_xvmin_w(src0, vmax);                                \
> +    dst[0] = __lasx_xvpickve2gr_w(src0, 0);                           \
> +    dst[1] = __lasx_xvpickve2gr_w(src0, 2);                           \
> +    filterPos += 2;                                                   \
> +    filter    += 8;                                                   \
> +    dst       += 2;                                                   \
> +}
> +
> +#define SCALE_16                                                      \
> +{                                                                     \
> +    int dex  = j << 1;                                                \
> +    src0     = __lasx_xvldrepl_d((srcPos1 + j), 0);                   \
> +    src1     = __lasx_xvldrepl_d((srcPos2 + j), 0);                   \
> +    src2     = __lasx_xvldrepl_d((srcPos3 + j), 0);                   \
> +    src3     = __lasx_xvldrepl_d((srcPos4 + j), 0);                   \
> +    DUP4_ARG2(__lasx_xvldx, filterStart1, dex, filterStart2, dex,     \
> +              filterStart3, dex, filterStart4, dex, filter0,          \
> +              filter1, filter2, filter3);                             \
> +    src0     = __lasx_xvpermi_q(src0, src1, 0x02);                    \
> +    src1     = __lasx_xvpermi_q(src2, src3, 0x02);                    \
> +    filter0  = __lasx_xvpermi_q(filter0, filter1, 0x02);              \
> +    filter1  = __lasx_xvpermi_q(filter2, filter3, 0x02);              \
> +    src0     = __lasx_xvilvl_b(zero, src0);                           \
> +    src1     = __lasx_xvilvl_b(zero, src1);                           \
> +    out0     = __lasx_xvdp2_w_h(filter0, src0);                       \
> +    out1     = __lasx_xvdp2_w_h(filter1, src1);                       \
> +    src0     = __lasx_xvhaddw_d_w(out0, out0);                        \
> +    src1     = __lasx_xvhaddw_d_w(out1, out1);                        \
> +    out0     = __lasx_xvpackev_d(src1, src0);                         \
> +    out1     = __lasx_xvpackod_d(src1, src0);                         \
> +    out0     = __lasx_xvadd_w(out0, out1);                            \
> +    out      = __lasx_xvadd_w(out, out0);                             \
> +}
> +
> +void ff_hscale_8_to_15_lasx(SwsContext *c, int16_t *dst, int dstW,
> +                            const uint8_t *src, const int16_t *filter,
> +                            const int32_t *filterPos, int filterSize)
> +{
> +    int i;
> +    int max = (1 << 15) - 1;
> +
> +    if (filterSize == 8) {
> +        __m256i src0, src1, src2, src3, src4, src5, src6, src7;
> +        __m256i src8, src9, src10, src11, src12, src13, src14, src15;
> +        __m256i filter0, filter1, filter2, filter3;
> +        __m256i filter4, filter5, filter6, filter7;
> +        __m256i vmax = __lasx_xvreplgr2vr_w(max);
> +        __m256i shuf = {0x0000000400000000, 0x0000000500000001,
> +                        0x0000000600000002, 0x0000000700000003};
> +        int len = dstW >> 4;
> +        int res = dstW & 15;
> +        while (len--) {
> +            SCALE_8_16(7);
> +        }
> +        if (res & 8) {
> +            SCALE_8_8(7);
> +            src0 = __lasx_xvpickev_h(src0, src0);
> +            __lasx_xvstelm_d(src0, dst, 0, 0);
> +            __lasx_xvstelm_d(src0, dst, 8, 2);
> +            dst       += 8;
> +        }
> +        if (res & 4) {
> +            SCALE_8_4(7);
> +            src0 = __lasx_xvpickev_h(src0, src0);
> +            __lasx_xvstelm_d(src0, dst, 0, 0);
> +            dst       += 4;
> +        }
> +        if (res & 2) {
> +            SCALE_8_2(7);
> +        }
> +        if (res & 1) {
> +            int val = 0;
> +            src0    = __lasx_xvldrepl_d(src + filterPos[0], 0);
> +            filter0 = __lasx_xvld(filter, 0);
> +            src0 = __lasx_vext2xv_hu_bu(src0);
> +            src0 = __lasx_xvdp2_w_h(filter0, src0);
> +            src0    = __lasx_xvhaddw_d_w(src0, src0);
> +            src0    = __lasx_xvhaddw_q_d(src0, src0);
> +            val     = __lasx_xvpickve2gr_w(src0, 0);
> +            dst[0]  = FFMIN(val >> 7, max);
> +        }
> +    } else if (filterSize == 4) {
> +        __m256i src0, src1, src2, src3, src4, src5, src6, src7;
> +        __m256i src8, src9, src10, src11, src12, src13, src14, src15;
> +        __m256i filter0, filter1, filter2, filter3;
> +        __m256i vmax = __lasx_xvreplgr2vr_w(max);
> +        __m256i shuf = {0x0000000400000000, 0x0000000500000001,
> +                        0x0000000600000002, 0x0000000700000003};
> +        int len = dstW >> 4;
> +        int res = dstW & 15;
> +        while (len--) {
> +            SCALE_4_16(7);
> +        }
> +        if (res & 8) {
> +            SCALE_4_8(7);
> +            src0 = __lasx_xvpickev_h(src1, src0);
> +            src0 = __lasx_xvperm_w(src0, shuf);
> +            __lasx_xvstelm_d(src0, dst, 0, 0);
> +            __lasx_xvstelm_d(src0, dst, 8, 1);
> +            dst       += 8;
> +        }
> +        if (res & 4) {
> +            SCALE_4_4(7);
> +            src0 = __lasx_xvpickev_h(src0, src0);
> +            __lasx_xvstelm_d(src0, dst, 0, 0);
> +            dst       += 4;
> +        }
> +        if (res & 2) {
> +            SCALE_4_2(7);
> +        }
> +        if (res & 1) {
> +            int val = 0;
> +            const uint8_t *srcPos = src + filterPos[0];
> +
> +            for (int j = 0; j < filterSize; j++) {
> +                val += ((int)srcPos[j]) * filter[j];
> +            }
> +            dst[0] = FFMIN(val >> 7, max);
> +        }
> +    } else if (filterSize > 8) {
> +        int filterlen = filterSize - 7;
> +        int len = dstW >> 2;
> +        int res = dstW & 3;
> +        __m256i zero = __lasx_xvldi(0);
> +
> +        while (len--) {
> +            __m256i src0, src1, src2, src3;
> +            __m256i filter0, filter1, filter2, filter3, out0, out1;
> +            __m256i out = zero;
> +            const uint8_t *srcPos1 = src + filterPos[0];
> +            const uint8_t *srcPos2 = src + filterPos[1];
> +            const uint8_t *srcPos3 = src + filterPos[2];
> +            const uint8_t *srcPos4 = src + filterPos[3];
> +            const int16_t *filterStart1 = filter;
> +            const int16_t *filterStart2 = filterStart1 + filterSize;
> +            const int16_t *filterStart3 = filterStart2 + filterSize;
> +            const int16_t *filterStart4 = filterStart3 + filterSize;
> +            int j, val1 = 0, val2 = 0, val3 = 0, val4 = 0;
> +
> +            for (j = 0; j < filterlen; j += 8) {
> +                SCALE_16
> +            }
> +            val1 = __lasx_xvpickve2gr_w(out, 0);
> +            val2 = __lasx_xvpickve2gr_w(out, 4);
> +            val3 = __lasx_xvpickve2gr_w(out, 2);
> +            val4 = __lasx_xvpickve2gr_w(out, 6);
> +            for (; j < filterSize; j++) {
> +                val1 += ((int)srcPos1[j]) * filterStart1[j];
> +                val2 += ((int)srcPos2[j]) * filterStart2[j];
> +                val3 += ((int)srcPos3[j]) * filterStart3[j];
> +                val4 += ((int)srcPos4[j]) * filterStart4[j];
> +            }
> +            dst[0] = FFMIN(val1 >> 7, max);
> +            dst[1] = FFMIN(val2 >> 7, max);
> +            dst[2] = FFMIN(val3 >> 7, max);
> +            dst[3] = FFMIN(val4 >> 7, max);
> +            dst       += 4;
> +            filterPos += 4;
> +            filter     = filterStart4 + filterSize;
> +        }
> +        for(i = 0; i < res; i++) {
> +            int j, val = 0;
> +            const uint8_t *srcPos = src + filterPos[i];
> +            __m256i src1, filter0, out0;
> +
> +            for (j = 0; j < filterlen; j += 8) {
> +                src1   = __lasx_xvldrepl_d((srcPos + j), 0);
> +                filter0 = __lasx_xvld(filter + j, 0);
> +                src1 = __lasx_xvilvl_b(zero, src1);
> +                out0 = __lasx_xvdp2_w_h(filter0, src1);
> +                out0 = __lasx_xvhaddw_d_w(out0, out0);
> +                out0 = __lasx_xvhaddw_q_d(out0, out0);
> +                val += __lasx_xvpickve2gr_w(out0, 0);
> +            }
> +            for (; j < filterSize; j++) {
> +                val += ((int)srcPos[j]) * filter[j];
> +            }
> +            dst[i]  = FFMIN(val >> 7, max);
> +            filter += filterSize;
> +        }
> +    } else {
> +        for (i = 0; i < dstW; i++) {
> +            int val = 0;
> +            const uint8_t *srcPos = src + filterPos[i];
> +
> +            for (int j = 0; j < filterSize; j++) {
> +                val += ((int)srcPos[j]) * filter[j];
> +            }
> +            dst[i]  = FFMIN(val >> 7, max);
> +            filter += filterSize;
> +        }
> +    }
> +}
> +
> +void ff_hscale_8_to_19_lasx(SwsContext *c, int16_t *_dst, int dstW,
> +                            const uint8_t *src, const int16_t *filter,
> +                            const int32_t *filterPos, int filterSize)
> +{
> +    int i;
> +    int max = (1 << 19) - 1;
> +    int32_t *dst = (int32_t *) _dst;
> +
> +    if (filterSize == 8) {
> +        __m256i src0, src1, src2, src3, src4, src5, src6, src7;
> +        __m256i filter0, filter1, filter2, filter3;
> +        __m256i vmax = __lasx_xvreplgr2vr_w(max);
> +        __m256i shuf = {0x0000000400000000, 0x0000000500000001,
> +                        0x0000000600000002, 0x0000000700000003};
> +        int len = dstW >> 3;
> +        int res = dstW & 7;
> +        while (len--) {
> +            SCALE_8_8(3);
> +            __lasx_xvst(src0, dst, 0);
> +            dst       += 8;
> +        }
> +        if (res & 4) {
> +            SCALE_8_4(3);
> +            __lasx_xvstelm_d(src0, dst, 0, 0);
> +            __lasx_xvstelm_d(src0, dst, 8, 1);
> +            dst       += 4;
> +        }
> +        if (res & 2) {
> +            SCALE_8_2(3);
> +        }
> +        if (res & 1) {
> +            int val = 0;
> +            __m256i src0, filter0, out0;
> +
> +            src0    = __lasx_xvldrepl_d(src + filterPos[0], 0);
> +            filter0 = __lasx_xvld(filter, 0);
> +            src0 = __lasx_vext2xv_hu_bu(src0);
> +            out0 = __lasx_xvdp2_w_h(filter0, src0);
> +            out0    = __lasx_xvhaddw_d_w(out0, out0);
> +            out0    = __lasx_xvhaddw_q_d(out0, out0);
> +            val     = __lasx_xvpickve2gr_w(out0, 0);
> +            dst[0]  = FFMIN(val >> 3, max);
> +        }
> +    } else if (filterSize == 4) {
> +        __m256i src0, src1, src2, src3, src4, src5, src6, src7;
> +        __m256i filter0, filter1;
> +        __m256i vmax = __lasx_xvreplgr2vr_w(max);
> +        __m256i shuf = {0x0000000100000000, 0x0000000500000004,
> +                        0x0000000300000002, 0x0000000700000006};
> +        int len = dstW >> 3;
> +        int res = dstW & 7;
> +        while (len--) {
> +            SCALE_4_8(3);
> +            src0 = __lasx_xvperm_w(src0, shuf);
> +            __lasx_xvst(src0, dst, 0);
> +            dst       += 8;
> +        }
> +        if (res & 4) {
> +            SCALE_4_4(3);
> +            __lasx_xvstelm_d(src0, dst, 0, 0);
> +            __lasx_xvstelm_d(src0, dst, 8, 1);
> +            dst       += 4;
> +        }
> +        if (res & 2) {
> +            SCALE_4_2(3);
> +        }
> +        if (res & 1) {
> +            int val = 0;
> +            const uint8_t *srcPos = src + filterPos[0];
> +
> +            for (int j = 0; j < filterSize; j++) {
> +                val += ((int)srcPos[j]) * filter[j];
> +            }
> +            dst[0] = FFMIN(val >> 3, max);
> +        }
> +    } else if (filterSize > 8) {
> +        int len = dstW >> 2;
> +        int res = dstW & 3;
> +        int filterlen = filterSize - 7;
> +        __m256i zero = __lasx_xvldi(0);
> +
> +        while (len--) {
> +            __m256i src0, src1, src2, src3;
> +            __m256i filter0, filter1, filter2, filter3, out0, out1;
> +            __m256i out = zero;
> +            const uint8_t *srcPos1 = src + filterPos[0];
> +            const uint8_t *srcPos2 = src + filterPos[1];
> +            const uint8_t *srcPos3 = src + filterPos[2];
> +            const uint8_t *srcPos4 = src + filterPos[3];
> +            const int16_t *filterStart1 = filter;
> +            const int16_t *filterStart2 = filterStart1 + filterSize;
> +            const int16_t *filterStart3 = filterStart2 + filterSize;
> +            const int16_t *filterStart4 = filterStart3 + filterSize;
> +            int j, val1 = 0, val2 = 0, val3 = 0, val4 = 0;
> +
> +            for (j = 0; j < filterlen; j += 8) {
> +                SCALE_16
> +            }
> +            val1 = __lasx_xvpickve2gr_w(out, 0);
> +            val2 = __lasx_xvpickve2gr_w(out, 4);
> +            val3 = __lasx_xvpickve2gr_w(out, 2);
> +            val4 = __lasx_xvpickve2gr_w(out, 6);
> +            for (; j < filterSize; j++) {
> +                val1 += ((int)srcPos1[j]) * filterStart1[j];
> +                val2 += ((int)srcPos2[j]) * filterStart2[j];
> +                val3 += ((int)srcPos3[j]) * filterStart3[j];
> +                val4 += ((int)srcPos4[j]) * filterStart4[j];
> +            }
> +            dst[0] = FFMIN(val1 >> 3, max);
> +            dst[1] = FFMIN(val2 >> 3, max);
> +            dst[2] = FFMIN(val3 >> 3, max);
> +            dst[3] = FFMIN(val4 >> 3, max);
> +            dst       += 4;
> +            filterPos += 4;
> +            filter     = filterStart4 + filterSize;
> +        }
> +        for (i = 0; i < res; i++) {
> +            int j, val = 0;
> +            const uint8_t *srcPos = src + filterPos[i];
> +            __m256i src1, filter0, out0;
> +
> +            for (j = 0; j < filterlen; j += 8) {
> +                src1   = __lasx_xvldrepl_d((srcPos + j), 0);
> +                filter0 = __lasx_xvld(filter + j, 0);
> +                src1 = __lasx_xvilvl_b(zero, src1);
> +                out0 = __lasx_xvdp2_w_h(filter0, src1);
> +                out0 = __lasx_xvhaddw_d_w(out0, out0);
> +                out0 = __lasx_xvhaddw_q_d(out0, out0);
> +                val += __lasx_xvpickve2gr_w(out0, 0);
> +            }
> +            for (; j < filterSize; j++) {
> +                val += ((int)srcPos[j]) * filter[j];
> +            }
> +            dst[i] = FFMIN(val >> 3, max);
> +            filter += filterSize;
> +        }
> +    } else {
> +        for (i = 0; i < dstW; i++) {
> +            int val = 0;
> +            const uint8_t *srcPos = src + filterPos[i];
> +
> +            for (int j = 0; j < filterSize; j++) {
> +                val += ((int)srcPos[j]) * filter[j];
> +            }
> +            dst[i]  = FFMIN(val >> 3, max);
> +            filter += filterSize;
> +        }
> +    }
> +}
> +
> +#undef SCALE_16
> +
> +#define SCALE_8                                                              \
> +{                                                                            \
> +    __m256i src0, src1, src2, src3, filter0, filter1, out0, out1;            \
> +    DUP4_ARG2(__lasx_xvld, src + filterPos[0], 0, src + filterPos[1], 0,     \
> +              src + filterPos[2], 0, src + filterPos[3], 0, src0, src1, src2,\
> +              src3);                                                         \
> +    filter0 = __lasx_xvld(filter, 0);                                        \
> +    filter1 = __lasx_xvld(filter, 32);                                       \
> +    src0    = __lasx_xvpermi_q(src0, src1, 0x02);                            \
> +    src2    = __lasx_xvpermi_q(src2, src3, 0x02);                            \
> +    out0    = __lasx_xvdp2_w_hu_h(src0, filter0);                            \
> +    out1    = __lasx_xvdp2_w_hu_h(src2, filter1);                            \
> +    src0    = __lasx_xvhaddw_d_w(out0, out0);                                \
> +    src1    = __lasx_xvhaddw_d_w(out1, out1);                                \
> +    out0    = __lasx_xvpackev_d(src1, src0);                                 \
> +    out1    = __lasx_xvpackod_d(src1, src0);                                 \
> +    out0    = __lasx_xvadd_w(out0, out1);                                    \
> +    out0    = __lasx_xvsra_w(out0, shift);                                   \
> +    out0    = __lasx_xvmin_w(out0, v_max);                                   \
> +    dst[0]  = __lasx_xvpickve2gr_w(out0, 0);                                 \
> +    dst[1]  = __lasx_xvpickve2gr_w(out0, 4);                                 \
> +    dst[2]  = __lasx_xvpickve2gr_w(out0, 2);                                 \
> +    dst[3]  = __lasx_xvpickve2gr_w(out0, 6);                                 \
> +    filterPos += 4;                                                          \
> +    filter += 32;                                                            \
> +    dst += 4;                                                                \
> +}
> +
> +#define SCALE_16                                                             \
> +{                                                                            \
> +    int dex = j << 1;                                                        \
> +    DUP4_ARG2(__lasx_xvldx, srcPos1, dex, srcPos2, dex, srcPos3, dex,        \
> +              srcPos4, dex, src0, src1, src2, src3);                         \
> +    DUP4_ARG2(__lasx_xvldx, filterStart1, dex, filterStart2, dex,            \
> +              filterStart3, dex, filterStart4, dex, filter0,                 \
> +              filter1, filter2, filter3);                                    \
> +    src0     = __lasx_xvpermi_q(src0, src1, 0x02);                           \
> +    src1     = __lasx_xvpermi_q(src2, src3, 0x02);                           \
> +    filter0  = __lasx_xvpermi_q(filter0, filter1, 0x02);                     \
> +    filter1  = __lasx_xvpermi_q(filter2, filter3, 0x02);                     \
> +    out0     = __lasx_xvdp2_w_hu_h(src0, filter0);                           \
> +    out1     = __lasx_xvdp2_w_hu_h(src1, filter1);                           \
> +    src0     = __lasx_xvhaddw_d_w(out0, out0);                               \
> +    src1     = __lasx_xvhaddw_d_w(out1, out1);                               \
> +    out0     = __lasx_xvpackev_d(src1, src0);                                \
> +    out1     = __lasx_xvpackod_d(src1, src0);                                \
> +    out0     = __lasx_xvadd_w(out0, out1);                                   \
> +    out      = __lasx_xvadd_w(out, out0);                                    \
> +}
> +
> +void ff_hscale_16_to_15_lasx(SwsContext *c, int16_t *dst, int dstW,
> +                             const uint8_t *_src, const int16_t *filter,
> +                             const int32_t *filterPos, int filterSize)
> +{
> +    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
> +    int i;
> +    const uint16_t *src = (const uint16_t *) _src;
> +    int sh              = desc->comp[0].depth - 1;
> +    int max = (1 << 15) - 1;
> +    int len = dstW >> 2;
> +    int res = dstW & 3;
> +    __m256i shift;
> +    __m256i zero = __lasx_xvldi(0);
> +
> +    if (sh < 15) {
> +        sh = isAnyRGB(c->srcFormat) || c->srcFormat==AV_PIX_FMT_PAL8 ? 13 :
> +                      (desc->comp[0].depth - 1);
> +    } else if (desc->flags && AV_PIX_FMT_FLAG_FLOAT) {
> +        sh = 15;
> +    }
> +    shift = __lasx_xvreplgr2vr_w(sh);
> +
> +    if (filterSize == 8) {
> +        __m256i v_max = __lasx_xvreplgr2vr_w(max);
> +        for (i = 0; i < len; i++) {
> +            SCALE_8
> +        }
> +        for (i = 0; i < res; i++) {
> +            int val = 0;
> +            __m256i src0, filter0, out0;
> +
> +            src0    = __lasx_xvld(src + filterPos[i], 0);
> +            filter0 = __lasx_xvld(filter, 0);
> +            out0 = __lasx_xvdp2_w_hu_h(src0, filter0);
> +            out0    = __lasx_xvhaddw_d_w(out0, out0);
> +            out0    = __lasx_xvhaddw_q_d(out0, out0);
> +            val     = __lasx_xvpickve2gr_w(out0, 0);
> +            dst[i]  = FFMIN(val >> sh, max);
> +            filter += 8;
> +        }
> +    } else if (filterSize == 4) {
> +        __m256i v_max = __lasx_xvreplgr2vr_w(max);
> +        for (i = 0; i < len; i++) {
> +            __m256i src1, src2, src3, src4, src0, filter0, out0;
> +
> +            src1 = __lasx_xvldrepl_d(src + filterPos[0], 0);
> +            src2 = __lasx_xvldrepl_d(src + filterPos[1], 0);
> +            src3 = __lasx_xvldrepl_d(src + filterPos[2], 0);
> +            src4 = __lasx_xvldrepl_d(src + filterPos[3], 0);
> +            filter0 = __lasx_xvld(filter, 0);
> +            src1 = __lasx_xvextrins_d(src1, src2, 0x10);
> +            src3 = __lasx_xvextrins_d(src3, src4, 0x10);
> +            src0 = __lasx_xvpermi_q(src1, src3, 0x02);
> +            out0 = __lasx_xvdp2_w_hu_h(src0, filter0);
> +            out0 = __lasx_xvhaddw_d_w(out0, out0);
> +            out0 = __lasx_xvsra_w(out0, shift);
> +            out0 = __lasx_xvmin_w(out0, v_max);
> +            dst[0] = __lasx_xvpickve2gr_w(out0, 0);
> +            dst[1] = __lasx_xvpickve2gr_w(out0, 2);
> +            dst[2] = __lasx_xvpickve2gr_w(out0, 4);
> +            dst[3] = __lasx_xvpickve2gr_w(out0, 6);
> +            dst       += 4;
> +            filterPos += 4;
> +            filter    += 16;
> +        }
> +        for (i = 0; i < res; i++) {
> +            int val = 0;
> +            const uint16_t *srcPos = src + filterPos[i];
> +
> +            for (int j = 0; j < filterSize; j++) {
> +                val += ((int)srcPos[j]) * filter[j];
> +            }
> +            dst[i]  = FFMIN(val >> sh, max);
> +            filter += 4;
> +        }
> +    } else if (filterSize > 8) {
> +        int filterlen = filterSize - 7;
> +
> +        for (i = 0; i < len; i++) {
> +            __m256i src0, src1, src2, src3;
> +            __m256i filter0, filter1, filter2, filter3, out0, out1;
> +            __m256i out = zero;
> +            const uint16_t *srcPos1 = src + filterPos[0];
> +            const uint16_t *srcPos2 = src + filterPos[1];
> +            const uint16_t *srcPos3 = src + filterPos[2];
> +            const uint16_t *srcPos4 = src + filterPos[3];
> +            const int16_t *filterStart1 = filter;
> +            const int16_t *filterStart2 = filterStart1 + filterSize;
> +            const int16_t *filterStart3 = filterStart2 + filterSize;
> +            const int16_t *filterStart4 = filterStart3 + filterSize;
> +            int j, val1 = 0, val2 = 0, val3 = 0, val4 = 0;
> +
> +            for (j = 0; j < filterlen; j += 8) {
> +                SCALE_16
> +            }
> +            val1 = __lasx_xvpickve2gr_w(out, 0);
> +            val2 = __lasx_xvpickve2gr_w(out, 4);
> +            val3 = __lasx_xvpickve2gr_w(out, 2);
> +            val4 = __lasx_xvpickve2gr_w(out, 6);
> +            for (; j < filterSize; j++) {
> +                val1 += ((int)srcPos1[j]) * filterStart1[j];
> +                val2 += ((int)srcPos2[j]) * filterStart2[j];
> +                val3 += ((int)srcPos3[j]) * filterStart3[j];
> +                val4 += ((int)srcPos4[j]) * filterStart4[j];
> +            }
> +            dst[0] = FFMIN(val1 >> sh, max);
> +            dst[1] = FFMIN(val2 >> sh, max);
> +            dst[2] = FFMIN(val3 >> sh, max);
> +            dst[3] = FFMIN(val4 >> sh, max);
> +            dst       += 4;
> +            filterPos += 4;
> +            filter     = filterStart4 + filterSize;
> +        }
> +        for (i = 0; i < res; i++) {
> +            int j, val = 0;
> +            const uint16_t *srcPos      = src + filterPos[i];
> +            __m256i src0, filter0, out0;
> +
> +            for (j = 0; j < filterlen; j += 8) {
> +                int dex = j << 1;
> +                src0    = __lasx_xvldx(srcPos, dex);
> +                filter0 = __lasx_xvldx(filter, dex);
> +                out0 = __lasx_xvdp2_w_hu_h(src0, filter0);
> +                out0    = __lasx_xvhaddw_d_w(out0, out0);
> +                out0    = __lasx_xvhaddw_q_d(out0, out0);
> +                val    += __lasx_xvpickve2gr_w(out0, 0);
> +            }
> +            for (; j < filterSize; j++) {
> +                val += ((int)srcPos[j]) * filter[j];
> +            }
> +            dst[i]  = FFMIN(val >> sh, max);
> +            filter += filterSize;
> +        }
> +    } else {
> +        for (i = 0; i < dstW; i++) {
> +            int val = 0;
> +            const uint16_t *srcPos = src + filterPos[i];
> +
> +            for (int j = 0; j < filterSize; j++) {
> +                val += ((int)srcPos[j]) * filter[j];
> +            }
> +            dst[i]  = FFMIN(val >> sh, max);
> +            filter += filterSize;
> +        }
> +    }
> +}
> +
> +void ff_hscale_16_to_19_lasx(SwsContext *c, int16_t *_dst, int dstW,
> +                             const uint8_t *_src, const int16_t *filter,
> +                             const int32_t *filterPos, int filterSize)
> +{
> +    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
> +    int i;
> +    int32_t *dst        = (int32_t *) _dst;
> +    const uint16_t *src = (const uint16_t *) _src;
> +    int sh              = desc->comp[0].depth - 5;
> +    int max = (1 << 19) - 1;
> +    int len = dstW >> 2;
> +    int res = dstW & 3;
> +    __m256i shift;
> +    __m256i zero = __lasx_xvldi(0);
> +
> +    if ((isAnyRGB(c->srcFormat) || c->srcFormat == AV_PIX_FMT_PAL8)
> +         && desc->comp[0].depth<16) {
> +        sh = 9;
> +    } else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
> +        sh = 11;
> +    }
> +    shift = __lasx_xvreplgr2vr_w(sh);
> +
> +    if (filterSize == 8) {
> +        __m256i v_max = __lasx_xvreplgr2vr_w(max);
> +        for (i = 0; i < len; i++) {
> +            SCALE_8
> +        }
> +        for (i = 0; i < res; i++) {
> +            int val = 0;
> +            __m256i src0, filter0, out0;
> +
> +            src0 = __lasx_xvld(src + filterPos[i], 0);
> +            filter0 = __lasx_xvld(filter, 0);
> +            out0 = __lasx_xvdp2_w_hu_h(src0, filter0);
> +            out0 = __lasx_xvhaddw_d_w(out0, out0);
> +            out0 = __lasx_xvhaddw_q_d(out0, out0);
> +            val  = __lasx_xvpickve2gr_w(out0, 0);
> +            dst[i] = FFMIN(val >> sh, max);
> +            filter += 8;
> +        }
> +    } else if (filterSize == 4) {
> +        __m256i v_max = __lasx_xvreplgr2vr_w(max);
> +        for (i = 0; i < len; i++) {
> +            __m256i src1, src2, src3, src4, src0, filter0, out0;
> +
> +            src1 = __lasx_xvldrepl_d(src + filterPos[0], 0);
> +            src2 = __lasx_xvldrepl_d(src + filterPos[1], 0);
> +            src3 = __lasx_xvldrepl_d(src + filterPos[2], 0);
> +            src4 = __lasx_xvldrepl_d(src + filterPos[3], 0);
> +            filter0 = __lasx_xvld(filter, 0);
> +            src1 = __lasx_xvextrins_d(src1, src2, 0x10);
> +            src3 = __lasx_xvextrins_d(src3, src4, 0x10);
> +            src0 = __lasx_xvpermi_q(src1, src3, 0x02);
> +            out0 = __lasx_xvdp2_w_hu_h(src0, filter0);
> +            out0 = __lasx_xvhaddw_d_w(out0, out0);
> +            out0 = __lasx_xvsra_w(out0, shift);
> +            out0 = __lasx_xvmin_w(out0, v_max);
> +            dst[0] = __lasx_xvpickve2gr_w(out0, 0);
> +            dst[1] = __lasx_xvpickve2gr_w(out0, 2);
> +            dst[2] = __lasx_xvpickve2gr_w(out0, 4);
> +            dst[3] = __lasx_xvpickve2gr_w(out0, 6);
> +            dst       += 4;
> +            filterPos += 4;
> +            filter    += 16;
> +        }
> +        for (i = 0; i < res; i++) {
> +            int val = 0;
> +            const uint16_t *srcPos = src + filterPos[i];
> +
> +            for (int j = 0; j < filterSize; j++) {
> +                val += ((int)srcPos[j]) * filter[j];
> +            }
> +            dst[i]  = FFMIN(val >> sh, max);
> +            filter += 4;
> +        }
> +    } else if (filterSize > 8) {
> +        int filterlen = filterSize - 7;
> +
> +        for (i = 0; i < len; i ++) {
> +            __m256i src0, src1, src2, src3;
> +            __m256i filter0, filter1, filter2, filter3, out0, out1;
> +            __m256i out = zero;
> +            const uint16_t *srcPos1 = src + filterPos[0];
> +            const uint16_t *srcPos2 = src + filterPos[1];
> +            const uint16_t *srcPos3 = src + filterPos[2];
> +            const uint16_t *srcPos4 = src + filterPos[3];
> +            const int16_t *filterStart1 = filter;
> +            const int16_t *filterStart2 = filterStart1 + filterSize;
> +            const int16_t *filterStart3 = filterStart2 + filterSize;
> +            const int16_t *filterStart4 = filterStart3 + filterSize;
> +            int j, val1 = 0, val2 = 0, val3 = 0, val4 = 0;
> +
> +            for (j = 0; j < filterlen; j += 8) {
> +                SCALE_16
> +            }
> +            val1 = __lasx_xvpickve2gr_w(out, 0);
> +            val2 = __lasx_xvpickve2gr_w(out, 4);
> +            val3 = __lasx_xvpickve2gr_w(out, 2);
> +            val4 = __lasx_xvpickve2gr_w(out, 6);
> +            for (; j < filterSize; j++) {
> +                val1 += ((int)srcPos1[j]) * filterStart1[j];
> +                val2 += ((int)srcPos2[j]) * filterStart2[j];
> +                val3 += ((int)srcPos3[j]) * filterStart3[j];
> +                val4 += ((int)srcPos4[j]) * filterStart4[j];
> +            }
> +            dst[0] = FFMIN(val1 >> sh, max);
> +            dst[1] = FFMIN(val2 >> sh, max);
> +            dst[2] = FFMIN(val3 >> sh, max);
> +            dst[3] = FFMIN(val4 >> sh, max);
> +            dst       += 4;
> +            filterPos += 4;
> +            filter     = filterStart4 + filterSize;
> +        }
> +        for (i = 0; i < res; i++) {
> +            int j, val = 0;
> +            const uint16_t *srcPos      = src + filterPos[i];
> +            __m256i src0, filter0, out0;
> +
> +            for (j = 0; j < filterlen; j += 8) {
> +                int dex = j << 1;
> +                src0 = __lasx_xvldx(srcPos, dex);
> +                filter0 = __lasx_xvldx(filter, dex);
> +                out0 = __lasx_xvdp2_w_hu_h(src0, filter0);
> +                out0    = __lasx_xvhaddw_d_w(out0, out0);
> +                out0    = __lasx_xvhaddw_q_d(out0, out0);
> +                val    += __lasx_xvpickve2gr_w(out0, 0);
> +            }
> +            for (; j < filterSize; j++) {
> +                val += ((int)srcPos[j]) * filter[j];
> +            }
> +            dst[i]  = FFMIN(val >> sh, max);
> +            filter += filterSize;
> +        }
> +    } else {
> +        for (i = 0; i < dstW; i++) {
> +            int val = 0;
> +            const uint16_t *srcPos = src + filterPos[i];
> +
> +            for (int j = 0; j < filterSize; j++) {
> +                val += ((int)srcPos[j]) * filter[j];
> +            }
> +            dst[i]  = FFMIN(val >> sh, max);
> +            filter += filterSize;
> +        }
> +    }
> +}
> +
> +#undef SCALE_8
> +#undef SCALE_16
> diff --git a/libswscale/loongarch/swscale_loongarch.h b/libswscale/loongarch/swscale_loongarch.h
> new file mode 100644
> index 0000000000..67e24d544c
> --- /dev/null
> +++ b/libswscale/loongarch/swscale_loongarch.h
> @@ -0,0 +1,50 @@
> +/*
> + * Copyright (C) 2022 Loongson Technology Corporation Limited
> + * Contributed by Hao Chen(chenhao@loongson.cn)
> + *
> + * This file is part of FFmpeg.
> + *
> + * FFmpeg 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.
> + *
> + * FFmpeg 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 FFmpeg; if not, write to the Free Software
> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
> + */
> +
> +#ifndef SWSCALE_LOONGARCH_SWSCALE_LOONGARCH_H
> +#define SWSCALE_LOONGARCH_SWSCALE_LOONGARCH_H
> +
> +#include "libswscale/swscale.h"
> +#include "libswscale/swscale_internal.h"
> +
> +void ff_hscale_8_to_15_lasx(SwsContext *c, int16_t *dst, int dstW,
> +                            const uint8_t *src, const int16_t *filter,
> +                            const int32_t *filterPos, int filterSize);
> +
> +void ff_hscale_8_to_19_lasx(SwsContext *c, int16_t *_dst, int dstW,
> +                            const uint8_t *src, const int16_t *filter,
> +                            const int32_t *filterPos, int filterSize);
> +
> +void ff_hscale_16_to_19_lasx(SwsContext *c, int16_t *_dst, int dstW,
> +                             const uint8_t *_src, const int16_t *filter,
> +                             const int32_t *filterPos, int filterSize);
> +
> +void ff_hscale_16_to_15_lasx(SwsContext *c, int16_t *dst, int dstW,
> +                             const uint8_t *_src, const int16_t *filter,
> +                             const int32_t *filterPos, int filterSize);
> +
> +void planar_rgb_to_uv_lasx(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4],
> +                           int width, int32_t *rgb2yuv);
> +
> +void planar_rgb_to_y_lasx(uint8_t *_dst, const uint8_t *src[4], int width,
> +                          int32_t *rgb2yuv);
> +
> +#endif /* SWSCALE_LOONGARCH_SWSCALE_LOONGARCH_H */
> diff --git a/libswscale/swscale.c b/libswscale/swscale.c
> index 7b40f49da4..367d045a02 100644
> --- a/libswscale/swscale.c
> +++ b/libswscale/swscale.c
> @@ -598,6 +598,8 @@ void ff_sws_init_scale(SwsContext *c)
>      ff_sws_init_swscale_aarch64(c);
>  #elif ARCH_ARM
>      ff_sws_init_swscale_arm(c);
> +#elif ARCH_LOONGARCH64
> +    ff_sws_init_swscale_loongarch(c);
>  #endif
>  }
>  
> diff --git a/libswscale/swscale_internal.h b/libswscale/swscale_internal.h
> index 6c14ce8536..abeebbb002 100644
> --- a/libswscale/swscale_internal.h
> +++ b/libswscale/swscale_internal.h
> @@ -698,6 +698,7 @@ av_cold void ff_sws_init_range_convert(SwsContext *c);
>  
>  SwsFunc ff_yuv2rgb_init_x86(SwsContext *c);
>  SwsFunc ff_yuv2rgb_init_ppc(SwsContext *c);
> +SwsFunc ff_yuv2rgb_init_loongarch(SwsContext *c);
>  
>  static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
>  {
> @@ -983,6 +984,7 @@ void ff_sws_init_swscale_vsx(SwsContext *c);
>  void ff_sws_init_swscale_x86(SwsContext *c);
>  void ff_sws_init_swscale_aarch64(SwsContext *c);
>  void ff_sws_init_swscale_arm(SwsContext *c);
> +void ff_sws_init_swscale_loongarch(SwsContext *c);
>  
>  void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth,
>                         const uint8_t *src, int srcW, int xInc);
> diff --git a/libswscale/utils.c b/libswscale/utils.c
> index a621a35862..f762fba1df 100644
> --- a/libswscale/utils.c
> +++ b/libswscale/utils.c
> @@ -53,6 +53,7 @@
>  #include "libavutil/ppc/cpu.h"
>  #include "libavutil/x86/asm.h"
>  #include "libavutil/x86/cpu.h"
> +#include "libavutil/loongarch/cpu.h"
>  
>  #include "rgb2rgb.h"
>  #include "swscale.h"
> @@ -654,6 +655,15 @@ static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos,
>              filterAlign = 1;
>      }
>  
> +    if (have_lasx(cpu_flags)) {
> +        int reNum = minFilterSize & (0x07);
> +
> +        if (minFilterSize < 5)
> +            filterAlign = 4;
> +        if (reNum < 3)
> +            filterAlign = 1;
> +    }
> +
>      av_assert0(minFilterSize > 0);
>      filterSize = (minFilterSize + (filterAlign - 1)) & (~(filterAlign - 1));
>      av_assert0(filterSize > 0);
> @@ -1839,7 +1849,8 @@ av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
>          {
>              const int filterAlign = X86_MMX(cpu_flags)     ? 4 :
>                                      PPC_ALTIVEC(cpu_flags) ? 8 :
> -                                    have_neon(cpu_flags)   ? 4 : 1;
> +                                    have_neon(cpu_flags)   ? 4 :
> +                                    have_lasx(cpu_flags)   ? 8 : 1;
>  
>              if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos,
>                             &c->hLumFilterSize, c->lumXInc,
Hao Chen Sept. 6, 2022, 8:06 a.m. UTC | #2
在 2022/9/3 下午8:31, Andreas Rheinhardt 写道:
> Hao Chen:
>> ffmpeg -i 1_h264_1080p_30fps_3Mbps.mp4 -f rawvideo -s 640x480 -y /dev/null -an
>> before: 101fps
>> after:  138fps
>>
>> Signed-off-by: Hao Chen <chenhao@loongson.cn>
>> ---
>>   libswscale/loongarch/Makefile                 |   3 +
>>   libswscale/loongarch/input_lasx.c             | 202 ++++
>>   libswscale/loongarch/swscale_init_loongarch.c |  50 +
>>   libswscale/loongarch/swscale_lasx.c           | 972 ++++++++++++++++++
>>   libswscale/loongarch/swscale_loongarch.h      |  50 +
>>   libswscale/swscale.c                          |   2 +
>>   libswscale/swscale_internal.h                 |   2 +
>>   libswscale/utils.c                            |  13 +-
>>   8 files changed, 1293 insertions(+), 1 deletion(-)
>>   create mode 100644 libswscale/loongarch/Makefile
>>   create mode 100644 libswscale/loongarch/input_lasx.c
>>   create mode 100644 libswscale/loongarch/swscale_init_loongarch.c
>>   create mode 100644 libswscale/loongarch/swscale_lasx.c
>>   create mode 100644 libswscale/loongarch/swscale_loongarch.h
>>
>> diff --git a/libswscale/loongarch/Makefile b/libswscale/loongarch/Makefile
>> new file mode 100644
>> index 0000000000..586a1717b6
>> --- /dev/null
>> +++ b/libswscale/loongarch/Makefile
>> @@ -0,0 +1,3 @@
>> +OBJS-$(CONFIG_SWSCALE)      += loongarch/swscale_init_loongarch.o
>> +LASX-OBJS-$(CONFIG_SWSCALE) += loongarch/swscale_lasx.o \
>> +                               loongarch/input_lasx.o   \
>> diff --git a/libswscale/loongarch/input_lasx.c b/libswscale/loongarch/input_lasx.c
>> new file mode 100644
>> index 0000000000..c3060ea6a3
>> --- /dev/null
>> +++ b/libswscale/loongarch/input_lasx.c
>> @@ -0,0 +1,202 @@
>> +/*
>> + * Copyright (C) 2022 Loongson Technology Corporation Limited
>> + * Contributed by Hao Chen(chenhao@loongson.cn)
>> + *
>> + * This file is part of FFmpeg.
>> + *
>> + * FFmpeg 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.
>> + *
>> + * FFmpeg 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 FFmpeg; if not, write to the Free Software
>> + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
>> + */
>> +
>> +#include "swscale_loongarch.h"
>> +#include "libavutil/loongarch/loongson_intrinsics.h"
>> +
>> +void planar_rgb_to_uv_lasx(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4],
>> +                           int width, int32_t *rgb2yuv)
>> +{
>> +    int i;
>> +    uint16_t *dstU   = (uint16_t *)_dstU;
>> +    uint16_t *dstV   = (uint16_t *)_dstV;
>> +    int set          = 0x4001 << (RGB2YUV_SHIFT - 7);
>> +    int len          = width - 15;
>> +    int32_t tem_ru   = rgb2yuv[RU_IDX], tem_gu = rgb2yuv[GU_IDX];
>> +    int32_t tem_bu = rgb2yuv[BU_IDX], tem_rv   = rgb2yuv[RV_IDX];
>> +    int32_t tem_gv = rgb2yuv[GV_IDX], tem_bv = rgb2yuv[BV_IDX];
>> +    int shift        = RGB2YUV_SHIFT - 6;
>> +    const uint8_t *src0 = src[0], *src1 = src[1], *src2 = src[2];
>> +    __m256i ru, gu, bu, rv, gv, bv;
>> +    __m256i mask = {0x0D0C090805040100, 0x1D1C191815141110,
>> +                    0x0D0C090805040100, 0x1D1C191815141110};
>> +    __m256i temp = __lasx_xvreplgr2vr_w(set);
>> +    __m256i sra  = __lasx_xvreplgr2vr_w(shift);
>> +
>> +    ru = __lasx_xvreplgr2vr_w(tem_ru);
>> +    gu = __lasx_xvreplgr2vr_w(tem_gu);
>> +    bu = __lasx_xvreplgr2vr_w(tem_bu);
>> +    rv = __lasx_xvreplgr2vr_w(tem_rv);
>> +    gv = __lasx_xvreplgr2vr_w(tem_gv);
>> +    bv = __lasx_xvreplgr2vr_w(tem_bv);
>> +    for (i = 0; i < len; i += 16) {
>> +        __m256i _g, _b, _r;
>> +        __m256i g_l, g_h, b_l, b_h, r_l, r_h;
>> +        __m256i v_l, v_h, u_l, u_h, u_lh, v_lh;
>> +
>> +        _g  = __lasx_xvldx(src0, i);
> According to
> https://patchwork.ffmpeg.org/project/ffmpeg/list/?series=7366 this
> patchset creates new warnings and as I have explained in
> https://ffmpeg.org/pipermail/ffmpeg-devel/2022-August/300682.html this
> is (most likely) due to lasxintrin.h and lsxintrin.h not accepting
> pointers to void in the load-functions. The above __lasx_xvldx() is
> affected by this. Could you please fix this issue and provide an updated
> toolchain able to compile lsx and lasx?
>
Thanks for your attention to loongson. The __lasx_xvldx() is defined in 
lasxintrin.h as following:

extern __inline __attribute__((__gnu_inline__, __always_inline__, 
__artificial__))
__m256i __lasx_xvldx(void * _1, long int _2)

{
     return (void)__builtin_lasx_xvstx((v32i8)_1, (void *)_2, (long int)_3);
}

A warning appears when the parameter passed is a pointer to a const.

Now, I have fed it back to my colleagues in the compiler group to 
discuss how to solve it.

I believe it will be solved soon.
diff mbox series

Patch

diff --git a/libswscale/loongarch/Makefile b/libswscale/loongarch/Makefile
new file mode 100644
index 0000000000..586a1717b6
--- /dev/null
+++ b/libswscale/loongarch/Makefile
@@ -0,0 +1,3 @@ 
+OBJS-$(CONFIG_SWSCALE)      += loongarch/swscale_init_loongarch.o
+LASX-OBJS-$(CONFIG_SWSCALE) += loongarch/swscale_lasx.o \
+                               loongarch/input_lasx.o   \
diff --git a/libswscale/loongarch/input_lasx.c b/libswscale/loongarch/input_lasx.c
new file mode 100644
index 0000000000..c3060ea6a3
--- /dev/null
+++ b/libswscale/loongarch/input_lasx.c
@@ -0,0 +1,202 @@ 
+/*
+ * Copyright (C) 2022 Loongson Technology Corporation Limited
+ * Contributed by Hao Chen(chenhao@loongson.cn)
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "swscale_loongarch.h"
+#include "libavutil/loongarch/loongson_intrinsics.h"
+
+void planar_rgb_to_uv_lasx(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4],
+                           int width, int32_t *rgb2yuv)
+{
+    int i;
+    uint16_t *dstU   = (uint16_t *)_dstU;
+    uint16_t *dstV   = (uint16_t *)_dstV;
+    int set          = 0x4001 << (RGB2YUV_SHIFT - 7);
+    int len          = width - 15;
+    int32_t tem_ru   = rgb2yuv[RU_IDX], tem_gu = rgb2yuv[GU_IDX];
+    int32_t tem_bu = rgb2yuv[BU_IDX], tem_rv   = rgb2yuv[RV_IDX];
+    int32_t tem_gv = rgb2yuv[GV_IDX], tem_bv = rgb2yuv[BV_IDX];
+    int shift        = RGB2YUV_SHIFT - 6;
+    const uint8_t *src0 = src[0], *src1 = src[1], *src2 = src[2];
+    __m256i ru, gu, bu, rv, gv, bv;
+    __m256i mask = {0x0D0C090805040100, 0x1D1C191815141110,
+                    0x0D0C090805040100, 0x1D1C191815141110};
+    __m256i temp = __lasx_xvreplgr2vr_w(set);
+    __m256i sra  = __lasx_xvreplgr2vr_w(shift);
+
+    ru = __lasx_xvreplgr2vr_w(tem_ru);
+    gu = __lasx_xvreplgr2vr_w(tem_gu);
+    bu = __lasx_xvreplgr2vr_w(tem_bu);
+    rv = __lasx_xvreplgr2vr_w(tem_rv);
+    gv = __lasx_xvreplgr2vr_w(tem_gv);
+    bv = __lasx_xvreplgr2vr_w(tem_bv);
+    for (i = 0; i < len; i += 16) {
+        __m256i _g, _b, _r;
+        __m256i g_l, g_h, b_l, b_h, r_l, r_h;
+        __m256i v_l, v_h, u_l, u_h, u_lh, v_lh;
+
+        _g  = __lasx_xvldx(src0, i);
+        _b  = __lasx_xvldx(src1, i);
+        _r  = __lasx_xvldx(src2, i);
+        g_l = __lasx_vext2xv_wu_bu(_g);
+        b_l = __lasx_vext2xv_wu_bu(_b);
+        r_l = __lasx_vext2xv_wu_bu(_r);
+        _g  = __lasx_xvpermi_d(_g, 0x01);
+        _b  = __lasx_xvpermi_d(_b, 0x01);
+        _r  = __lasx_xvpermi_d(_r, 0x01);
+        g_h = __lasx_vext2xv_wu_bu(_g);
+        b_h = __lasx_vext2xv_wu_bu(_b);
+        r_h = __lasx_vext2xv_wu_bu(_r);
+        u_l  = __lasx_xvmadd_w(temp, ru, r_l);
+        u_h  = __lasx_xvmadd_w(temp, ru, r_h);
+        v_l  = __lasx_xvmadd_w(temp, rv, r_l);
+        v_h  = __lasx_xvmadd_w(temp, rv, r_h);
+        u_l  = __lasx_xvmadd_w(u_l, gu, g_l);
+        u_l  = __lasx_xvmadd_w(u_l, bu, b_l);
+        u_h  = __lasx_xvmadd_w(u_h, gu, g_h);
+        u_h  = __lasx_xvmadd_w(u_h, bu, b_h);
+        v_l  = __lasx_xvmadd_w(v_l, gv, g_l);
+        v_l  = __lasx_xvmadd_w(v_l, bv, b_l);
+        v_h  = __lasx_xvmadd_w(v_h, gv, g_h);
+        v_h  = __lasx_xvmadd_w(v_h, bv, b_h);
+        u_l  = __lasx_xvsra_w(u_l, sra);
+        u_h  = __lasx_xvsra_w(u_h, sra);
+        v_l  = __lasx_xvsra_w(v_l, sra);
+        v_h  = __lasx_xvsra_w(v_h, sra);
+        u_lh = __lasx_xvshuf_b(u_h, u_l, mask);
+        v_lh = __lasx_xvshuf_b(v_h, v_l, mask);
+        u_lh = __lasx_xvpermi_d(u_lh, 0xD8);
+        v_lh = __lasx_xvpermi_d(v_lh, 0xD8);
+        __lasx_xvst(u_lh, (dstU + i), 0);
+        __lasx_xvst(v_lh, (dstV + i), 0);
+    }
+    if (width - i >= 8) {
+        __m256i _g, _b, _r;
+        __m256i g_l, b_l, r_l;
+        __m256i v_l, u_l, u, v;
+
+        _g  = __lasx_xvldrepl_d((src0 + i), 0);
+        _b  = __lasx_xvldrepl_d((src1 + i), 0);
+        _r  = __lasx_xvldrepl_d((src2 + i), 0);
+        g_l = __lasx_vext2xv_wu_bu(_g);
+        b_l = __lasx_vext2xv_wu_bu(_b);
+        r_l = __lasx_vext2xv_wu_bu(_r);
+        u_l = __lasx_xvmadd_w(temp, ru, r_l);
+        v_l = __lasx_xvmadd_w(temp, rv, r_l);
+        u_l = __lasx_xvmadd_w(u_l, gu, g_l);
+        u_l = __lasx_xvmadd_w(u_l, bu, b_l);
+        v_l = __lasx_xvmadd_w(v_l, gv, g_l);
+        v_l = __lasx_xvmadd_w(v_l, bv, b_l);
+        u_l = __lasx_xvsra_w(u_l, sra);
+        v_l = __lasx_xvsra_w(v_l, sra);
+        u   = __lasx_xvshuf_b(u_l, u_l, mask);
+        v   = __lasx_xvshuf_b(v_l, v_l, mask);
+        __lasx_xvstelm_d(u, (dstU + i), 0, 0);
+        __lasx_xvstelm_d(u, (dstU + i), 8, 2);
+        __lasx_xvstelm_d(v, (dstV + i), 0, 0);
+        __lasx_xvstelm_d(v, (dstV + i), 8, 2);
+        i += 8;
+    }
+    for (; i < width; i++) {
+        int g = src[0][i];
+        int b = src[1][i];
+        int r = src[2][i];
+
+        dstU[i] = (tem_ru * r + tem_gu * g + tem_bu * b + set) >> shift;
+        dstV[i] = (tem_rv * r + tem_gv * g + tem_bv * b + set) >> shift;
+    }
+}
+
+void planar_rgb_to_y_lasx(uint8_t *_dst, const uint8_t *src[4], int width,
+                          int32_t *rgb2yuv)
+{
+    int i;
+    int shift        = (RGB2YUV_SHIFT - 6);
+    int set          = 0x801 << (RGB2YUV_SHIFT - 7);
+    int len          = width - 15;
+    uint16_t *dst    = (uint16_t *)_dst;
+    int32_t tem_ry   = rgb2yuv[RY_IDX], tem_gy = rgb2yuv[GY_IDX];
+    int32_t tem_by   = rgb2yuv[BY_IDX];
+    const uint8_t *src0 = src[0], *src1 = src[1], *src2 = src[2];
+    __m256i mask = {0x0D0C090805040100, 0x1D1C191815141110,
+                    0x0D0C090805040100, 0x1D1C191815141110};
+    __m256i temp = __lasx_xvreplgr2vr_w(set);
+    __m256i sra  = __lasx_xvreplgr2vr_w(shift);
+    __m256i ry   = __lasx_xvreplgr2vr_w(tem_ry);
+    __m256i gy   = __lasx_xvreplgr2vr_w(tem_gy);
+    __m256i by   = __lasx_xvreplgr2vr_w(tem_by);
+
+    for (i = 0; i < len; i += 16) {
+        __m256i _g, _b, _r;
+        __m256i g_l, g_h, b_l, b_h, r_l, r_h;
+        __m256i y_l, y_h, y_lh;
+
+        _g  = __lasx_xvldx(src0, i);
+        _b  = __lasx_xvldx(src1, i);
+        _r  = __lasx_xvldx(src2, i);
+        g_l = __lasx_vext2xv_wu_bu(_g);
+        b_l = __lasx_vext2xv_wu_bu(_b);
+        r_l = __lasx_vext2xv_wu_bu(_r);
+        _g  = __lasx_xvpermi_d(_g, 0x01);
+        _b  = __lasx_xvpermi_d(_b, 0x01);
+        _r  = __lasx_xvpermi_d(_r, 0x01);
+        g_h = __lasx_vext2xv_wu_bu(_g);
+        b_h = __lasx_vext2xv_wu_bu(_b);
+        r_h = __lasx_vext2xv_wu_bu(_r);
+        y_l  = __lasx_xvmadd_w(temp, ry, r_l);
+        y_h  = __lasx_xvmadd_w(temp, ry, r_h);
+        y_l  = __lasx_xvmadd_w(y_l, gy, g_l);
+        y_l  = __lasx_xvmadd_w(y_l, by, b_l);
+        y_h  = __lasx_xvmadd_w(y_h, gy, g_h);
+        y_h  = __lasx_xvmadd_w(y_h, by, b_h);
+        y_l  = __lasx_xvsra_w(y_l, sra);
+        y_h  = __lasx_xvsra_w(y_h, sra);
+        y_lh = __lasx_xvshuf_b(y_h, y_l, mask);
+        y_lh = __lasx_xvpermi_d(y_lh, 0xD8);
+        __lasx_xvst(y_lh, (dst + i), 0);
+    }
+    if (width - i >= 8) {
+        __m256i _g, _b, _r;
+        __m256i g_l, b_l, r_l;
+        __m256i y_l, y;
+
+        _g  = __lasx_xvldrepl_d((src0 + i), 0);
+        _b  = __lasx_xvldrepl_d((src1 + i), 0);
+        _r  = __lasx_xvldrepl_d((src2 + i), 0);
+        g_l = __lasx_vext2xv_wu_bu(_g);
+        b_l = __lasx_vext2xv_wu_bu(_b);
+        r_l = __lasx_vext2xv_wu_bu(_r);
+        y_l = __lasx_xvmadd_w(temp, ry, r_l);
+        y_l = __lasx_xvmadd_w(y_l, gy, g_l);
+        y_l = __lasx_xvmadd_w(y_l, by, b_l);
+        y_l = __lasx_xvsra_w(y_l, sra);
+        y = __lasx_xvshuf_b(y_l, y_l, mask);
+        __lasx_xvstelm_d(y, (dst + i), 0, 0);
+        __lasx_xvstelm_d(y, (dst + i), 8, 2);
+        i += 8;
+    }
+    for (; i < width; i++) {
+        int g = src[0][i];
+        int b = src[1][i];
+        int r = src[2][i];
+
+        dst[i] = (tem_ry * r + tem_gy * g + tem_by * b + set) >> shift;
+    }
+}
diff --git a/libswscale/loongarch/swscale_init_loongarch.c b/libswscale/loongarch/swscale_init_loongarch.c
new file mode 100644
index 0000000000..197dc6e1e7
--- /dev/null
+++ b/libswscale/loongarch/swscale_init_loongarch.c
@@ -0,0 +1,50 @@ 
+/*
+ * Copyright (C) 2022 Loongson Technology Corporation Limited
+ * Contributed by Hao Chen(chenhao@loongson.cn)
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "swscale_loongarch.h"
+#include "libswscale/swscale_internal.h"
+#include "libavutil/loongarch/cpu.h"
+
+av_cold void ff_sws_init_swscale_loongarch(SwsContext *c)
+{
+    int cpu_flags = av_get_cpu_flags();
+    if (have_lasx(cpu_flags)) {
+        if (c->srcBpc == 8) {
+            if (c->dstBpc <= 14) {
+                c->hyScale = c->hcScale = ff_hscale_8_to_15_lasx;
+            } else {
+                c->hyScale = c->hcScale = ff_hscale_8_to_19_lasx;
+            }
+        } else {
+            c->hyScale = c->hcScale = c->dstBpc > 14 ? ff_hscale_16_to_19_lasx
+                                                     : ff_hscale_16_to_15_lasx;
+        }
+        switch (c->srcFormat) {
+        case AV_PIX_FMT_GBRAP:
+        case AV_PIX_FMT_GBRP:
+            {
+                c->readChrPlanar = planar_rgb_to_uv_lasx;
+                c->readLumPlanar = planar_rgb_to_y_lasx;
+            }
+            break;
+        }
+    }
+}
diff --git a/libswscale/loongarch/swscale_lasx.c b/libswscale/loongarch/swscale_lasx.c
new file mode 100644
index 0000000000..3e0bae2cc2
--- /dev/null
+++ b/libswscale/loongarch/swscale_lasx.c
@@ -0,0 +1,972 @@ 
+/*
+ * Copyright (C) 2022 Loongson Technology Corporation Limited
+ * Contributed by Hao Chen(chenhao@loongson.cn)
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "swscale_loongarch.h"
+#include "libavutil/loongarch/loongson_intrinsics.h"
+#include "libavutil/intreadwrite.h"
+
+#define SCALE_8_16(_sh)                                               \
+{                                                                     \
+    src0    = __lasx_xvldrepl_d(src + filterPos[0], 0);               \
+    src1    = __lasx_xvldrepl_d(src + filterPos[1], 0);               \
+    src2    = __lasx_xvldrepl_d(src + filterPos[2], 0);               \
+    src3    = __lasx_xvldrepl_d(src + filterPos[3], 0);               \
+    src4    = __lasx_xvldrepl_d(src + filterPos[4], 0);               \
+    src5    = __lasx_xvldrepl_d(src + filterPos[5], 0);               \
+    src6    = __lasx_xvldrepl_d(src + filterPos[6], 0);               \
+    src7    = __lasx_xvldrepl_d(src + filterPos[7], 0);               \
+    src8    = __lasx_xvldrepl_d(src + filterPos[8], 0);               \
+    src9    = __lasx_xvldrepl_d(src + filterPos[9], 0);               \
+    src10   = __lasx_xvldrepl_d(src + filterPos[10], 0);              \
+    src11   = __lasx_xvldrepl_d(src + filterPos[11], 0);              \
+    src12   = __lasx_xvldrepl_d(src + filterPos[12], 0);              \
+    src13   = __lasx_xvldrepl_d(src + filterPos[13], 0);              \
+    src14   = __lasx_xvldrepl_d(src + filterPos[14], 0);              \
+    src15   = __lasx_xvldrepl_d(src + filterPos[15], 0);              \
+    DUP4_ARG2(__lasx_xvld, filter, 0, filter, 32, filter, 64,         \
+              filter, 96, filter0, filter1, filter2, filter3);        \
+    DUP4_ARG2(__lasx_xvld, filter, 128, filter, 160,                  \
+              filter, 192, filter, 224, filter4,                      \
+              filter5, filter6, filter7);                             \
+    DUP4_ARG2(__lasx_xvilvl_d, src1, src0, src3, src2,                \
+              src5, src4, src7, src6, src0, src2, src4, src6);        \
+    DUP4_ARG2(__lasx_xvilvl_d, src9, src8, src11, src10,              \
+              src13, src12, src15, src14, src8, src10, src12, src14); \
+    DUP4_ARG1(__lasx_vext2xv_hu_bu, src0, src2, src4, src6,           \
+              src0, src2, src4, src6);                                \
+    DUP4_ARG1(__lasx_vext2xv_hu_bu, src8, src10, src12,               \
+              src14, src8, src10, src12, src14);                      \
+    DUP4_ARG2(__lasx_xvdp2_w_h, filter0, src0, filter1, src2,         \
+              filter2, src4, filter3, src6, src0, src1, src2, src3);  \
+    DUP4_ARG2(__lasx_xvdp2_w_h, filter4, src8, filter5, src10,        \
+              filter6, src12, filter7, src14, src4, src5, src6, src7);\
+    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
+    src1 = __lasx_xvhaddw_d_w(src1, src1);                            \
+    src2 = __lasx_xvhaddw_d_w(src2, src2);                            \
+    src3 = __lasx_xvhaddw_d_w(src3, src3);                            \
+    src4 = __lasx_xvhaddw_d_w(src4, src4);                            \
+    src5 = __lasx_xvhaddw_d_w(src5, src5);                            \
+    src6 = __lasx_xvhaddw_d_w(src6, src6);                            \
+    src7 = __lasx_xvhaddw_d_w(src7, src7);                            \
+    DUP4_ARG2(__lasx_xvpickev_w, src1, src0, src3, src2,              \
+              src5, src4, src7, src6, src0, src1, src2, src3);        \
+    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
+    src1 = __lasx_xvhaddw_d_w(src1, src1);                            \
+    src2 = __lasx_xvhaddw_d_w(src2, src2);                            \
+    src3 = __lasx_xvhaddw_d_w(src3, src3);                            \
+    src0 = __lasx_xvpickev_w(src1, src0);                             \
+    src1 = __lasx_xvpickev_w(src3, src2);                             \
+    src0 = __lasx_xvsrai_w(src0, _sh);                                \
+    src1 = __lasx_xvsrai_w(src1, _sh);                                \
+    src0 = __lasx_xvmin_w(src0, vmax);                                \
+    src1 = __lasx_xvmin_w(src1, vmax);                                \
+    src0 = __lasx_xvperm_w(src0, shuf);                               \
+    src1 = __lasx_xvperm_w(src1, shuf);                               \
+    src0 = __lasx_xvpickev_h(src1, src0);                             \
+    src0 = __lasx_xvpermi_d(src0, 0xd8);                              \
+    __lasx_xvst(src0, dst, 0);                                        \
+    filterPos += 16;                                                  \
+    filter    += 128;                                                 \
+    dst       += 16;                                                  \
+}
+
+#define SCALE_8_8(_sh)                                                \
+{                                                                     \
+    src0    = __lasx_xvldrepl_d(src + filterPos[0], 0);               \
+    src1    = __lasx_xvldrepl_d(src + filterPos[1], 0);               \
+    src2    = __lasx_xvldrepl_d(src + filterPos[2], 0);               \
+    src3    = __lasx_xvldrepl_d(src + filterPos[3], 0);               \
+    src4    = __lasx_xvldrepl_d(src + filterPos[4], 0);               \
+    src5    = __lasx_xvldrepl_d(src + filterPos[5], 0);               \
+    src6    = __lasx_xvldrepl_d(src + filterPos[6], 0);               \
+    src7    = __lasx_xvldrepl_d(src + filterPos[7], 0);               \
+    DUP4_ARG2(__lasx_xvld, filter, 0, filter, 32, filter, 64,         \
+              filter, 96, filter0, filter1, filter2, filter3);        \
+    filterPos += 8;                                                   \
+    filter    += 64;                                                  \
+    DUP4_ARG2(__lasx_xvilvl_d, src1, src0, src3, src2,                \
+              src5, src4, src7, src6, src0, src2, src4, src6);        \
+    DUP4_ARG1(__lasx_vext2xv_hu_bu, src0, src2, src4, src6,           \
+              src0, src2, src4, src6);                                \
+    DUP4_ARG2(__lasx_xvdp2_w_h, filter0, src0, filter1, src2,         \
+              filter2, src4, filter3, src6, src0, src1, src2,src3);   \
+    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
+    src1 = __lasx_xvhaddw_d_w(src1, src1);                            \
+    src2 = __lasx_xvhaddw_d_w(src2, src2);                            \
+    src3 = __lasx_xvhaddw_d_w(src3, src3);                            \
+    src0 = __lasx_xvpickev_w(src1, src0);                             \
+    src1 = __lasx_xvpickev_w(src3, src2);                             \
+    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
+    src1 = __lasx_xvhaddw_d_w(src1, src1);                            \
+    src0 = __lasx_xvpickev_w(src1, src0);                             \
+    src0 = __lasx_xvsrai_w(src0, _sh);                                \
+    src0 = __lasx_xvmin_w(src0, vmax);                                \
+    src0 = __lasx_xvperm_w(src0, shuf);                               \
+}
+
+#define SCALE_8_4(_sh)                                                    \
+{                                                                         \
+    src0    = __lasx_xvldrepl_d(src + filterPos[0], 0);                   \
+    src1    = __lasx_xvldrepl_d(src + filterPos[1], 0);                   \
+    src2    = __lasx_xvldrepl_d(src + filterPos[2], 0);                   \
+    src3    = __lasx_xvldrepl_d(src + filterPos[3], 0);                   \
+    filter0 = __lasx_xvld(filter, 0);                                     \
+    filter1 = __lasx_xvld(filter, 32);                                    \
+    filterPos += 4;                                                       \
+    filter    += 32;                                                      \
+    src0    = __lasx_xvilvl_d(src1, src0);                                \
+    src2    = __lasx_xvilvl_d(src3, src2);                                \
+    src0    = __lasx_vext2xv_hu_bu(src0);                                 \
+    src2    = __lasx_vext2xv_hu_bu(src2);                                 \
+    src0    = __lasx_xvdp2_w_h(src0, filter0);                            \
+    src1    = __lasx_xvdp2_w_h(src2, filter1);                            \
+    src0 = __lasx_xvhaddw_d_w(src0, src0);                                \
+    src1 = __lasx_xvhaddw_d_w(src1, src1);                                \
+    src0 = __lasx_xvpickev_w(src1, src0);                                 \
+    src0 = __lasx_xvhaddw_d_w(src0, src0);                                \
+    src0 = __lasx_xvpickev_w(src0, src0);                                 \
+    src0 = __lasx_xvsrai_w(src0, _sh);                                    \
+    src0 = __lasx_xvmin_w(src0, vmax);                                    \
+    src0 = __lasx_xvperm_w(src0, shuf);                                   \
+}
+
+#define SCALE_8_2(_sh)                                                \
+{                                                                     \
+    src0    = __lasx_xvldrepl_d(src + filterPos[0], 0);               \
+    src1    = __lasx_xvldrepl_d(src + filterPos[1], 0);               \
+    filter0 = __lasx_xvld(filter, 0);                                 \
+    src0 = __lasx_xvilvl_d(src1, src0);                               \
+    src0 = __lasx_vext2xv_hu_bu(src0);                                \
+    src0 = __lasx_xvdp2_w_h(filter0, src0);                           \
+    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
+    src0 = __lasx_xvhaddw_q_d(src0, src0);                            \
+    src0 = __lasx_xvsrai_w(src0, _sh);                                \
+    src0 = __lasx_xvmin_w(src0, vmax);                                \
+    dst[0] = __lasx_xvpickve2gr_w(src0, 0);                           \
+    dst[1] = __lasx_xvpickve2gr_w(src0, 4);                           \
+    filterPos += 2;                                                   \
+    filter    += 16;                                                  \
+    dst       += 2;                                                   \
+}
+
+#define SCALE_4_16(_sh)                                               \
+{                                                                     \
+    src0    = __lasx_xvldrepl_w(src + filterPos[0], 0);               \
+    src1    = __lasx_xvldrepl_w(src + filterPos[1], 0);               \
+    src2    = __lasx_xvldrepl_w(src + filterPos[2], 0);               \
+    src3    = __lasx_xvldrepl_w(src + filterPos[3], 0);               \
+    src4    = __lasx_xvldrepl_w(src + filterPos[4], 0);               \
+    src5    = __lasx_xvldrepl_w(src + filterPos[5], 0);               \
+    src6    = __lasx_xvldrepl_w(src + filterPos[6], 0);               \
+    src7    = __lasx_xvldrepl_w(src + filterPos[7], 0);               \
+    src8    = __lasx_xvldrepl_w(src + filterPos[8], 0);               \
+    src9    = __lasx_xvldrepl_w(src + filterPos[9], 0);               \
+    src10   = __lasx_xvldrepl_w(src + filterPos[10], 0);              \
+    src11   = __lasx_xvldrepl_w(src + filterPos[11], 0);              \
+    src12   = __lasx_xvldrepl_w(src + filterPos[12], 0);              \
+    src13   = __lasx_xvldrepl_w(src + filterPos[13], 0);              \
+    src14   = __lasx_xvldrepl_w(src + filterPos[14], 0);              \
+    src15   = __lasx_xvldrepl_w(src + filterPos[15], 0);              \
+    DUP4_ARG2(__lasx_xvld, filter, 0, filter, 32, filter, 64,         \
+              filter, 96, filter0, filter1, filter2, filter3);        \
+    DUP4_ARG2(__lasx_xvilvl_w, src1, src0, src3, src2, src5,          \
+              src4, src7, src6, src0, src2, src4, src6);              \
+    DUP4_ARG2(__lasx_xvilvl_w, src9, src8, src11, src10, src13,       \
+              src12, src15, src14, src8, src10, src12, src14);        \
+    DUP4_ARG2(__lasx_xvilvl_d, src2, src0, src6, src4, src10,         \
+                   src8, src14, src12, src0, src1, src2, src3);       \
+    DUP4_ARG1(__lasx_vext2xv_hu_bu, src0, src1, src2, src3,           \
+              src0, src1, src2, src3);                                \
+    DUP4_ARG2(__lasx_xvdp2_w_h, filter0, src0, filter1, src1,         \
+              filter2, src2, filter3, src3, src0, src1, src2, src3);  \
+    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
+    src1 = __lasx_xvhaddw_d_w(src1, src1);                            \
+    src2 = __lasx_xvhaddw_d_w(src2, src2);                            \
+    src3 = __lasx_xvhaddw_d_w(src3, src3);                            \
+    src0 = __lasx_xvpickev_w(src1, src0);                             \
+    src1 = __lasx_xvpickev_w(src3, src2);                             \
+    src0 = __lasx_xvsrai_w(src0, _sh);                                \
+    src1 = __lasx_xvsrai_w(src1, _sh);                                \
+    src0 = __lasx_xvmin_w(src0, vmax);                                \
+    src1 = __lasx_xvmin_w(src1, vmax);                                \
+    src0 = __lasx_xvpickev_h(src1, src0);                             \
+    src0 = __lasx_xvperm_w(src0, shuf);                               \
+    __lasx_xvst(src0, dst, 0);                                        \
+    filterPos += 16;                                                  \
+    filter    += 64;                                                  \
+    dst       += 16;                                                  \
+}
+
+#define SCALE_4_8(_sh)                                                    \
+{                                                                         \
+    src0    = __lasx_xvldrepl_w(src + filterPos[0], 0);                   \
+    src1    = __lasx_xvldrepl_w(src + filterPos[1], 0);                   \
+    src2    = __lasx_xvldrepl_w(src + filterPos[2], 0);                   \
+    src3    = __lasx_xvldrepl_w(src + filterPos[3], 0);                   \
+    src4    = __lasx_xvldrepl_w(src + filterPos[4], 0);                   \
+    src5    = __lasx_xvldrepl_w(src + filterPos[5], 0);                   \
+    src6    = __lasx_xvldrepl_w(src + filterPos[6], 0);                   \
+    src7    = __lasx_xvldrepl_w(src + filterPos[7], 0);                   \
+    filter0 = __lasx_xvld(filter, 0);                                     \
+    filter1 = __lasx_xvld(filter, 32);                                    \
+    filterPos += 8;                                                       \
+    filter    += 32;                                                      \
+    DUP4_ARG2(__lasx_xvilvl_w, src1, src0, src3, src2, src5,              \
+              src4, src7, src6, src0, src2, src4, src6);                  \
+    src0 = __lasx_xvilvl_d(src2, src0);                                   \
+    src1 = __lasx_xvilvl_d(src6, src4);                                   \
+                                                                          \
+    src0 = __lasx_vext2xv_hu_bu(src0);                                    \
+    src1 = __lasx_vext2xv_hu_bu(src1);                                    \
+    src0 = __lasx_xvdp2_w_h(filter0, src0);                               \
+    src1 = __lasx_xvdp2_w_h(filter1, src1);                               \
+    src0 = __lasx_xvhaddw_d_w(src0, src0);                                \
+    src1 = __lasx_xvhaddw_d_w(src1, src1);                                \
+    src0 = __lasx_xvpickev_w(src1, src0);                                 \
+    src0 = __lasx_xvsrai_w(src0, _sh);                                    \
+    src0 = __lasx_xvmin_w(src0, vmax);                                    \
+}
+
+#define SCALE_4_4(_sh)                                                \
+{                                                                     \
+    src0    = __lasx_xvldrepl_w(src + filterPos[0], 0);               \
+    src1    = __lasx_xvldrepl_w(src + filterPos[1], 0);               \
+    src2    = __lasx_xvldrepl_w(src + filterPos[2], 0);               \
+    src3    = __lasx_xvldrepl_w(src + filterPos[3], 0);               \
+    filter0 = __lasx_xvld(filter, 0);                                 \
+    filterPos += 4;                                                   \
+    filter    += 16;                                                  \
+    src0    = __lasx_xvilvl_w(src1, src0);                            \
+    src1    = __lasx_xvilvl_w(src3, src2);                            \
+                                                                      \
+    src0 = __lasx_xvilvl_d(src1, src0);                               \
+    src0 = __lasx_vext2xv_hu_bu(src0);                                \
+    src0 = __lasx_xvdp2_w_h(filter0, src0);                           \
+    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
+    src0 = __lasx_xvsrai_w(src0, _sh);                                \
+    src0 = __lasx_xvmin_w(src0, vmax);                                \
+    src0 = __lasx_xvpickev_w(src0, src0);                             \
+    src0 = __lasx_xvpermi_d(src0, 0xd8);                              \
+}
+
+#define SCALE_4_2(_sh)                                                \
+{                                                                     \
+    src0    = __lasx_xvldrepl_w(src + filterPos[0], 0);               \
+    src1    = __lasx_xvldrepl_w(src + filterPos[1], 0);               \
+    filter0 = __lasx_xvld(filter, 0);                                 \
+    src0 = __lasx_xvilvl_w(src1, src0);                               \
+    src0 = __lasx_vext2xv_hu_bu(src0);                                \
+    src0 = __lasx_xvdp2_w_h(filter0, src0);                           \
+    src0 = __lasx_xvhaddw_d_w(src0, src0);                            \
+    src0 = __lasx_xvsrai_w(src0, _sh);                                \
+    src0 = __lasx_xvmin_w(src0, vmax);                                \
+    dst[0] = __lasx_xvpickve2gr_w(src0, 0);                           \
+    dst[1] = __lasx_xvpickve2gr_w(src0, 2);                           \
+    filterPos += 2;                                                   \
+    filter    += 8;                                                   \
+    dst       += 2;                                                   \
+}
+
+#define SCALE_16                                                      \
+{                                                                     \
+    int dex  = j << 1;                                                \
+    src0     = __lasx_xvldrepl_d((srcPos1 + j), 0);                   \
+    src1     = __lasx_xvldrepl_d((srcPos2 + j), 0);                   \
+    src2     = __lasx_xvldrepl_d((srcPos3 + j), 0);                   \
+    src3     = __lasx_xvldrepl_d((srcPos4 + j), 0);                   \
+    DUP4_ARG2(__lasx_xvldx, filterStart1, dex, filterStart2, dex,     \
+              filterStart3, dex, filterStart4, dex, filter0,          \
+              filter1, filter2, filter3);                             \
+    src0     = __lasx_xvpermi_q(src0, src1, 0x02);                    \
+    src1     = __lasx_xvpermi_q(src2, src3, 0x02);                    \
+    filter0  = __lasx_xvpermi_q(filter0, filter1, 0x02);              \
+    filter1  = __lasx_xvpermi_q(filter2, filter3, 0x02);              \
+    src0     = __lasx_xvilvl_b(zero, src0);                           \
+    src1     = __lasx_xvilvl_b(zero, src1);                           \
+    out0     = __lasx_xvdp2_w_h(filter0, src0);                       \
+    out1     = __lasx_xvdp2_w_h(filter1, src1);                       \
+    src0     = __lasx_xvhaddw_d_w(out0, out0);                        \
+    src1     = __lasx_xvhaddw_d_w(out1, out1);                        \
+    out0     = __lasx_xvpackev_d(src1, src0);                         \
+    out1     = __lasx_xvpackod_d(src1, src0);                         \
+    out0     = __lasx_xvadd_w(out0, out1);                            \
+    out      = __lasx_xvadd_w(out, out0);                             \
+}
+
+void ff_hscale_8_to_15_lasx(SwsContext *c, int16_t *dst, int dstW,
+                            const uint8_t *src, const int16_t *filter,
+                            const int32_t *filterPos, int filterSize)
+{
+    int i;
+    int max = (1 << 15) - 1;
+
+    if (filterSize == 8) {
+        __m256i src0, src1, src2, src3, src4, src5, src6, src7;
+        __m256i src8, src9, src10, src11, src12, src13, src14, src15;
+        __m256i filter0, filter1, filter2, filter3;
+        __m256i filter4, filter5, filter6, filter7;
+        __m256i vmax = __lasx_xvreplgr2vr_w(max);
+        __m256i shuf = {0x0000000400000000, 0x0000000500000001,
+                        0x0000000600000002, 0x0000000700000003};
+        int len = dstW >> 4;
+        int res = dstW & 15;
+        while (len--) {
+            SCALE_8_16(7);
+        }
+        if (res & 8) {
+            SCALE_8_8(7);
+            src0 = __lasx_xvpickev_h(src0, src0);
+            __lasx_xvstelm_d(src0, dst, 0, 0);
+            __lasx_xvstelm_d(src0, dst, 8, 2);
+            dst       += 8;
+        }
+        if (res & 4) {
+            SCALE_8_4(7);
+            src0 = __lasx_xvpickev_h(src0, src0);
+            __lasx_xvstelm_d(src0, dst, 0, 0);
+            dst       += 4;
+        }
+        if (res & 2) {
+            SCALE_8_2(7);
+        }
+        if (res & 1) {
+            int val = 0;
+            src0    = __lasx_xvldrepl_d(src + filterPos[0], 0);
+            filter0 = __lasx_xvld(filter, 0);
+            src0 = __lasx_vext2xv_hu_bu(src0);
+            src0 = __lasx_xvdp2_w_h(filter0, src0);
+            src0    = __lasx_xvhaddw_d_w(src0, src0);
+            src0    = __lasx_xvhaddw_q_d(src0, src0);
+            val     = __lasx_xvpickve2gr_w(src0, 0);
+            dst[0]  = FFMIN(val >> 7, max);
+        }
+    } else if (filterSize == 4) {
+        __m256i src0, src1, src2, src3, src4, src5, src6, src7;
+        __m256i src8, src9, src10, src11, src12, src13, src14, src15;
+        __m256i filter0, filter1, filter2, filter3;
+        __m256i vmax = __lasx_xvreplgr2vr_w(max);
+        __m256i shuf = {0x0000000400000000, 0x0000000500000001,
+                        0x0000000600000002, 0x0000000700000003};
+        int len = dstW >> 4;
+        int res = dstW & 15;
+        while (len--) {
+            SCALE_4_16(7);
+        }
+        if (res & 8) {
+            SCALE_4_8(7);
+            src0 = __lasx_xvpickev_h(src1, src0);
+            src0 = __lasx_xvperm_w(src0, shuf);
+            __lasx_xvstelm_d(src0, dst, 0, 0);
+            __lasx_xvstelm_d(src0, dst, 8, 1);
+            dst       += 8;
+        }
+        if (res & 4) {
+            SCALE_4_4(7);
+            src0 = __lasx_xvpickev_h(src0, src0);
+            __lasx_xvstelm_d(src0, dst, 0, 0);
+            dst       += 4;
+        }
+        if (res & 2) {
+            SCALE_4_2(7);
+        }
+        if (res & 1) {
+            int val = 0;
+            const uint8_t *srcPos = src + filterPos[0];
+
+            for (int j = 0; j < filterSize; j++) {
+                val += ((int)srcPos[j]) * filter[j];
+            }
+            dst[0] = FFMIN(val >> 7, max);
+        }
+    } else if (filterSize > 8) {
+        int filterlen = filterSize - 7;
+        int len = dstW >> 2;
+        int res = dstW & 3;
+        __m256i zero = __lasx_xvldi(0);
+
+        while (len--) {
+            __m256i src0, src1, src2, src3;
+            __m256i filter0, filter1, filter2, filter3, out0, out1;
+            __m256i out = zero;
+            const uint8_t *srcPos1 = src + filterPos[0];
+            const uint8_t *srcPos2 = src + filterPos[1];
+            const uint8_t *srcPos3 = src + filterPos[2];
+            const uint8_t *srcPos4 = src + filterPos[3];
+            const int16_t *filterStart1 = filter;
+            const int16_t *filterStart2 = filterStart1 + filterSize;
+            const int16_t *filterStart3 = filterStart2 + filterSize;
+            const int16_t *filterStart4 = filterStart3 + filterSize;
+            int j, val1 = 0, val2 = 0, val3 = 0, val4 = 0;
+
+            for (j = 0; j < filterlen; j += 8) {
+                SCALE_16
+            }
+            val1 = __lasx_xvpickve2gr_w(out, 0);
+            val2 = __lasx_xvpickve2gr_w(out, 4);
+            val3 = __lasx_xvpickve2gr_w(out, 2);
+            val4 = __lasx_xvpickve2gr_w(out, 6);
+            for (; j < filterSize; j++) {
+                val1 += ((int)srcPos1[j]) * filterStart1[j];
+                val2 += ((int)srcPos2[j]) * filterStart2[j];
+                val3 += ((int)srcPos3[j]) * filterStart3[j];
+                val4 += ((int)srcPos4[j]) * filterStart4[j];
+            }
+            dst[0] = FFMIN(val1 >> 7, max);
+            dst[1] = FFMIN(val2 >> 7, max);
+            dst[2] = FFMIN(val3 >> 7, max);
+            dst[3] = FFMIN(val4 >> 7, max);
+            dst       += 4;
+            filterPos += 4;
+            filter     = filterStart4 + filterSize;
+        }
+        for(i = 0; i < res; i++) {
+            int j, val = 0;
+            const uint8_t *srcPos = src + filterPos[i];
+            __m256i src1, filter0, out0;
+
+            for (j = 0; j < filterlen; j += 8) {
+                src1   = __lasx_xvldrepl_d((srcPos + j), 0);
+                filter0 = __lasx_xvld(filter + j, 0);
+                src1 = __lasx_xvilvl_b(zero, src1);
+                out0 = __lasx_xvdp2_w_h(filter0, src1);
+                out0 = __lasx_xvhaddw_d_w(out0, out0);
+                out0 = __lasx_xvhaddw_q_d(out0, out0);
+                val += __lasx_xvpickve2gr_w(out0, 0);
+            }
+            for (; j < filterSize; j++) {
+                val += ((int)srcPos[j]) * filter[j];
+            }
+            dst[i]  = FFMIN(val >> 7, max);
+            filter += filterSize;
+        }
+    } else {
+        for (i = 0; i < dstW; i++) {
+            int val = 0;
+            const uint8_t *srcPos = src + filterPos[i];
+
+            for (int j = 0; j < filterSize; j++) {
+                val += ((int)srcPos[j]) * filter[j];
+            }
+            dst[i]  = FFMIN(val >> 7, max);
+            filter += filterSize;
+        }
+    }
+}
+
+void ff_hscale_8_to_19_lasx(SwsContext *c, int16_t *_dst, int dstW,
+                            const uint8_t *src, const int16_t *filter,
+                            const int32_t *filterPos, int filterSize)
+{
+    int i;
+    int max = (1 << 19) - 1;
+    int32_t *dst = (int32_t *) _dst;
+
+    if (filterSize == 8) {
+        __m256i src0, src1, src2, src3, src4, src5, src6, src7;
+        __m256i filter0, filter1, filter2, filter3;
+        __m256i vmax = __lasx_xvreplgr2vr_w(max);
+        __m256i shuf = {0x0000000400000000, 0x0000000500000001,
+                        0x0000000600000002, 0x0000000700000003};
+        int len = dstW >> 3;
+        int res = dstW & 7;
+        while (len--) {
+            SCALE_8_8(3);
+            __lasx_xvst(src0, dst, 0);
+            dst       += 8;
+        }
+        if (res & 4) {
+            SCALE_8_4(3);
+            __lasx_xvstelm_d(src0, dst, 0, 0);
+            __lasx_xvstelm_d(src0, dst, 8, 1);
+            dst       += 4;
+        }
+        if (res & 2) {
+            SCALE_8_2(3);
+        }
+        if (res & 1) {
+            int val = 0;
+            __m256i src0, filter0, out0;
+
+            src0    = __lasx_xvldrepl_d(src + filterPos[0], 0);
+            filter0 = __lasx_xvld(filter, 0);
+            src0 = __lasx_vext2xv_hu_bu(src0);
+            out0 = __lasx_xvdp2_w_h(filter0, src0);
+            out0    = __lasx_xvhaddw_d_w(out0, out0);
+            out0    = __lasx_xvhaddw_q_d(out0, out0);
+            val     = __lasx_xvpickve2gr_w(out0, 0);
+            dst[0]  = FFMIN(val >> 3, max);
+        }
+    } else if (filterSize == 4) {
+        __m256i src0, src1, src2, src3, src4, src5, src6, src7;
+        __m256i filter0, filter1;
+        __m256i vmax = __lasx_xvreplgr2vr_w(max);
+        __m256i shuf = {0x0000000100000000, 0x0000000500000004,
+                        0x0000000300000002, 0x0000000700000006};
+        int len = dstW >> 3;
+        int res = dstW & 7;
+        while (len--) {
+            SCALE_4_8(3);
+            src0 = __lasx_xvperm_w(src0, shuf);
+            __lasx_xvst(src0, dst, 0);
+            dst       += 8;
+        }
+        if (res & 4) {
+            SCALE_4_4(3);
+            __lasx_xvstelm_d(src0, dst, 0, 0);
+            __lasx_xvstelm_d(src0, dst, 8, 1);
+            dst       += 4;
+        }
+        if (res & 2) {
+            SCALE_4_2(3);
+        }
+        if (res & 1) {
+            int val = 0;
+            const uint8_t *srcPos = src + filterPos[0];
+
+            for (int j = 0; j < filterSize; j++) {
+                val += ((int)srcPos[j]) * filter[j];
+            }
+            dst[0] = FFMIN(val >> 3, max);
+        }
+    } else if (filterSize > 8) {
+        int len = dstW >> 2;
+        int res = dstW & 3;
+        int filterlen = filterSize - 7;
+        __m256i zero = __lasx_xvldi(0);
+
+        while (len--) {
+            __m256i src0, src1, src2, src3;
+            __m256i filter0, filter1, filter2, filter3, out0, out1;
+            __m256i out = zero;
+            const uint8_t *srcPos1 = src + filterPos[0];
+            const uint8_t *srcPos2 = src + filterPos[1];
+            const uint8_t *srcPos3 = src + filterPos[2];
+            const uint8_t *srcPos4 = src + filterPos[3];
+            const int16_t *filterStart1 = filter;
+            const int16_t *filterStart2 = filterStart1 + filterSize;
+            const int16_t *filterStart3 = filterStart2 + filterSize;
+            const int16_t *filterStart4 = filterStart3 + filterSize;
+            int j, val1 = 0, val2 = 0, val3 = 0, val4 = 0;
+
+            for (j = 0; j < filterlen; j += 8) {
+                SCALE_16
+            }
+            val1 = __lasx_xvpickve2gr_w(out, 0);
+            val2 = __lasx_xvpickve2gr_w(out, 4);
+            val3 = __lasx_xvpickve2gr_w(out, 2);
+            val4 = __lasx_xvpickve2gr_w(out, 6);
+            for (; j < filterSize; j++) {
+                val1 += ((int)srcPos1[j]) * filterStart1[j];
+                val2 += ((int)srcPos2[j]) * filterStart2[j];
+                val3 += ((int)srcPos3[j]) * filterStart3[j];
+                val4 += ((int)srcPos4[j]) * filterStart4[j];
+            }
+            dst[0] = FFMIN(val1 >> 3, max);
+            dst[1] = FFMIN(val2 >> 3, max);
+            dst[2] = FFMIN(val3 >> 3, max);
+            dst[3] = FFMIN(val4 >> 3, max);
+            dst       += 4;
+            filterPos += 4;
+            filter     = filterStart4 + filterSize;
+        }
+        for (i = 0; i < res; i++) {
+            int j, val = 0;
+            const uint8_t *srcPos = src + filterPos[i];
+            __m256i src1, filter0, out0;
+
+            for (j = 0; j < filterlen; j += 8) {
+                src1   = __lasx_xvldrepl_d((srcPos + j), 0);
+                filter0 = __lasx_xvld(filter + j, 0);
+                src1 = __lasx_xvilvl_b(zero, src1);
+                out0 = __lasx_xvdp2_w_h(filter0, src1);
+                out0 = __lasx_xvhaddw_d_w(out0, out0);
+                out0 = __lasx_xvhaddw_q_d(out0, out0);
+                val += __lasx_xvpickve2gr_w(out0, 0);
+            }
+            for (; j < filterSize; j++) {
+                val += ((int)srcPos[j]) * filter[j];
+            }
+            dst[i] = FFMIN(val >> 3, max);
+            filter += filterSize;
+        }
+    } else {
+        for (i = 0; i < dstW; i++) {
+            int val = 0;
+            const uint8_t *srcPos = src + filterPos[i];
+
+            for (int j = 0; j < filterSize; j++) {
+                val += ((int)srcPos[j]) * filter[j];
+            }
+            dst[i]  = FFMIN(val >> 3, max);
+            filter += filterSize;
+        }
+    }
+}
+
+#undef SCALE_16
+
+#define SCALE_8                                                              \
+{                                                                            \
+    __m256i src0, src1, src2, src3, filter0, filter1, out0, out1;            \
+    DUP4_ARG2(__lasx_xvld, src + filterPos[0], 0, src + filterPos[1], 0,     \
+              src + filterPos[2], 0, src + filterPos[3], 0, src0, src1, src2,\
+              src3);                                                         \
+    filter0 = __lasx_xvld(filter, 0);                                        \
+    filter1 = __lasx_xvld(filter, 32);                                       \
+    src0    = __lasx_xvpermi_q(src0, src1, 0x02);                            \
+    src2    = __lasx_xvpermi_q(src2, src3, 0x02);                            \
+    out0    = __lasx_xvdp2_w_hu_h(src0, filter0);                            \
+    out1    = __lasx_xvdp2_w_hu_h(src2, filter1);                            \
+    src0    = __lasx_xvhaddw_d_w(out0, out0);                                \
+    src1    = __lasx_xvhaddw_d_w(out1, out1);                                \
+    out0    = __lasx_xvpackev_d(src1, src0);                                 \
+    out1    = __lasx_xvpackod_d(src1, src0);                                 \
+    out0    = __lasx_xvadd_w(out0, out1);                                    \
+    out0    = __lasx_xvsra_w(out0, shift);                                   \
+    out0    = __lasx_xvmin_w(out0, v_max);                                   \
+    dst[0]  = __lasx_xvpickve2gr_w(out0, 0);                                 \
+    dst[1]  = __lasx_xvpickve2gr_w(out0, 4);                                 \
+    dst[2]  = __lasx_xvpickve2gr_w(out0, 2);                                 \
+    dst[3]  = __lasx_xvpickve2gr_w(out0, 6);                                 \
+    filterPos += 4;                                                          \
+    filter += 32;                                                            \
+    dst += 4;                                                                \
+}
+
+#define SCALE_16                                                             \
+{                                                                            \
+    int dex = j << 1;                                                        \
+    DUP4_ARG2(__lasx_xvldx, srcPos1, dex, srcPos2, dex, srcPos3, dex,        \
+              srcPos4, dex, src0, src1, src2, src3);                         \
+    DUP4_ARG2(__lasx_xvldx, filterStart1, dex, filterStart2, dex,            \
+              filterStart3, dex, filterStart4, dex, filter0,                 \
+              filter1, filter2, filter3);                                    \
+    src0     = __lasx_xvpermi_q(src0, src1, 0x02);                           \
+    src1     = __lasx_xvpermi_q(src2, src3, 0x02);                           \
+    filter0  = __lasx_xvpermi_q(filter0, filter1, 0x02);                     \
+    filter1  = __lasx_xvpermi_q(filter2, filter3, 0x02);                     \
+    out0     = __lasx_xvdp2_w_hu_h(src0, filter0);                           \
+    out1     = __lasx_xvdp2_w_hu_h(src1, filter1);                           \
+    src0     = __lasx_xvhaddw_d_w(out0, out0);                               \
+    src1     = __lasx_xvhaddw_d_w(out1, out1);                               \
+    out0     = __lasx_xvpackev_d(src1, src0);                                \
+    out1     = __lasx_xvpackod_d(src1, src0);                                \
+    out0     = __lasx_xvadd_w(out0, out1);                                   \
+    out      = __lasx_xvadd_w(out, out0);                                    \
+}
+
+void ff_hscale_16_to_15_lasx(SwsContext *c, int16_t *dst, int dstW,
+                             const uint8_t *_src, const int16_t *filter,
+                             const int32_t *filterPos, int filterSize)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
+    int i;
+    const uint16_t *src = (const uint16_t *) _src;
+    int sh              = desc->comp[0].depth - 1;
+    int max = (1 << 15) - 1;
+    int len = dstW >> 2;
+    int res = dstW & 3;
+    __m256i shift;
+    __m256i zero = __lasx_xvldi(0);
+
+    if (sh < 15) {
+        sh = isAnyRGB(c->srcFormat) || c->srcFormat==AV_PIX_FMT_PAL8 ? 13 :
+                      (desc->comp[0].depth - 1);
+    } else if (desc->flags && AV_PIX_FMT_FLAG_FLOAT) {
+        sh = 15;
+    }
+    shift = __lasx_xvreplgr2vr_w(sh);
+
+    if (filterSize == 8) {
+        __m256i v_max = __lasx_xvreplgr2vr_w(max);
+        for (i = 0; i < len; i++) {
+            SCALE_8
+        }
+        for (i = 0; i < res; i++) {
+            int val = 0;
+            __m256i src0, filter0, out0;
+
+            src0    = __lasx_xvld(src + filterPos[i], 0);
+            filter0 = __lasx_xvld(filter, 0);
+            out0 = __lasx_xvdp2_w_hu_h(src0, filter0);
+            out0    = __lasx_xvhaddw_d_w(out0, out0);
+            out0    = __lasx_xvhaddw_q_d(out0, out0);
+            val     = __lasx_xvpickve2gr_w(out0, 0);
+            dst[i]  = FFMIN(val >> sh, max);
+            filter += 8;
+        }
+    } else if (filterSize == 4) {
+        __m256i v_max = __lasx_xvreplgr2vr_w(max);
+        for (i = 0; i < len; i++) {
+            __m256i src1, src2, src3, src4, src0, filter0, out0;
+
+            src1 = __lasx_xvldrepl_d(src + filterPos[0], 0);
+            src2 = __lasx_xvldrepl_d(src + filterPos[1], 0);
+            src3 = __lasx_xvldrepl_d(src + filterPos[2], 0);
+            src4 = __lasx_xvldrepl_d(src + filterPos[3], 0);
+            filter0 = __lasx_xvld(filter, 0);
+            src1 = __lasx_xvextrins_d(src1, src2, 0x10);
+            src3 = __lasx_xvextrins_d(src3, src4, 0x10);
+            src0 = __lasx_xvpermi_q(src1, src3, 0x02);
+            out0 = __lasx_xvdp2_w_hu_h(src0, filter0);
+            out0 = __lasx_xvhaddw_d_w(out0, out0);
+            out0 = __lasx_xvsra_w(out0, shift);
+            out0 = __lasx_xvmin_w(out0, v_max);
+            dst[0] = __lasx_xvpickve2gr_w(out0, 0);
+            dst[1] = __lasx_xvpickve2gr_w(out0, 2);
+            dst[2] = __lasx_xvpickve2gr_w(out0, 4);
+            dst[3] = __lasx_xvpickve2gr_w(out0, 6);
+            dst       += 4;
+            filterPos += 4;
+            filter    += 16;
+        }
+        for (i = 0; i < res; i++) {
+            int val = 0;
+            const uint16_t *srcPos = src + filterPos[i];
+
+            for (int j = 0; j < filterSize; j++) {
+                val += ((int)srcPos[j]) * filter[j];
+            }
+            dst[i]  = FFMIN(val >> sh, max);
+            filter += 4;
+        }
+    } else if (filterSize > 8) {
+        int filterlen = filterSize - 7;
+
+        for (i = 0; i < len; i++) {
+            __m256i src0, src1, src2, src3;
+            __m256i filter0, filter1, filter2, filter3, out0, out1;
+            __m256i out = zero;
+            const uint16_t *srcPos1 = src + filterPos[0];
+            const uint16_t *srcPos2 = src + filterPos[1];
+            const uint16_t *srcPos3 = src + filterPos[2];
+            const uint16_t *srcPos4 = src + filterPos[3];
+            const int16_t *filterStart1 = filter;
+            const int16_t *filterStart2 = filterStart1 + filterSize;
+            const int16_t *filterStart3 = filterStart2 + filterSize;
+            const int16_t *filterStart4 = filterStart3 + filterSize;
+            int j, val1 = 0, val2 = 0, val3 = 0, val4 = 0;
+
+            for (j = 0; j < filterlen; j += 8) {
+                SCALE_16
+            }
+            val1 = __lasx_xvpickve2gr_w(out, 0);
+            val2 = __lasx_xvpickve2gr_w(out, 4);
+            val3 = __lasx_xvpickve2gr_w(out, 2);
+            val4 = __lasx_xvpickve2gr_w(out, 6);
+            for (; j < filterSize; j++) {
+                val1 += ((int)srcPos1[j]) * filterStart1[j];
+                val2 += ((int)srcPos2[j]) * filterStart2[j];
+                val3 += ((int)srcPos3[j]) * filterStart3[j];
+                val4 += ((int)srcPos4[j]) * filterStart4[j];
+            }
+            dst[0] = FFMIN(val1 >> sh, max);
+            dst[1] = FFMIN(val2 >> sh, max);
+            dst[2] = FFMIN(val3 >> sh, max);
+            dst[3] = FFMIN(val4 >> sh, max);
+            dst       += 4;
+            filterPos += 4;
+            filter     = filterStart4 + filterSize;
+        }
+        for (i = 0; i < res; i++) {
+            int j, val = 0;
+            const uint16_t *srcPos      = src + filterPos[i];
+            __m256i src0, filter0, out0;
+
+            for (j = 0; j < filterlen; j += 8) {
+                int dex = j << 1;
+                src0    = __lasx_xvldx(srcPos, dex);
+                filter0 = __lasx_xvldx(filter, dex);
+                out0 = __lasx_xvdp2_w_hu_h(src0, filter0);
+                out0    = __lasx_xvhaddw_d_w(out0, out0);
+                out0    = __lasx_xvhaddw_q_d(out0, out0);
+                val    += __lasx_xvpickve2gr_w(out0, 0);
+            }
+            for (; j < filterSize; j++) {
+                val += ((int)srcPos[j]) * filter[j];
+            }
+            dst[i]  = FFMIN(val >> sh, max);
+            filter += filterSize;
+        }
+    } else {
+        for (i = 0; i < dstW; i++) {
+            int val = 0;
+            const uint16_t *srcPos = src + filterPos[i];
+
+            for (int j = 0; j < filterSize; j++) {
+                val += ((int)srcPos[j]) * filter[j];
+            }
+            dst[i]  = FFMIN(val >> sh, max);
+            filter += filterSize;
+        }
+    }
+}
+
+void ff_hscale_16_to_19_lasx(SwsContext *c, int16_t *_dst, int dstW,
+                             const uint8_t *_src, const int16_t *filter,
+                             const int32_t *filterPos, int filterSize)
+{
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
+    int i;
+    int32_t *dst        = (int32_t *) _dst;
+    const uint16_t *src = (const uint16_t *) _src;
+    int sh              = desc->comp[0].depth - 5;
+    int max = (1 << 19) - 1;
+    int len = dstW >> 2;
+    int res = dstW & 3;
+    __m256i shift;
+    __m256i zero = __lasx_xvldi(0);
+
+    if ((isAnyRGB(c->srcFormat) || c->srcFormat == AV_PIX_FMT_PAL8)
+         && desc->comp[0].depth<16) {
+        sh = 9;
+    } else if (desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
+        sh = 11;
+    }
+    shift = __lasx_xvreplgr2vr_w(sh);
+
+    if (filterSize == 8) {
+        __m256i v_max = __lasx_xvreplgr2vr_w(max);
+        for (i = 0; i < len; i++) {
+            SCALE_8
+        }
+        for (i = 0; i < res; i++) {
+            int val = 0;
+            __m256i src0, filter0, out0;
+
+            src0 = __lasx_xvld(src + filterPos[i], 0);
+            filter0 = __lasx_xvld(filter, 0);
+            out0 = __lasx_xvdp2_w_hu_h(src0, filter0);
+            out0 = __lasx_xvhaddw_d_w(out0, out0);
+            out0 = __lasx_xvhaddw_q_d(out0, out0);
+            val  = __lasx_xvpickve2gr_w(out0, 0);
+            dst[i] = FFMIN(val >> sh, max);
+            filter += 8;
+        }
+    } else if (filterSize == 4) {
+        __m256i v_max = __lasx_xvreplgr2vr_w(max);
+        for (i = 0; i < len; i++) {
+            __m256i src1, src2, src3, src4, src0, filter0, out0;
+
+            src1 = __lasx_xvldrepl_d(src + filterPos[0], 0);
+            src2 = __lasx_xvldrepl_d(src + filterPos[1], 0);
+            src3 = __lasx_xvldrepl_d(src + filterPos[2], 0);
+            src4 = __lasx_xvldrepl_d(src + filterPos[3], 0);
+            filter0 = __lasx_xvld(filter, 0);
+            src1 = __lasx_xvextrins_d(src1, src2, 0x10);
+            src3 = __lasx_xvextrins_d(src3, src4, 0x10);
+            src0 = __lasx_xvpermi_q(src1, src3, 0x02);
+            out0 = __lasx_xvdp2_w_hu_h(src0, filter0);
+            out0 = __lasx_xvhaddw_d_w(out0, out0);
+            out0 = __lasx_xvsra_w(out0, shift);
+            out0 = __lasx_xvmin_w(out0, v_max);
+            dst[0] = __lasx_xvpickve2gr_w(out0, 0);
+            dst[1] = __lasx_xvpickve2gr_w(out0, 2);
+            dst[2] = __lasx_xvpickve2gr_w(out0, 4);
+            dst[3] = __lasx_xvpickve2gr_w(out0, 6);
+            dst       += 4;
+            filterPos += 4;
+            filter    += 16;
+        }
+        for (i = 0; i < res; i++) {
+            int val = 0;
+            const uint16_t *srcPos = src + filterPos[i];
+
+            for (int j = 0; j < filterSize; j++) {
+                val += ((int)srcPos[j]) * filter[j];
+            }
+            dst[i]  = FFMIN(val >> sh, max);
+            filter += 4;
+        }
+    } else if (filterSize > 8) {
+        int filterlen = filterSize - 7;
+
+        for (i = 0; i < len; i ++) {
+            __m256i src0, src1, src2, src3;
+            __m256i filter0, filter1, filter2, filter3, out0, out1;
+            __m256i out = zero;
+            const uint16_t *srcPos1 = src + filterPos[0];
+            const uint16_t *srcPos2 = src + filterPos[1];
+            const uint16_t *srcPos3 = src + filterPos[2];
+            const uint16_t *srcPos4 = src + filterPos[3];
+            const int16_t *filterStart1 = filter;
+            const int16_t *filterStart2 = filterStart1 + filterSize;
+            const int16_t *filterStart3 = filterStart2 + filterSize;
+            const int16_t *filterStart4 = filterStart3 + filterSize;
+            int j, val1 = 0, val2 = 0, val3 = 0, val4 = 0;
+
+            for (j = 0; j < filterlen; j += 8) {
+                SCALE_16
+            }
+            val1 = __lasx_xvpickve2gr_w(out, 0);
+            val2 = __lasx_xvpickve2gr_w(out, 4);
+            val3 = __lasx_xvpickve2gr_w(out, 2);
+            val4 = __lasx_xvpickve2gr_w(out, 6);
+            for (; j < filterSize; j++) {
+                val1 += ((int)srcPos1[j]) * filterStart1[j];
+                val2 += ((int)srcPos2[j]) * filterStart2[j];
+                val3 += ((int)srcPos3[j]) * filterStart3[j];
+                val4 += ((int)srcPos4[j]) * filterStart4[j];
+            }
+            dst[0] = FFMIN(val1 >> sh, max);
+            dst[1] = FFMIN(val2 >> sh, max);
+            dst[2] = FFMIN(val3 >> sh, max);
+            dst[3] = FFMIN(val4 >> sh, max);
+            dst       += 4;
+            filterPos += 4;
+            filter     = filterStart4 + filterSize;
+        }
+        for (i = 0; i < res; i++) {
+            int j, val = 0;
+            const uint16_t *srcPos      = src + filterPos[i];
+            __m256i src0, filter0, out0;
+
+            for (j = 0; j < filterlen; j += 8) {
+                int dex = j << 1;
+                src0 = __lasx_xvldx(srcPos, dex);
+                filter0 = __lasx_xvldx(filter, dex);
+                out0 = __lasx_xvdp2_w_hu_h(src0, filter0);
+                out0    = __lasx_xvhaddw_d_w(out0, out0);
+                out0    = __lasx_xvhaddw_q_d(out0, out0);
+                val    += __lasx_xvpickve2gr_w(out0, 0);
+            }
+            for (; j < filterSize; j++) {
+                val += ((int)srcPos[j]) * filter[j];
+            }
+            dst[i]  = FFMIN(val >> sh, max);
+            filter += filterSize;
+        }
+    } else {
+        for (i = 0; i < dstW; i++) {
+            int val = 0;
+            const uint16_t *srcPos = src + filterPos[i];
+
+            for (int j = 0; j < filterSize; j++) {
+                val += ((int)srcPos[j]) * filter[j];
+            }
+            dst[i]  = FFMIN(val >> sh, max);
+            filter += filterSize;
+        }
+    }
+}
+
+#undef SCALE_8
+#undef SCALE_16
diff --git a/libswscale/loongarch/swscale_loongarch.h b/libswscale/loongarch/swscale_loongarch.h
new file mode 100644
index 0000000000..67e24d544c
--- /dev/null
+++ b/libswscale/loongarch/swscale_loongarch.h
@@ -0,0 +1,50 @@ 
+/*
+ * Copyright (C) 2022 Loongson Technology Corporation Limited
+ * Contributed by Hao Chen(chenhao@loongson.cn)
+ *
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg 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.
+ *
+ * FFmpeg 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 FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef SWSCALE_LOONGARCH_SWSCALE_LOONGARCH_H
+#define SWSCALE_LOONGARCH_SWSCALE_LOONGARCH_H
+
+#include "libswscale/swscale.h"
+#include "libswscale/swscale_internal.h"
+
+void ff_hscale_8_to_15_lasx(SwsContext *c, int16_t *dst, int dstW,
+                            const uint8_t *src, const int16_t *filter,
+                            const int32_t *filterPos, int filterSize);
+
+void ff_hscale_8_to_19_lasx(SwsContext *c, int16_t *_dst, int dstW,
+                            const uint8_t *src, const int16_t *filter,
+                            const int32_t *filterPos, int filterSize);
+
+void ff_hscale_16_to_19_lasx(SwsContext *c, int16_t *_dst, int dstW,
+                             const uint8_t *_src, const int16_t *filter,
+                             const int32_t *filterPos, int filterSize);
+
+void ff_hscale_16_to_15_lasx(SwsContext *c, int16_t *dst, int dstW,
+                             const uint8_t *_src, const int16_t *filter,
+                             const int32_t *filterPos, int filterSize);
+
+void planar_rgb_to_uv_lasx(uint8_t *_dstU, uint8_t *_dstV, const uint8_t *src[4],
+                           int width, int32_t *rgb2yuv);
+
+void planar_rgb_to_y_lasx(uint8_t *_dst, const uint8_t *src[4], int width,
+                          int32_t *rgb2yuv);
+
+#endif /* SWSCALE_LOONGARCH_SWSCALE_LOONGARCH_H */
diff --git a/libswscale/swscale.c b/libswscale/swscale.c
index 7b40f49da4..367d045a02 100644
--- a/libswscale/swscale.c
+++ b/libswscale/swscale.c
@@ -598,6 +598,8 @@  void ff_sws_init_scale(SwsContext *c)
     ff_sws_init_swscale_aarch64(c);
 #elif ARCH_ARM
     ff_sws_init_swscale_arm(c);
+#elif ARCH_LOONGARCH64
+    ff_sws_init_swscale_loongarch(c);
 #endif
 }
 
diff --git a/libswscale/swscale_internal.h b/libswscale/swscale_internal.h
index 6c14ce8536..abeebbb002 100644
--- a/libswscale/swscale_internal.h
+++ b/libswscale/swscale_internal.h
@@ -698,6 +698,7 @@  av_cold void ff_sws_init_range_convert(SwsContext *c);
 
 SwsFunc ff_yuv2rgb_init_x86(SwsContext *c);
 SwsFunc ff_yuv2rgb_init_ppc(SwsContext *c);
+SwsFunc ff_yuv2rgb_init_loongarch(SwsContext *c);
 
 static av_always_inline int is16BPS(enum AVPixelFormat pix_fmt)
 {
@@ -983,6 +984,7 @@  void ff_sws_init_swscale_vsx(SwsContext *c);
 void ff_sws_init_swscale_x86(SwsContext *c);
 void ff_sws_init_swscale_aarch64(SwsContext *c);
 void ff_sws_init_swscale_arm(SwsContext *c);
+void ff_sws_init_swscale_loongarch(SwsContext *c);
 
 void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth,
                        const uint8_t *src, int srcW, int xInc);
diff --git a/libswscale/utils.c b/libswscale/utils.c
index a621a35862..f762fba1df 100644
--- a/libswscale/utils.c
+++ b/libswscale/utils.c
@@ -53,6 +53,7 @@ 
 #include "libavutil/ppc/cpu.h"
 #include "libavutil/x86/asm.h"
 #include "libavutil/x86/cpu.h"
+#include "libavutil/loongarch/cpu.h"
 
 #include "rgb2rgb.h"
 #include "swscale.h"
@@ -654,6 +655,15 @@  static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos,
             filterAlign = 1;
     }
 
+    if (have_lasx(cpu_flags)) {
+        int reNum = minFilterSize & (0x07);
+
+        if (minFilterSize < 5)
+            filterAlign = 4;
+        if (reNum < 3)
+            filterAlign = 1;
+    }
+
     av_assert0(minFilterSize > 0);
     filterSize = (minFilterSize + (filterAlign - 1)) & (~(filterAlign - 1));
     av_assert0(filterSize > 0);
@@ -1839,7 +1849,8 @@  av_cold int sws_init_context(SwsContext *c, SwsFilter *srcFilter,
         {
             const int filterAlign = X86_MMX(cpu_flags)     ? 4 :
                                     PPC_ALTIVEC(cpu_flags) ? 8 :
-                                    have_neon(cpu_flags)   ? 4 : 1;
+                                    have_neon(cpu_flags)   ? 4 :
+                                    have_lasx(cpu_flags)   ? 8 : 1;
 
             if ((ret = initFilter(&c->hLumFilter, &c->hLumFilterPos,
                            &c->hLumFilterSize, c->lumXInc,