使用ffmpeg中的转换库进行颜色转换

最新推荐文章于 2024-02-06 17:37:17 发布
最新推荐文章于 2024-02-06 17:37:17 发布
阅读量2k 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lgs790709/article/details/79213218
版权

李国帅 2010

colorspace模块包含了各种各样的颜色格式转换。

初始化

yv12转成RGBA的代码，需要把附件加入工程编译，并在控件初始化后调用一次

colorspace_init();


处理<inttypes.h>和<stdint.h>找不到的问题

在ffmpeg中使用了 #include <inttypes.h>

在vs2008下没有这个文件，实际上这个文件无非也就是一些整形定义而已，可以直接注释掉这个包含，然后在config.h中加上类似的定义：

typedef char int8_t;
typedef unsigned char uint8_t;
typedef short int16_t;
typedef unsigned short uint16_t;
typedef int int32_t;
typedef unsigned int uint32_t;
typedef __int64 int64_t;
typedef unsigned __int64 uint64_t;

<stdint.h>这个头文件同样可以直接注释掉。


调用例程


unsigned char *yuv_data[4];
    int yuv_lineSize[4];
    unsigned char *rgb_data[4];
    int rgb_lineSize[4];

    rgb_data[0] = (uint8_t *)new char[pChannel->videoParam.width * pChannel->videoParam.height * 4];

    if (rgb_data[0] == NULL)
    {
        DebugLog("outpic.data[0] == NULL! memory not enough!\n");
    }
    else
    {
        rgb_data[1] = 0;
        rgb_data[2] = 0;
        rgb_data[3] = 0;

        rgb_lineSize[0] = pChannel->videoParam.width * 4;
        rgb_lineSize[1] = 0;
        rgb_lineSize[2] = 0;
        rgb_lineSize[3] = 0;

        yuv_lineSize[0] = *(int *)dispBuffer;
        yuv_lineSize[1] = yuv_lineSize[0] / 2;
        yuv_lineSize[2] = yuv_lineSize[0] / 2;
        yuv_lineSize[3] = 0;

        yuv_data[0] = (unsigned char *)(dispBuffer + 4 * sizeof(int));
        yuv_data[1] = (unsigned char *)(dispBuffer + 4 * sizeof(int)+pChannel->videoParam.height * yuv_lineSize[0]);
        yuv_data[2] = (unsigned char *)(dispBuffer + 4 * sizeof(int)+pChannel->videoParam.height * yuv_lineSize[0] + pChannel->videoParam.height / 2 * yuv_lineSize[1]);
        yuv_data[3] = 0;

        yv12_to_bgra_c(rgb_data[0],
            rgb_lineSize[0],
            yuv_data[0],      //y
            yuv_data[2],      //V
            yuv_data[1],      //u
            yuv_lineSize[0],
            yuv_lineSize[1],
            pChannel->videoParam.width,
            pChannel->videoParam.height,
            0);

        HBITMAP hBmp = CreateBitmap(pChannel->videoParam.width, pChannel->videoParam.height, 1, 32, rgb_data[0]);


colorspace.h


/*****************************************************************************
*
*  XVID MPEG-4 VIDEO CODEC
*  - Colorspace related header  -
*
*  Copyright(C) 2001-2003 Peter Ross <pross@xvid.org>
*
*  This program is free software ; you can redistribute it and/or modify
*  it under the terms of the GNU General Public License as published by
*  the Free Software Foundation ; either version 2 of the License, or
*  (at your option) any later version.
*
*  This program 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 General Public License for more details.
*
*  You should have received a copy of the GNU General Public License
*  along with this program ; if not, write to the Free Software
*  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
*
* $Id: colorspace.h,v 1.10 2008/11/26 01:04:34 Isibaar Exp $
*
****************************************************************************/

#ifndef _COLORSPACE_H
#define _COLORSPACE_H

#include "stdint.h"

/* initialize tables */

void colorspace_init(void);

/* colorspace conversion function (encoder) */

typedef void (packedFunc)(uint8_t * x_ptr,
    int x_stride,
    uint8_t * y_src,
    uint8_t * v_src,
    uint8_t * u_src,
    int y_stride,
    int uv_stride,
    int width,
    int height,
    int vflip);

typedef packedFunc *packedFuncPtr;


/* xxx_to_yv12 colorspace conversion functions (encoder) */

extern packedFuncPtr rgb555_to_yv12;
extern packedFuncPtr rgb565_to_yv12;
extern packedFuncPtr rgb_to_yv12;
extern packedFuncPtr bgr_to_yv12;
extern packedFuncPtr bgra_to_yv12;
extern packedFuncPtr abgr_to_yv12;
extern packedFuncPtr rgba_to_yv12;
extern packedFuncPtr argb_to_yv12;
extern packedFuncPtr yuyv_to_yv12;
extern packedFuncPtr uyvy_to_yv12;

extern packedFuncPtr rgb555i_to_yv12;
extern packedFuncPtr rgb565i_to_yv12;
extern packedFuncPtr rgbi_to_yv12;
extern packedFuncPtr bgri_to_yv12;
extern packedFuncPtr bgrai_to_yv12;
extern packedFuncPtr abgri_to_yv12;
extern packedFuncPtr rgbai_to_yv12;
extern packedFuncPtr argbi_to_yv12;
extern packedFuncPtr yuyvi_to_yv12;
extern packedFuncPtr uyvyi_to_yv12;

/* plain c */
packedFunc rgb555_to_yv12_c;
packedFunc rgb565_to_yv12_c;
packedFunc rgb_to_yv12_c;
packedFunc bgr_to_yv12_c;
packedFunc bgra_to_yv12_c;
packedFunc abgr_to_yv12_c;
packedFunc rgba_to_yv12_c;
packedFunc argb_to_yv12_c;
packedFunc yuyv_to_yv12_c;
packedFunc uyvy_to_yv12_c;

packedFunc rgb555i_to_yv12_c;
packedFunc rgb565i_to_yv12_c;
packedFunc rgbi_to_yv12_c;
packedFunc bgri_to_yv12_c;
packedFunc bgrai_to_yv12_c;
packedFunc abgri_to_yv12_c;
packedFunc rgbai_to_yv12_c;
packedFunc argbi_to_yv12_c;
packedFunc yuyvi_to_yv12_c;
packedFunc uyvyi_to_yv12_c;

#if defined(ARCH_IS_IA32) || defined(ARCH_IS_X86_64)
/* mmx */
packedFunc bgr_to_yv12_mmx;
packedFunc rgb_to_yv12_mmx;
packedFunc bgra_to_yv12_mmx;
packedFunc rgba_to_yv12_mmx;
packedFunc yuyv_to_yv12_mmx;
packedFunc uyvy_to_yv12_mmx;

/* 3dnow */
packedFunc yuyv_to_yv12_3dn;
packedFunc uyvy_to_yv12_3dn;

/* xmm */
packedFunc yuyv_to_yv12_xmm;
packedFunc uyvy_to_yv12_xmm;
#endif

#ifdef ARCH_IS_PPC
packedFunc bgra_to_yv12_altivec_c;
packedFunc abgr_to_yv12_altivec_c;
packedFunc rgba_to_yv12_altivec_c;
packedFunc argb_to_yv12_altivec_c;

packedFunc yuyv_to_yv12_altivec_c;
packedFunc uyvy_to_yv12_altivec_c;
#endif

/* yv12_to_xxx colorspace conversion functions (decoder) */

extern packedFuncPtr yv12_to_rgb555;
extern packedFuncPtr yv12_to_rgb565;
extern packedFuncPtr yv12_to_rgb;
extern packedFuncPtr yv12_to_bgr;
extern packedFuncPtr yv12_to_bgra;
extern packedFuncPtr yv12_to_abgr;
extern packedFuncPtr yv12_to_rgba;
extern packedFuncPtr yv12_to_argb;
extern packedFuncPtr yv12_to_yuyv;
extern packedFuncPtr yv12_to_uyvy;

extern packedFuncPtr yv12_to_rgb555i;
extern packedFuncPtr yv12_to_rgb565i;
extern packedFuncPtr yv12_to_rgbi;
extern packedFuncPtr yv12_to_bgri;
extern packedFuncPtr yv12_to_bgrai;
extern packedFuncPtr yv12_to_abgri;
extern packedFuncPtr yv12_to_rgbai;
extern packedFuncPtr yv12_to_argbi;
extern packedFuncPtr yv12_to_yuyvi;
extern packedFuncPtr yv12_to_uyvyi;

/* plain c */
packedFunc yv12_to_rgb555_c;
packedFunc yv12_to_rgb565_c;
packedFunc yv12_to_rgb_c;
packedFunc yv12_to_bgr_c;
packedFunc yv12_to_bgra_c;
packedFunc yv12_to_abgr_c;
packedFunc yv12_to_rgba_c;
packedFunc yv12_to_argb_c;
packedFunc yv12_to_yuyv_c;
packedFunc yv12_to_uyvy_c;

packedFunc yv12_to_rgb555i_c;
packedFunc yv12_to_rgb565i_c;
packedFunc yv12_to_rgbi_c;
packedFunc yv12_to_bgri_c;
packedFunc yv12_to_bgrai_c;
packedFunc yv12_to_abgri_c;
packedFunc yv12_to_rgbai_c;
packedFunc yv12_to_argbi_c;
packedFunc yv12_to_yuyvi_c;
packedFunc yv12_to_uyvyi_c;

#if defined(ARCH_IS_IA32) || defined(ARCH_IS_X86_64)
/* mmx */
packedFunc yv12_to_bgr_mmx;
packedFunc yv12_to_bgra_mmx;
packedFunc yv12_to_yuyv_mmx;
packedFunc yv12_to_uyvy_mmx;

packedFunc yv12_to_yuyvi_mmx;
packedFunc yv12_to_uyvyi_mmx;
#endif

#ifdef ARCH_IS_PPC
packedFunc yv12_to_yuyv_altivec_c;
packedFunc yv12_to_uyvy_altivec_c;
#endif

typedef void (planarFunc)(
    uint8_t * y_dst, uint8_t * u_dst, uint8_t * v_dst,
    int y_dst_stride, int uv_dst_stride,
    uint8_t * y_src, uint8_t * u_src, uint8_t * v_src,
    int y_src_stride, int uv_src_stride,
    int width, int height, int vflip);
typedef planarFunc *planarFuncPtr;

extern planarFuncPtr yv12_to_yv12;

planarFunc yv12_to_yv12_c;

#if defined(ARCH_IS_IA32) || defined(ARCH_IS_X86_64)
planarFunc yv12_to_yv12_mmx;
planarFunc yv12_to_yv12_xmm;
#endif


#endif                            /* _COLORSPACE_H_ */

colorspace.c

#include "colorspace.h"

#define MIN(X, Y) ((X)<(Y)?(X):(Y))
#define MAX(X, Y) ((X)>(Y)?(X):(Y))
#define SIGN(X)   (((X)>0)?1:-1)
#define CLIP(X,AMIN,AMAX)   (((X)<(AMIN)) ? (AMIN) : ((X)>(AMAX)) ? (AMAX) : (X))
#define DIV_DIV(a,b)    (((a)>0) ? ((a)+((b)>>1))/(b) : ((a)-((b)>>1))/(b))
#define SWAP(_T_,A,B)    { _T_ tmp = A; A = B; B = tmp; }

/* function pointers */

/* input */
packedFuncPtr rgb555_to_yv12;
packedFuncPtr rgb565_to_yv12;
packedFuncPtr rgb_to_yv12;
packedFuncPtr bgr_to_yv12;
packedFuncPtr bgra_to_yv12;
packedFuncPtr abgr_to_yv12;
packedFuncPtr rgba_to_yv12;
packedFuncPtr argb_to_yv12;
packedFuncPtr yuyv_to_yv12;
packedFuncPtr uyvy_to_yv12;

packedFuncPtr rgb555i_to_yv12;
packedFuncPtr rgb565i_to_yv12;
packedFuncPtr rgbi_to_yv12;
packedFuncPtr bgri_to_yv12;
packedFuncPtr bgrai_to_yv12;
packedFuncPtr abgri_to_yv12;
packedFuncPtr rgbai_to_yv12;
packedFuncPtr argbi_to_yv12;
packedFuncPtr yuyvi_to_yv12;
packedFuncPtr uyvyi_to_yv12;

/* output */
packedFuncPtr yv12_to_rgb555;
packedFuncPtr yv12_to_rgb565;
packedFuncPtr yv12_to_bgr;
packedFuncPtr yv12_to_bgra;
packedFuncPtr yv12_to_abgr;
packedFuncPtr yv12_to_rgb;
packedFuncPtr yv12_to_rgba;
packedFuncPtr yv12_to_argb;
packedFuncPtr yv12_to_yuyv;
packedFuncPtr yv12_to_uyvy;

packedFuncPtr yv12_to_rgb555i;
packedFuncPtr yv12_to_rgb565i;
packedFuncPtr yv12_to_bgri;
packedFuncPtr yv12_to_bgrai;
packedFuncPtr yv12_to_abgri;
packedFuncPtr yv12_to_rgbi;
packedFuncPtr yv12_to_rgbai;
packedFuncPtr yv12_to_argbi;
packedFuncPtr yv12_to_yuyvi;
packedFuncPtr yv12_to_uyvyi;

planarFuncPtr yv12_to_yv12;


static int32_t RGB_Y_tab[256];
static int32_t B_U_tab[256];
static int32_t G_U_tab[256];
static int32_t G_V_tab[256];
static int32_t R_V_tab[256];



/********** generic colorspace macro **********/


#define MAKE_COLORSPACE(NAME,SIZE,PIXELS,VPIXELS,FUNC,C1,C2,C3,C4) \
    void    \
    NAME(uint8_t * x_ptr, int x_stride, \
    uint8_t * y_ptr, uint8_t * u_ptr, uint8_t * v_ptr, \
    int y_stride, int uv_stride, \
    int width, int height, int vflip)    \
{    \
    int fixed_width = (width + 1) & ~1;                \
    int x_dif = x_stride - (SIZE)*fixed_width;        \
    int y_dif = y_stride - fixed_width;                \
    int uv_dif = uv_stride - (fixed_width / 2);        \
    int x, y;                                        \
if (vflip) {
\
    x_ptr += (height - 1) * x_stride;            \
    x_dif = -(SIZE)*fixed_width - x_stride;        \
    x_stride = -x_stride;                        \
}                                                \
for (y = 0; y < height; y += (VPIXELS)) {
    \
    FUNC##_ROW(SIZE, C1, C2, C3, C4);                \
    for (x = 0; x < fixed_width; x += (PIXELS)) {
    \
    FUNC(SIZE, C1, C2, C3, C4);                \
    x_ptr += (PIXELS)*(SIZE);                \
    y_ptr += (PIXELS);                        \
    u_ptr += (PIXELS) / 2;                    \
    v_ptr += (PIXELS) / 2;                    \
    }                                            \
    x_ptr += x_dif + (VPIXELS - 1)*x_stride;        \
    y_ptr += y_dif + (VPIXELS - 1)*y_stride;        \
    u_ptr += uv_dif + ((VPIXELS / 2) - 1)*uv_stride;    \
    v_ptr += uv_dif + ((VPIXELS / 2) - 1)*uv_stride;    \
}                                                \
}



/********** colorspace input (xxx_to_yv12) functions **********/

/*    rgb -> yuv def's

this following constants are "official spec"
Video Demystified" (ISBN 1-878707-09-4)

rgb<->yuv _is_ lossy, since most programs do the conversion differently

SCALEBITS/FIX taken from  ffmpeg
*/

#define Y_R_IN            0.257
#define Y_G_IN            0.504
#define Y_B_IN            0.098
#define Y_ADD_IN        16

#define U_R_IN            0.148
#define U_G_IN            0.291
#define U_B_IN            0.439
#define U_ADD_IN        128

#define V_R_IN            0.439
#define V_G_IN            0.368
#define V_B_IN            0.071
#define V_ADD_IN        128

#define SCALEBITS_IN    8
#define FIX_IN(x)        ((uint16_t) ((x) * (1L<<SCALEBITS_IN) + 0.5))


/* rgb16/rgb16i input */

#define MK_RGB555_B(RGB)  ((RGB) << 3) & 0xf8
#define MK_RGB555_G(RGB)  ((RGB) >> 2) & 0xf8
#define MK_RGB555_R(RGB)  ((RGB) >> 7) & 0xf8

#define MK_RGB565_B(RGB)  ((RGB) << 3) & 0xf8
#define MK_RGB565_G(RGB)  ((RGB) >> 3) & 0xfc
#define MK_RGB565_R(RGB)  ((RGB) >> 8) & 0xf8


#define READ_RGB16_Y(ROW, UVID, C1,C2,C3,C4)    \
    rgb = *(uint16_t *)(x_ptr + ((ROW)*x_stride) + 0);    \
    b##UVID += b = C1##_B(rgb);                \
    g##UVID += g = C1##_G(rgb);                \
    r##UVID += r = C1##_R(rgb);                \
    y_ptr[(ROW)*y_stride + 0] = \
    (uint8_t)((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g + \
    FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;    \
    rgb = *(uint16_t *)(x_ptr + ((ROW)*x_stride) + 2);    \
    b##UVID += b = C1##_B(rgb);                \
    g##UVID += g = C1##_G(rgb);                \
    r##UVID += r = C1##_R(rgb);                \
    y_ptr[(ROW)*y_stride + 1] = \
    (uint8_t)((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g + \
    FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;

#define READ_RGB16_UV(UV_ROW,UVID)    \
    u_ptr[(UV_ROW)*uv_stride] = \
    (uint8_t)((-FIX_IN(U_R_IN) * r##UVID - FIX_IN(U_G_IN) * g##UVID + \
    FIX_IN(U_B_IN) * b##UVID) >> (SCALEBITS_IN + 2)) + U_ADD_IN;    \
    v_ptr[(UV_ROW)*uv_stride] = \
    (uint8_t)((FIX_IN(V_R_IN) * r##UVID - FIX_IN(V_G_IN) * g##UVID - \
    FIX_IN(V_B_IN) * b##UVID) >> (SCALEBITS_IN + 2)) + V_ADD_IN;

#define RGB16_TO_YV12_ROW(SIZE,C1,C2,C3,C4) \
    /* nothing */
#define RGB16_TO_YV12(SIZE,C1,C2,C3,C4)    \
    uint32_t rgb, r, g, b, r0, g0, b0;    \
    r0 = g0 = b0 = 0;                    \
    READ_RGB16_Y(0, 0, C1, C2, C3, C4)    \
    READ_RGB16_Y(1, 0, C1, C2, C3, C4)    \
    READ_RGB16_UV(0, 0)


#define RGB16I_TO_YV12_ROW(SIZE,C1,C2,C3,C4) \
    /* nothing */
#define RGB16I_TO_YV12(SIZE,C1,C2,C3,C4)    \
    uint32_t rgb, r, g, b, r0, g0, b0, r1, g1, b1;    \
    r0 = g0 = b0 = r1 = g1 = b1 = 0;    \
    READ_RGB16_Y(0, 0, C1, C2, C3, C4)    \
    READ_RGB16_Y(1, 1, C1, C2, C3, C4)    \
    READ_RGB16_Y(2, 0, C1, C2, C3, C4)    \
    READ_RGB16_Y(3, 1, C1, C2, C3, C4)    \
    READ_RGB16_UV(0, 0)                    \
    READ_RGB16_UV(1, 1)


/* rgb/rgbi input */

#define READ_RGB_Y(SIZE, ROW, UVID, C1,C2,C3,C4)    \
    r##UVID += r = x_ptr[(ROW)*x_stride + (C1)];                        \
    g##UVID += g = x_ptr[(ROW)*x_stride + (C2)];                        \
    b##UVID += b = x_ptr[(ROW)*x_stride + (C3)];                        \
    y_ptr[(ROW)*y_stride + 0] = \
    (uint8_t)((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g + \
    FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;    \
    r##UVID += r = x_ptr[(ROW)*x_stride + (SIZE)+(C1)];                \
    g##UVID += g = x_ptr[(ROW)*x_stride + (SIZE)+(C2)];                \
    b##UVID += b = x_ptr[(ROW)*x_stride + (SIZE)+(C3)];                \
    y_ptr[(ROW)*y_stride + 1] = \
    (uint8_t)((FIX_IN(Y_R_IN) * r + FIX_IN(Y_G_IN) * g + \
    FIX_IN(Y_B_IN) * b) >> SCALEBITS_IN) + Y_ADD_IN;

#define READ_RGB_UV(UV_ROW,UVID)    \
    u_ptr[(UV_ROW)*uv_stride] = \
    (uint8_t)((-FIX_IN(U_R_IN) * r##UVID - FIX_IN(U_G_IN) * g##UVID + \
    FIX_IN(U_B_IN) * b##UVID) >> (SCALEBITS_IN + 2)) + U_ADD_IN;    \
    v_ptr[(UV_ROW)*uv_stride] = \
    (uint8_t)((FIX_IN(V_R_IN) * r##UVID - FIX_IN(V_G_IN) * g##UVID - \
    FIX_IN(V_B_IN) * b##UVID) >> (SCALEBITS_IN + 2)) + V_ADD_IN;


#define RGB_TO_YV12_ROW(SIZE,C1,C2,C3,C4) \
    /* nothing */
#define RGB_TO_YV12(SIZE,C1,C2,C3,C4)    \
    uint32_t r, g, b, r0, g0, b0;        \
    r0 = g0 = b0 = 0;                    \
    READ_RGB_Y(SIZE, 0, 0, C1, C2, C3, C4)    \
    READ_RGB_Y(SIZE, 1, 0, C1, C2, C3, C4)    \
    READ_RGB_UV(0, 0)

#define RGBI_TO_YV12_ROW(SIZE,C1,C2,C3,C4) \
    /* nothing */
#define RGBI_TO_YV12(SIZE,C1,C2,C3,C4)    \
    uint32_t r, g, b, r0, g0, b0, r1, g1, b1;    \
    r0 = g0 = b0 = r1 = g1 = b1 = 0;    \
    READ_RGB_Y(SIZE, 0, 0, C1, C2, C3, C4)    \
    READ_RGB_Y(SIZE, 1, 1, C1, C2, C3, C4)    \
    READ_RGB_Y(SIZE, 2, 0, C1, C2, C3, C4)    \
    READ_RGB_Y(SIZE, 3, 1, C1, C2, C3, C4)    \
    READ_RGB_UV(0, 0)                \
    READ_RGB_UV(1, 1)


/* yuyv/yuyvi input */

#define READ_YUYV_Y(ROW,C1,C2,C3,C4)    \
    y_ptr[(ROW)*y_stride + 0] = x_ptr[(ROW)*x_stride + (C1)];    \
    y_ptr[(ROW)*y_stride + 1] = x_ptr[(ROW)*x_stride + (C3)];
#define READ_YUYV_UV(UV_ROW,ROW1,ROW2,C1,C2,C3,C4) \
    u_ptr[(UV_ROW)*uv_stride] = (x_ptr[(ROW1)*x_stride + (C2)] + x_ptr[(ROW2)*x_stride + (C2)] + 1) / 2;    \
    v_ptr[(UV_ROW)*uv_stride] = (x_ptr[(ROW1)*x_stride + (C4)] + x_ptr[(ROW2)*x_stride + (C4)] + 1) / 2;

#define YUYV_TO_YV12_ROW(SIZE,C1,C2,C3,C4) \
    /* nothing */
#define YUYV_TO_YV12(SIZE,C1,C2,C3,C4)    \
    READ_YUYV_Y(0, C1, C2, C3, C4)    \
    READ_YUYV_Y(1, C1, C2, C3, C4)    \
    READ_YUYV_UV(0, 0, 1, C1, C2, C3, C4)

#define YUYVI_TO_YV12_ROW(SIZE,C1,C2,C3,C4) \
    /* nothing */
#define YUYVI_TO_YV12(SIZE,C1,C2,C3,C4)    \
    READ_YUYV_Y(0, C1, C2, C3, C4)    \
    READ_YUYV_Y(1, C1, C2, C3, C4)    \
    READ_YUYV_Y(2, C1, C2, C3, C4)    \
    READ_YUYV_Y(3, C1, C2, C3, C4)    \
    READ_YUYV_UV(0, 0, 2, C1, C2, C3, C4)    \
    READ_YUYV_UV(1, 1, 3, C1, C2, C3, C4)


MAKE_COLORSPACE(rgb555_to_yv12_c, 2, 2, 2, RGB16_TO_YV12, MK_RGB555, 0, 0, 0)
MAKE_COLORSPACE(rgb565_to_yv12_c, 2, 2, 2, RGB16_TO_YV12, MK_RGB565, 0, 0, 0)
MAKE_COLORSPACE(bgr_to_yv12_c, 3, 2, 2, RGB_TO_YV12, 2, 1, 0, 0)
MAKE_COLORSPACE(bgra_to_yv12_c, 4, 2, 2, RGB_TO_YV12, 2, 1, 0, 0)
MAKE_COLORSPACE(rgb_to_yv12_c, 3, 2, 2, RGB_TO_YV12, 0, 1, 2, 0)
MAKE_COLORSPACE(abgr_to_yv12_c, 4, 2, 2, RGB_TO_YV12, 3, 2, 1, 0)
MAKE_COLORSPACE(rgba_to_yv12_c, 4, 2, 2, RGB_TO_YV12, 0, 1, 2, 0)
MAKE_COLORSPACE(argb_to_yv12_c, 4, 2, 2, RGB_TO_YV12, 1, 2, 3, 0)
MAKE_COLORSPACE(yuyv_to_yv12_c, 2, 2, 2, YUYV_TO_YV12, 0, 1, 2, 3)
MAKE_COLORSPACE(uyvy_to_yv12_c, 2, 2, 2, YUYV_TO_YV12, 1, 0, 3, 2)

MAKE_COLORSPACE(rgb555i_to_yv12_c, 2, 2, 4, RGB16I_TO_YV12, MK_RGB555, 0, 0, 0)
MAKE_COLORSPACE(rgb565i_to_yv12_c, 2, 2, 4, RGB16I_TO_YV12, MK_RGB565, 0, 0, 0)
MAKE_COLORSPACE(bgri_to_yv12_c, 3, 2, 4, RGBI_TO_YV12, 2, 1, 0, 0)
MAKE_COLORSPACE(bgrai_to_yv12_c, 4, 2, 4, RGBI_TO_YV12, 2, 1, 0, 0)
MAKE_COLORSPACE(abgri_to_yv12_c, 4, 2, 4, RGBI_TO_YV12, 3, 2, 1, 0)
MAKE_COLORSPACE(rgbi_to_yv12_c, 3, 2, 4, RGBI_TO_YV12, 0, 1, 2, 0)
MAKE_COLORSPACE(rgbai_to_yv12_c, 4, 2, 4, RGBI_TO_YV12, 0, 1, 2, 0)
MAKE_COLORSPACE(argbi_to_yv12_c, 4, 2, 4, RGBI_TO_YV12, 1, 2, 3, 0)
MAKE_COLORSPACE(yuyvi_to_yv12_c, 2, 2, 4, YUYVI_TO_YV12, 0, 1, 2, 3)
MAKE_COLORSPACE(uyvyi_to_yv12_c, 2, 2, 4, YUYVI_TO_YV12, 1, 0, 3, 2)


/********** colorspace output (yv12_to_xxx) functions **********/

/* yuv -> rgb def's */

#define RGB_Y_OUT        1.164
#define B_U_OUT            2.018
#define Y_ADD_OUT        16

#define G_U_OUT            0.391
#define G_V_OUT            0.813
#define U_ADD_OUT        128

#define R_V_OUT            1.596
#define V_ADD_OUT        128

#define SCALEBITS_OUT    13
#define FIX_OUT(x)        ((uint16_t) ((x) * (1L<<SCALEBITS_OUT) + 0.5))


/* rgb16/rgb16i output */

#define MK_RGB555(R,G,B)    \
    ((MAX(0, MIN(255, R)) << 7) & 0x7c00) | \
    ((MAX(0, MIN(255, G)) << 2) & 0x03e0) | \
    ((MAX(0, MIN(255, B)) >> 3) & 0x001f)

#define MK_RGB565(R,G,B)    \
    ((MAX(0, MIN(255, R)) << 8) & 0xf800) | \
    ((MAX(0, MIN(255, G)) << 3) & 0x07e0) | \
    ((MAX(0, MIN(255, B)) >> 3) & 0x001f)

#define WRITE_RGB16(ROW,UV_ROW,C1)    \
    rgb_y = RGB_Y_tab[y_ptr[y_stride*(ROW)+0]];                        \
    b[ROW] = (b[ROW] & 0x7) + ((rgb_y + b_u##UV_ROW) >> SCALEBITS_OUT);    \
    g[ROW] = (g[ROW] & 0x7) + ((rgb_y - g_uv##UV_ROW) >> SCALEBITS_OUT);    \
    r[ROW] = (r[ROW] & 0x7) + ((rgb_y + r_v##UV_ROW) >> SCALEBITS_OUT);        \
    *(uint16_t *)(x_ptr + ((ROW)*x_stride) + 0) = C1(r[ROW], g[ROW], b[ROW]);    \
    rgb_y = RGB_Y_tab[y_ptr[y_stride*(ROW)+1]];                \
    b[ROW] = (b[ROW] & 0x7) + ((rgb_y + b_u##UV_ROW) >> SCALEBITS_OUT);        \
    g[ROW] = (g[ROW] & 0x7) + ((rgb_y - g_uv##UV_ROW) >> SCALEBITS_OUT);    \
    r[ROW] = (r[ROW] & 0x7) + ((rgb_y + r_v##UV_ROW) >> SCALEBITS_OUT);        \
    *(uint16_t *)(x_ptr + ((ROW)*x_stride) + 2) = C1(r[ROW], g[ROW], b[ROW]);

#define YV12_TO_RGB16_ROW(SIZE,C1,C2,C3,C4) \
    int r[2], g[2], b[2];                    \
    r[0] = r[1] = g[0] = g[1] = b[0] = b[1] = 0;
#define YV12_TO_RGB16(SIZE,C1,C2,C3,C4)        \
    int rgb_y;                                                 \
    int b_u0 = B_U_tab[u_ptr[0]];                                \
    int g_uv0 = G_U_tab[u_ptr[0]] + G_V_tab[v_ptr[0]];        \
    int r_v0 = R_V_tab[v_ptr[0]];                                \
    WRITE_RGB16(0, 0, C1)                                        \
    WRITE_RGB16(1, 0, C1)

#define YV12_TO_RGB16I_ROW(SIZE,C1,C2,C3,C4) \
    int r[4], g[4], b[4];                    \
    r[0] = r[1] = r[2] = r[3] = 0;            \
    g[0] = g[1] = g[2] = g[3] = 0;            \
    b[0] = b[1] = b[2] = b[3] = 0;
#define YV12_TO_RGB16I(SIZE,C1,C2,C3,C4)        \
    int rgb_y;                                                     \
    int b_u0 = B_U_tab[u_ptr[0]];                                \
    int g_uv0 = G_U_tab[u_ptr[0]] + G_V_tab[v_ptr[0]];        \
    int r_v0 = R_V_tab[v_ptr[0]];                                \
    int b_u1 = B_U_tab[u_ptr[uv_stride]];                        \
    int g_uv1 = G_U_tab[u_ptr[uv_stride]] + G_V_tab[v_ptr[uv_stride]];    \
    int r_v1 = R_V_tab[v_ptr[uv_stride]];                        \
    WRITE_RGB16(0, 0, C1)                                        \
    WRITE_RGB16(1, 1, C1)                                        \
    WRITE_RGB16(2, 0, C1)                                        \
    WRITE_RGB16(3, 1, C1)                                        \


/* rgb/rgbi output */

#define WRITE_RGB(SIZE,ROW,UV_ROW,C1,C2,C3,C4)    \
    rgb_y = RGB_Y_tab[y_ptr[(ROW)*y_stride + 0]];                        \
    x_ptr[(ROW)*x_stride + (C3)] = MAX(0, MIN(255, (rgb_y + b_u##UV_ROW) >> SCALEBITS_OUT));    \
    x_ptr[(ROW)*x_stride + (C2)] = MAX(0, MIN(255, (rgb_y - g_uv##UV_ROW) >> SCALEBITS_OUT));    \
    x_ptr[(ROW)*x_stride + (C1)] = MAX(0, MIN(255, (rgb_y + r_v##UV_ROW) >> SCALEBITS_OUT));    \
    if ((SIZE)>3) x_ptr[(ROW)*x_stride + (C4)] = 0;                                    \
    rgb_y = RGB_Y_tab[y_ptr[(ROW)*y_stride + 1]];                                    \
    x_ptr[(ROW)*x_stride + (SIZE)+(C3)] = MAX(0, MIN(255, (rgb_y + b_u##UV_ROW) >> SCALEBITS_OUT));    \
    x_ptr[(ROW)*x_stride + (SIZE)+(C2)] = MAX(0, MIN(255, (rgb_y - g_uv##UV_ROW) >> SCALEBITS_OUT));    \
    x_ptr[(ROW)*x_stride + (SIZE)+(C1)] = MAX(0, MIN(255, (rgb_y + r_v##UV_ROW) >> SCALEBITS_OUT));    \
    if ((SIZE)>3) x_ptr[(ROW)*x_stride + (SIZE)+(C4)] = 0;


#define YV12_TO_RGB_ROW(SIZE,C1,C2,C3,C4)     /* nothing */
#define YV12_TO_RGB(SIZE,C1,C2,C3,C4)                \
    int rgb_y;                                                \
    int b_u0 = B_U_tab[u_ptr[0]];                            \
    int g_uv0 = G_U_tab[u_ptr[0]] + G_V_tab[v_ptr[0]];    \
    int r_v0 = R_V_tab[v_ptr[0]];                            \
    WRITE_RGB(SIZE, 0, 0, C1, C2, C3, C4)                        \
    WRITE_RGB(SIZE, 1, 0, C1, C2, C3, C4)

#define YV12_TO_RGBI_ROW(SIZE,C1,C2,C3,C4)     /* nothing */
#define YV12_TO_RGBI(SIZE,C1,C2,C3,C4)                \
    int rgb_y;                                                \
    int b_u0 = B_U_tab[u_ptr[0]];                            \
    int g_uv0 = G_U_tab[u_ptr[0]] + G_V_tab[v_ptr[0]];    \
    int r_v0 = R_V_tab[v_ptr[0]];                            \
    int b_u1 = B_U_tab[u_ptr[uv_stride]];                    \
    int g_uv1 = G_U_tab[u_ptr[uv_stride]] + G_V_tab[v_ptr[uv_stride]];    \
    int r_v1 = R_V_tab[v_ptr[uv_stride]];                    \
    WRITE_RGB(SIZE, 0, 0, C1, C2, C3, C4)        \
    WRITE_RGB(SIZE, 1, 1, C1, C2, C3, C4)        \
    WRITE_RGB(SIZE, 2, 0, C1, C2, C3, C4)        \
    WRITE_RGB(SIZE, 3, 1, C1, C2, C3, C4)


/* yuyv/yuyvi output */

#define WRITE_YUYV(ROW,UV_ROW,C1,C2,C3,C4)    \
    x_ptr[(ROW)*x_stride + (C1)] = y_ptr[(ROW)*y_stride + 0];    \
    x_ptr[(ROW)*x_stride + (C2)] = u_ptr[(UV_ROW)*uv_stride + 0];    \
    x_ptr[(ROW)*x_stride + (C3)] = y_ptr[(ROW)*y_stride + 1];    \
    x_ptr[(ROW)*x_stride + (C4)] = v_ptr[(UV_ROW)*uv_stride + 0];    \

#define YV12_TO_YUYV_ROW(SIZE,C1,C2,C3,C4)     /* nothing */
#define YV12_TO_YUYV(SIZE,C1,C2,C3,C4)    \
    WRITE_YUYV(0, 0, C1, C2, C3, C4)        \
    WRITE_YUYV(1, 0, C1, C2, C3, C4)

#define YV12_TO_YUYVI_ROW(SIZE,C1,C2,C3,C4) /* nothing */
#define YV12_TO_YUYVI(SIZE,C1,C2,C3,C4)    \
    WRITE_YUYV(0, 0, C1, C2, C3, C4)        \
    WRITE_YUYV(1, 1, C1, C2, C3, C4)        \
    WRITE_YUYV(2, 0, C1, C2, C3, C4)        \
    WRITE_YUYV(3, 1, C1, C2, C3, C4)


MAKE_COLORSPACE(yv12_to_rgb555_c, 2, 2, 2, YV12_TO_RGB16, MK_RGB555, 0, 0, 0)
MAKE_COLORSPACE(yv12_to_rgb565_c, 2, 2, 2, YV12_TO_RGB16, MK_RGB565, 0, 0, 0)
MAKE_COLORSPACE(yv12_to_bgr_c, 3, 2, 2, YV12_TO_RGB, 2, 1, 0, 0)
MAKE_COLORSPACE(yv12_to_bgra_c, 4, 2, 2, YV12_TO_RGB, 2, 1, 0, 3)
MAKE_COLORSPACE(yv12_to_abgr_c, 4, 2, 2, YV12_TO_RGB, 3, 2, 1, 0)
MAKE_COLORSPACE(yv12_to_rgb_c, 3, 2, 2, YV12_TO_RGB, 0, 1, 2, 0)
MAKE_COLORSPACE(yv12_to_rgba_c, 4, 2, 2, YV12_TO_RGB, 0, 1, 2, 3)
MAKE_COLORSPACE(yv12_to_argb_c, 4, 2, 2, YV12_TO_RGB, 1, 2, 3, 0)
MAKE_COLORSPACE(yv12_to_yuyv_c, 2, 2, 2, YV12_TO_YUYV, 0, 1, 2, 3)
MAKE_COLORSPACE(yv12_to_uyvy_c, 2, 2, 2, YV12_TO_YUYV, 1, 0, 3, 2)

MAKE_COLORSPACE(yv12_to_rgb555i_c, 2, 2, 4, YV12_TO_RGB16I, MK_RGB555, 0, 0, 0)
MAKE_COLORSPACE(yv12_to_rgb565i_c, 2, 2, 4, YV12_TO_RGB16I, MK_RGB565, 0, 0, 0)
MAKE_COLORSPACE(yv12_to_bgri_c, 3, 2, 4, YV12_TO_RGBI, 2, 1, 0, 0)
MAKE_COLORSPACE(yv12_to_bgrai_c, 4, 2, 4, YV12_TO_RGBI, 2, 1, 0, 3)
MAKE_COLORSPACE(yv12_to_abgri_c, 4, 2, 4, YV12_TO_RGBI, 3, 2, 1, 0)
MAKE_COLORSPACE(yv12_to_rgbi_c, 3, 2, 4, YV12_TO_RGBI, 0, 1, 2, 0)
MAKE_COLORSPACE(yv12_to_rgbai_c, 4, 2, 4, YV12_TO_RGBI, 0, 1, 2, 3)
MAKE_COLORSPACE(yv12_to_argbi_c, 4, 2, 4, YV12_TO_RGBI, 1, 2, 3, 0)
MAKE_COLORSPACE(yv12_to_yuyvi_c, 2, 2, 4, YV12_TO_YUYVI, 0, 1, 2, 3)
MAKE_COLORSPACE(yv12_to_uyvyi_c, 2, 2, 4, YV12_TO_YUYVI, 1, 0, 3, 2)



/* yv12 to yv12 copy function */

void
yv12_to_yv12_c(uint8_t * y_dst, uint8_t * u_dst, uint8_t * v_dst,
int y_dst_stride, int uv_dst_stride,
uint8_t * y_src, uint8_t * u_src, uint8_t * v_src,
int y_src_stride, int uv_src_stride,
int width, int height, int vflip)
    {
    int width2 = width / 2;
    int height2 = height / 2;
    int y;
    const int with_uv = (u_src != 0 && v_src != 0);

    if (vflip) {
        y_src += (height - 1) * y_src_stride;
        if (with_uv) {
            u_src += (height2 - 1) * uv_src_stride;
            v_src += (height2 - 1) * uv_src_stride;
        }
        y_src_stride = -y_src_stride;
        uv_src_stride = -uv_src_stride;
    }

    for (y = height; y; y--) {
        memcpy(y_dst, y_src, width);
        y_src += y_src_stride;
        y_dst += y_dst_stride;
    }

    if (with_uv) {
        for (y = height2; y; y--) {
            memcpy(u_dst, u_src, width2);
            memcpy(v_dst, v_src, width2);
            u_src += uv_src_stride;
            u_dst += uv_dst_stride;
            v_src += uv_src_stride;
            v_dst += uv_dst_stride;
        }
    }
    else {
        for (y = height2; y; y--) {
            memset(u_dst, 0x80, width2);
            memset(v_dst, 0x80, width2);
            u_dst += uv_dst_stride;
            v_dst += uv_dst_stride;
        }
    }
}

/* initialize rgb lookup tables */
void
colorspace_init(void)
{
    int32_t i;
    for (i = 0; i < 256; i++) {
        RGB_Y_tab[i] = FIX_OUT(RGB_Y_OUT) * (i - Y_ADD_OUT);
        B_U_tab[i] = FIX_OUT(B_U_OUT) * (i - U_ADD_OUT);
        G_U_tab[i] = FIX_OUT(G_U_OUT) * (i - U_ADD_OUT);
        G_V_tab[i] = FIX_OUT(G_V_OUT) * (i - V_ADD_OUT);
        R_V_tab[i] = FIX_OUT(R_V_OUT) * (i - V_ADD_OUT);
    }
}
微澜-
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
使用FFMPEG的sws_scale函数实现各种原始颜色格式互转(YUV\RGB\)
05-07 1953
一、环境介绍 FFMPEG版本: 4.2.2 测试系统：ubuntu18.04 二、示例代码 /* YUYV转QImage格式 */ QImage YUYV422_TO_QImage(uint8_t *yuyv422,int image_width,int image_height) { uint8_t *out_buffer= nullptr; AVFrame *In...
使用FFMPEG的sws_scale函数实现各种原始颜色格式互转(YUV\RGB)
最新发布
走向CTO的路上...
04-18 115
FFMPEG的sws_scale函数是一个强大的图像缩放和颜色格式转换函数，可以实现各种原始颜色格式之间的互转，例如YUV和RGB。sws_scale函数使用高效的算法和SIMD指令集优化，可以实现高性能的图像转换。sws_scale 函数是 FFmpeg 中的一个图像处理函数，用于实现不同颜色格式之间的转换，包括 YUV 到 RGB 的转换以及 RGB 到 YUV 的转换。该函数可以进行图像的缩放、裁剪和调整颜色空间等操作。
ffmpeg 颜色空间sws scale 转换使用案例
weixin_43360707的博客
02-07 185
ffmpeg 颜色空间转换使用案例。
Qt 集成 FFmpeg 实现颜色格式转换
StephenZhou
10-30 1733
由于输入输出为纯图片文件，所以需要指定图像的宽高信息；
颜色格式转换： 最简单的基于FFmpeg的libswscale的示例（YUV转RGB）
STN_LCD的专栏
06-23 3324
http://blog.csdn.net/leixiaohua1020/article/details/42134965 版权声明：本文为博主原创文章，未经博主允许不得转载。 目录(?)[+] ===================================================== 最简单的基于FFmpeg的
ffmpeg库实现bmp转换为jpeg格式图像
06-02
在C++中，使用FFmpeg库进行图像转换通常涉及以下步骤： 1. **初始化FFmpeg上下文**：调用`avformat_alloc_context`创建一个`AVFormatContext`对象，它是FFmpeg的核心结构，包含了媒体文件的全局信息。 2. **加载...
FFmpeg各个平台动态库
04-21
- **滤镜**：FFmpeg的libavfilter库提供了一系列强大的滤镜，如裁剪、缩放、颜色调整、音频混音等，可以对音视频流进行实时处理。 - **网络流**：FFmpeg支持RTSP、HTTP、FTP等多种网络协议，能够进行实时流传输和...
FFmpeg 视频转换获取视频码率
11-17
在“FFmpeg 视频转换获取视频码率”这个主题中，我们将深入探讨如何使用 FFmpeg 来进行视频格式转换，特别是从 MOV 格式转换到 MP4，并且关注如何获取和控制视频的码率。 首先，MOV 和 MP4 都是常见的视频容器格式...
ffmpeg的库文件包
06-20
FFmpeg是一个开源项目，用于处理音频和视频文件。...此外，由于FFmpeg更新频繁，新版本可能会引入API变动，因此在项目中使用时要关注版本更新和兼容性问题。对于初学者，官方文档和在线示例代码是很好的学习资源。
FFMpeg 库 FFMpeg 库 FFMpeg 库(openGL课程编辑)
11-23
例如，可以使用它来裁剪视频、调整亮度和对比度，甚至进行复杂的颜色空间转换。 4. **libavutil**：基础通用函数库，包含数学函数、随机数生成、数据结构等，为其他FFmpeg库提供支持。 5. **libswscale**：色彩...
ffmpeg colorkey_options中的black对应的十六进制
weixin_34409357的博客
11-04 192
2019独角兽企业重金招聘Python工程师标准>>> ...
ass字幕导入Premiere的另一种思路 用ffmpeg把ass转换成颜色通道和透明度通道两个视频
flaribbit的博客
01-14 2958
突发奇想，为什么不能用这种方式导出视频呢。 转成视频，支持透明的视频只有avi(RGBA)和mov。但是前者显然不现实，因为太大了；后者速度太慢了。 然后就想到，为什么不能把alpha通道导出成另一个视频呢。得，要学complex filter了。 看了一番文档，这东西也挺容易理解的，基本语法是： -filter_complex [输入1]滤镜1[输出1];[输入2]滤镜2[输出2];... 于...
ffmpeg--libswscale（图像缩放、颜色空间和像素格式转换操作）
qq_42024067的博客
02-15 1108
主要函数： （1） sws_getContext()：使用参数初始化SwsContext结构体。 可以用另一个接口函数sws_getCachedContext()取代。 （2） sws_scale()：转换一帧图像。 （3） sws_freeContext()：释放SwsContext结构体。 初始化方式2种： ①sws_getContext ②sws_al...
FFmpeg中的Color颜色参数解析、转码和HDR
苦逼的程序猿☺
02-06 2739
视频中帧的颜色信息非常重要，表示着编码时用到的标准，意味着解码时也要对应上，或者要使用正确的转换函数，否则就会带来色差问题。
Gstreamer衬垫(pad)支持的媒体类型(三)
Android系统攻城狮
07-21 588
1.audio裸流： GST_STATIC_CAPS( "audio/x-raw, " "format = (string)S16LE, " "rate=(int){ 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000 }, " "channels = (int){1,2};" ) 2.audio-mp3： GST_STATIC_CAPS( "audio/mpeg, " "mpegver.
视音频数据处理入门：颜色空间(二)---ffmpeg
梁启东的博客
08-31 943
d
FFMPEG初探
qq_38613138的博客
03-17 3907
1.安装（ubuntu18.04） a.下载源码：git clone https://gitee.com/mirrors/ffmpeg.git b.编译：cd ffmpeg && ./configure --enable-gpl --enable-shared && make && make install 2.代码验证：根据《最简单的基于FFMPEG的Helloworld程序》-雷霄骅修改 hello.cpp ...
ffmpeg 类型介绍
qq_30828651的博客
06-03 245
类型avframe 类型中 uint8_t *data[AV_NUM_DATA_POINTERS]; 解码后的原始数据，视频数据是YUV 和RGB，音频数据是PCM）int linesize[AV_NUM_DATA_POINTERS];data中“一行“数据的大小，一般大于图像的宽int width, height; 对视频而言指视频的宽和高int nb_samples; 音频中一个AVFrame包含多个音频帧，表示音频帧的数量int format; 帧的格式，原始数据的类型int key_frame;
ffmpeg 视频转换YUV
10-19
在视频处理中，YUV格式也是一种常见的中间格式，FFmpeg是一个开源的跨平台音视频处理工具，可以用来进行音视频的编解码、转换、过滤等操作。其中，视频转换为YUV格式是FFmpeg的一个常见操作。 YUV是一种颜色编码...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

微澜-

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值