基于FPGA的RGB转换为Ycrcb的verilog源码

最新推荐文章于 2023-03-26 19:46:42 发布
最新推荐文章于 2023-03-26 19:46:42 发布
阅读量3.6k 收藏 8
点赞数
分类专栏： FPGA 板块2:图像-特征提取处理 文章标签： fpga RGB转Ycrcb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ccsss22/article/details/117724434
版权

`timescale 1ns/10ps
module RGB_YCbCr
 (
    Clock,
    Reset,
    IDEN,
    IHS,
    IVS,
    R,
    G,
    B,
    ODEN_RGB,
    OHS_RGB,
    OVS_RGB,
    Y_in,
    Cb_in,
    Cr_in
);
//
    parameter DATAWIDTH = 8;
//---------------------------------------------------------------------------------
//
    input[DATAWIDTH-1:0] R;
    input[DATAWIDTH-1:0] G;
    input[DATAWIDTH-1:0] B;
    input    Clock;
    input    Reset;
    input    IDEN;
    input    IHS;
    input    IVS;
//
    output ODEN_RGB;
    output OHS_RGB;
    output OVS_RGB;
    output[DATAWIDTH+3:0]Y_in;
    output[DATAWIDTH+3:0]Cb_in;
    output[DATAWIDTH+3:0]Cr_in;
//*********************************************************************************
//
  reg  IDEN_RGB_Reg0;
     reg  IDEN_RGB_Reg1;
    reg  IDEN_RGB_Reg2;
    reg  ODEN_RGB;
    
    reg  IHS_RGB_Reg0;
     reg  IHS_RGB_Reg1;
    reg  IHS_RGB_Reg2;
    reg  OHS_RGB;
    
    reg  IVS_RGB_Reg0;
     reg  IVS_RGB_Reg1;
    reg  IVS_RGB_Reg2;
    reg  OVS_RGB;
    
    always@(posedge Clock or negedge Reset) 
        begin
        if(!Reset)
           begin
              IDEN_RGB_Reg0<=1'b0;
              IDEN_RGB_Reg1<=1'b0;
              IDEN_RGB_Reg2<=1'b0;
                    ODEN_RGB<=1'b0;
             end
        else 
          begin
              IDEN_RGB_Reg0<=IDEN;
              IDEN_RGB_Reg1<=IDEN_RGB_Reg0;
              IDEN_RGB_Reg2<=IDEN_RGB_Reg1;
                    ODEN_RGB<=IDEN_RGB_Reg2;
           end
        end     
             
    always@(posedge Clock or negedge Reset) 
        begin
        if(!Reset)
           begin
              IHS_RGB_Reg0<=1'b0;
              IHS_RGB_Reg1<=1'b0;
              IHS_RGB_Reg2<=1'b0;
                 OHS_RGB<=1'b0;
           end
         else 
          begin
              IHS_RGB_Reg0<=IHS;
              IHS_RGB_Reg1<=IHS_RGB_Reg0;
              IHS_RGB_Reg2<=IHS_RGB_Reg1;
                    OHS_RGB<=IHS_RGB_Reg2;
           end
        end
        
    always@(posedge Clock or negedge Reset) 
        begin
        if(!Reset)
           begin
              IVS_RGB_Reg0<=1'b0;
              IVS_RGB_Reg1<=1'b0;
              IVS_RGB_Reg2<=1'b0;
                    OVS_RGB<=1'b0;
           end
         else 
          begin
              IVS_RGB_Reg0<=IVS;
              IVS_RGB_Reg1<=IVS_RGB_Reg0;
              IVS_RGB_Reg2<=IVS_RGB_Reg1;
                    OVS_RGB<=IVS_RGB_Reg2;
           end
        end

//*********************************************************************************
//
    reg [DATAWIDTH-1:0] R_Reg,G_Reg,B_Reg;
//        
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                R_Reg <= 8'b0;
                G_Reg <= 8'b0;
                B_Reg <= 8'b0;
            end
        else 
            begin
                R_Reg <= R;
                G_Reg <= G;
                B_Reg <= B;
            end
        end
//********************************************************************************
    wire[19:0]    Y_R1;
    wire[19:0]    Y_R1_temp;
    wire[15:0]    Y_R2;
    wire[19:0]    Y_R_sum;
    reg [19:0]    Y_R1_Reg;
    reg [15:0]    Y_R2_Reg;
    reg [19:0]    Y_R_sum_Reg;
//
  assign  Y_R1_temp = {R_Reg,11'b0}+{R_Reg,8'b0};
    assign  Y_R1 = Y_R1_temp + {R_Reg,1'b0};
    
    assign  Y_R2 = {R_Reg,7'b0}+{R_Reg,4'b0};
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Y_R1_Reg <= 20'b0;
                Y_R2_Reg <= 16'b0;
            end
        else
            begin
                Y_R1_Reg <= Y_R1;
                Y_R2_Reg <= Y_R2;
            end
        end
//

    assign  Y_R_sum = Y_R1_Reg+Y_R2_Reg;
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Y_R_sum_Reg <= 20'b0;
            end
        else
            begin
                Y_R_sum_Reg <= Y_R_sum;
            end
        end    
//-------------------------------------------------------------------------------    
    wire[20:0]    Y_G1;
    wire[20:0]    Y_G1_temp;
    wire[15:0]    Y_G2;
    wire[15:0]    Y_G2_temp;
    wire[20:0]    Y_G_sum;
    reg [20:0]    Y_G1_Reg;
    reg [15:0]    Y_G2_Reg;
    reg [20:0]    Y_G_sum_Reg;
//
    
    assign    Y_G1_temp = {G_Reg,12'b0}+{G_Reg,9'b0};
    assign    Y_G1 = Y_G1_temp + G_Reg;
    
    assign    Y_G2_temp = {G_Reg,7'b0}+{G_Reg,6'b0};
    assign    Y_G2 = Y_G2_temp+{G_Reg,3'b0};
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Y_G1_Reg <= 21'b0;
                Y_G2_Reg <= 16'b0;
            end
        else
            begin
                Y_G1_Reg <= Y_G1;
                Y_G2_Reg <= Y_G2;
            end
        end
//
    assign    Y_G_sum = Y_G1_Reg+Y_G2_Reg;
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Y_G_sum_Reg <= 21'b0;
            end
        else
            begin
                Y_G_sum_Reg <= Y_G_sum;
            end
        end    
//-------------------------------------------------------------------------------
    wire[17:0]    Y_B1;
    wire[17:0]    Y_B1_temp;
    
    wire[16:0]    Y_B2;
    wire[16:0]    Y_B2_temp;
    
    wire[17:0]    Y_B_sum;
    
    reg [17:0]    Y_B1_Reg;
    reg [16:0]    Y_B2_Reg;
    reg [17:0]    Y_B_sum_Reg;
//
    assign  Y_B1_temp = {B_Reg,9'b0}+{B_Reg,2'b0};
    assign    Y_B1 = Y_B1_temp+{B_Reg,1'b0};
    
    assign    Y_B2_temp ={B_Reg,8'b0}+{B_Reg,7'b0};
    assign    Y_B2 = {B_Reg,5'b0}+Y_B2_temp;
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Y_B1_Reg <= 18'b0;
                Y_B2_Reg <= 17'b0;
            end
        else
            begin
                Y_B1_Reg <= Y_B1;
                Y_B2_Reg <= Y_B2;
            end
        end
//
    assign    Y_B_sum = Y_B1_Reg+Y_B2_Reg;
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Y_B_sum_Reg <= 18'b0;
            end
        else
            begin
                Y_B_sum_Reg <= Y_B_sum;
            end
        end    
//-------------------------------------------------------------------------------
    wire[21:0]    Y_RGB_Sum;
    wire[21:0]    Y_RGB_Sum_temp;
    wire[11:0]   Y_RGB_Sum_limit;
    reg [11:0]      Y_in;

    assign     Y_RGB_Sum_temp = Y_R_sum_Reg+Y_G_sum_Reg;
    assign     Y_RGB_Sum = Y_RGB_Sum_temp+Y_B_sum_Reg;
    
  assign     Y_RGB_Sum_limit = Y_RGB_Sum[21:10];
//
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            Y_in <= 12'b0;
        else
                Y_in <= Y_RGB_Sum_limit[11:0];
        end
//********************************************************************************
//
    wire[18:0]    Cb_R1;
    wire[18:0]    Cb_R1_temp;
    wire[16:0]    Cb_R2;
    wire[16:0]    Cb_R2_temp;
    wire[18:0]    Cb_R_sum;
    reg [18:0]    Cb_R1_Reg;
    reg [16:0]    Cb_R2_Reg;
    reg [18:0]    Cb_R_sum_Reg;
//        

    assign    Cb_R1_temp = {R_Reg,10'b0}+{R_Reg,2'b0};
    assign    Cb_R1 = Cb_R1_temp+{R_Reg,1'b0};
    
    assign    Cb_R2_temp = {R_Reg,8'b0}+{R_Reg,6'b0};
    assign    Cb_R2 = Cb_R2_temp+{R_Reg,5'b0};
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Cb_R1_Reg <= 19'b0;
                Cb_R2_Reg <= 17'b0;
            end
        else
            begin
                Cb_R1_Reg <= Cb_R1;
                Cb_R2_Reg <= Cb_R2;
            end
        end
//        
    assign    Cb_R_sum = Cb_R1_Reg+Cb_R2_Reg;
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Cb_R_sum_Reg <= 19'b0;
            end
        else
            begin
                Cb_R_sum_Reg <= Cb_R_sum;
            end
        end
//---------------------------------------------------------------------------------        
//
    wire[19:0]    Cb_G1;
    wire[19:0]    Cb_G1_temp;
    wire[17:0]    Cb_G2;
    wire[17:0]    Cb_G2_temp;
    wire[19:0]    Cb_G_sum;
    reg [19:0]    Cb_G1_Reg;
    reg [17:0]    Cb_G2_Reg;
    reg [19:0]    Cb_G_sum_Reg;

    assign    Cb_G1_temp ={G_Reg,11'b0}+{G_Reg,3'b0};
    assign    Cb_G1 = Cb_G1_temp+{G_Reg,1'b0};
    
    assign    Cb_G2_temp ={G_Reg,9'b0}+{G_Reg,7'b0};
    assign    Cb_G2 = Cb_G2_temp+{G_Reg,4'b0};
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Cb_G1_Reg <= 20'b0;
                Cb_G2_Reg <= 18'b0;
            end
        else
            begin
                Cb_G1_Reg <= Cb_G1;
                Cb_G2_Reg <= Cb_G2;
            end
        end
//
    assign    Cb_G_sum = Cb_G1_Reg+Cb_G2_Reg;
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Cb_G_sum_Reg <= 20'b0;
            end
        else
            begin
                Cb_G_sum_Reg <= Cb_G_sum;
            end
        end    
//---------------------------------------------------------------------------------        
//    
    wire[20:0]    Cb_B;
    reg [20:0]    Cb_B_sum;
    reg [20:0]    Cb_B_sum_Reg;
    
    assign    Cb_B = {B_Reg,12'b0};
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Cb_B_sum <= 21'b0;
                Cb_B_sum_Reg <= 21'b0;
            end
        else
            begin
                Cb_B_sum <= Cb_B;
                Cb_B_sum_Reg <= Cb_B_sum;
            end
        end    
//---------------------------------------------------------------------------------    
//
    wire[21:0]    Cb_RGB_sum;
    wire[20:0]    Cb_RGB_sum_temp1;
    wire[20:0]    Cb_RGB_sum_temp2;
    wire[11:0]   Cb_RGB_sum_limit;
    reg [11:0]      Cb_in;
//
    assign     Cb_RGB_sum_temp1 = Cb_R_sum_Reg+Cb_G_sum_Reg;
    assign     Cb_RGB_sum_temp2 = Cb_B_sum_Reg;
        
    assign     Cb_RGB_sum = Cb_RGB_sum_temp2-Cb_RGB_sum_temp1;
    assign     Cb_RGB_sum_limit = Cb_RGB_sum[21:10]+12'd2048; 
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Cb_in <= 12'b0;
            end
        else
            begin
                  Cb_in<= Cb_RGB_sum_limit[11:0];
            end
        end
//*********************************************************************************
//
    wire[20:0]    Cr_R;
    reg [20:0]    Cr_R_Reg1;
    reg [20:0]    Cr_R_sum_Reg;
//
    assign    Cr_R = {R_Reg,12'b0};
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Cr_R_Reg1 <= 21'b0;
                Cr_R_sum_Reg <= 21'b0;
            end
        else
            begin
                Cr_R_Reg1 <= Cr_R;
                Cr_R_sum_Reg <= Cr_R_Reg1;
            end
        end
//---------------------------------------------------------------------------------    
// 
    wire[19:0]    Cr_G1;
    wire[19:0]    Cr_G1_temp1;
    wire[10:0]    Cr_G1_temp2;
    wire[18:0]    Cr_G2;
    wire[18:0]    Cr_G2_temp;
    wire[19:0]    Cr_G_sum;
    reg [19:0]    Cr_G1_Reg;
    reg [18:0]    Cr_G2_Reg;
    reg [19:0]    Cr_G_sum_Reg;
        
    assign  Cr_G1_temp1={G_Reg,11'b0}+{G_Reg,8'b0};
    assign  Cr_G1_temp2={G_Reg,2'b0}+{G_Reg,1'b0};
    assign    Cr_G1 = Cr_G1_temp1+Cr_G1_temp2;
    
    assign    Cr_G2_temp = {G_Reg,10'b0}+{G_Reg,6'b0};
    assign    Cr_G2 = Cr_G2_temp+{G_Reg,5'b0};
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Cr_G1_Reg <= 20'b0;
                Cr_G2_Reg <= 19'b0;
            end
        else
            begin
                Cr_G1_Reg <= Cr_G1;
                Cr_G2_Reg <= Cr_G2;
            end
        end
//
    assign    Cr_G_sum = Cr_G1_Reg+Cr_G2_Reg;
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Cr_G_sum_Reg <= 20'b0;
            end
        else
            begin
                Cr_G_sum_Reg <= Cr_G_sum;
            end
        end
//---------------------------------------------------------------------------------    
//
    wire[17:0]    Cr_B1;
    wire[17:0]    Cr_B1_temp;
    wire[15:0]    Cr_B2;
    wire[17:0]    Cr_B_sum;
    reg [17:0]    Cr_B1_Reg;
    reg [15:0]    Cr_B2_Reg;
    reg [17:0]    Cr_B_sum_Reg;
//
    assign  Cr_B1_temp={B_Reg,9'b0}+{B_Reg,3'b0};
    assign    Cr_B1 = Cr_B1_temp+{B_Reg,1'b0};
    
    assign    Cr_B2 = {B_Reg,7'b0}+{B_Reg,4'b0};
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Cr_B1_Reg <= 18'b0;
                Cr_B2_Reg <= 16'b0;
            end
        else
            begin
                Cr_B1_Reg <= Cr_B1;
                Cr_B2_Reg <= Cr_B2;
            end
        end
//    
    assign    Cr_B_sum = Cr_B1_Reg+Cr_B2_Reg;
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Cr_B_sum_Reg <= 18'b0;
            end
        else
            begin
                Cr_B_sum_Reg <= Cr_B_sum;
            end
        end
//---------------------------------------------------------------------------------    
    wire[21:0]    Cr_sum_Reg;
    wire[20:0]    Cr_sum_Reg_temp1;
    wire[20:0]    Cr_sum_Reg_temp2;
    wire[11:0]   Cr_sum_Reg_limit;
    reg [11:0]    Cr_in;

    assign  Cr_sum_Reg_temp1=Cr_R_sum_Reg;
    assign  Cr_sum_Reg_temp2=Cr_G_sum_Reg+Cr_B_sum_Reg;
    
    assign    Cr_sum_Reg = Cr_sum_Reg_temp1-Cr_sum_Reg_temp2;
    assign    Cr_sum_Reg_limit = Cr_sum_Reg[21:10]+12'd2048;
    
    always@(posedge Clock or negedge Reset)
        begin
        if(!Reset)
            begin
                Cr_in <= 12'b0;
            end
        else
            begin
                Cr_in <= Cr_sum_Reg_limit[11:0];
            end
        end
//**********************************************************************************        
endmodule
 

fpga和matlab
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
基于verilog的rgb图像转化为ycrcb颜色模型的图像
平时工作较为繁忙,私信消息一般晚上回复,谢谢大家~~
12-26 414
颜色空间又称为颜色模型（color model），是指按照某种规则或定义来描述所有颜色。常见的颜色空间有：RGB颜色空间、HSV 颜色空间、YCbCr 颜色空间、CMY 颜色空间等。RGB 颜色模型用于计算机的显示，HSV 颜色模型用于视觉系统处理，YCbCr 颜色模型用于表示彩色电视数字信号，CMY颜色模型用在印刷行业。不同的颜色空间体现的颜色特征不同，使用不同的颜色模型对图像颜色校正的效果有一定的影响。经过实验测试发现，在YCbCr颜色空间下，该算法的校正效果最佳。
【RGB-Ycrcb】基于FPGA的RGB图像转化为Ycrcb,分别采用直接相乘法，移位法，查表法以及分布式算法来实现
FPGA/MATLAB学习教程/源码/项目合作开发
05-20 1216
1.软件版本 ISE14.7 2.本算法理论知识 转换公式： 量化后的公式： 建设输入的信号为10位，那么我假设二进制数10_0000_0000代表十进制的1，那么上面的式子分别为： 0.299/1=x/（10_0000_0000）2，那么x=306（十进制） 所以上面的系数可以变为整数。那么转化公式为： 3.部分源码 a-直接相乘法： 直接相乘，我们直接调用系统的IP核，这里我们实用的IP核是ISE10.1版本的，如果版本不同，需要重新生成。如代码段中： 这里就是第一个公
RGB转YCrCb的verilog程序
08-13
RGB转YCrCb的verilog程序,并附有详细备注，测试好用，可综合的代码。
rgb转YCrCb
qqtolm的专栏
05-26 5901
YCrCb 　   YCrCb在视频压缩和一些数字图像处理中使用得比较多，是一种基于人眼感知的颜色空间。 　　在OpenCV中，从RGB空间转换到YCrCb空间的公式如下： 　　 　　注意从RGB到YcrCb的公式并不是唯一的，     例如一般使用的公式如下：     // Y  = 0.2990R + 0.5870G + 0.1140B     // Cb = -0.1687R
m基于FPGA的RGB转ycrcb颜色空间转换算法实现,包含testbench,对比三种转换方法
最新发布
fpga/matlab/simulink算法仿真工程
03-26 783
然而,普通的R GB颜色空间对视频的显示存在很多问题,将其转换为YCbCr颜色空间能够很 好地适应现代社会的要求,本文正是采用一种新的方法,通过FPGA成功地将其转化,并得到正确的结果,此方法内 部变量少、算法优点突出、实时性好,十分易于在实际工程中实现。在RGB颜色空间中,1个带颜色的图像采样是用3个 值来表示一个像素点的相对的红、绿和蓝色比(3种光线的 主样构成颜色)。将输入信号的每一位和另一个数相乘，通过10级流水线操作后，我们可以得到10个部分积，然后将10个部分积累加，得到最后的结果。
颜色空间转换RGB to YCrCb
02-23
实现颜色空间的转换
RGBtoYCrCb.v
07-09
verilog语言实现RGB图像转YCrCb灰度图，定点数操作，流水线操作，大大提高了吞吐率。欢迎访问主页下载其他内容
YCbCr2转换成RGB的verilog解析
a14730497的专栏
01-05 6438
module YCbCr2RGB ( 2   input        iCLK, 3   input        iRESET, 4   input        iDVAL, 5   input  [7:0] iY, 6   input  [7:0] iCb, 7   input  [7:0] iCr, 8   output reg  
基于FPGA的RGB到YCrCb颜色空间转换
01-19
0 引 言 　随着多媒体和通信技术的发展，视频图像处理的实时性成为人们关注的...RGB基于三基色原理，颜色实现简单，在计算机、电视机显示系统中应用广泛，YCrCb将颜色的亮度信号与色度信号分离，易于实现压缩，方便传
基于FPGA的rgb转化为ycrcb的颜色模型转化算法,verilog编程实现,带testbench+含代码操作演示视频
05-18
基于FPGA的rgb转化为ycrcb的颜色模型转化算法,verilog编程实现,带testbench+含代码操作演示视频 运行注意事项：使用matlab2021a或者更高版本测试，运行里面的Runme.m文件，不要直接运行子函数文件。运行时注意matlab左侧的当前文件夹窗口必须是当前工程所在路径。具体可观看提供的操作录像视频跟着操作。
RGB转YCrCb Verilog代码
04-10
RGB转YCrCb Verilog代码 可综合
RGB 转换为 Y Cr Cb：将彩色图像转换为不同的形式-matlab开发
05-30
此功能对于将彩色图像转换为 YCrCb 格式或将 YCrCb 转换为 RGB 格式非常重要.... 此功能广泛用于数字图像处理和压缩技术。
基于FPGA的RGB到YCbCr色空间转换
09-18
基于FPGA的RGB到YCbCr色空间转换
EDA/PLD中的基于FPGA的RGB到YCrCb颜色空间转换
11-06
0 引 言 　随着多媒体和通信技术的发展，视频图像处理的实时性成为人们关注的...RGB基于三基色原理，颜色实现简单，在计算机、电视机显示系统中应用广泛，YCrCb将颜色的亮度信号与色度信号分离，易于实现压缩，方便传
基于FPGA的rgb转化为ycrcb的颜色模型转化算法,verilog编程实现,带testbench-源码
09-30
8. **设计流程**：设计FPGA RGB到YCbCr转换器通常包括以下步骤：理解颜色转换算法、用Verilog编写代码、编写Testbench、仿真验证、综合与布局布线、下载到FPGA硬件进行测试。 9. **优化考虑**：在FPGA设计中，需要...
Verilog语言编写 RGB文件转YCbCr模块
tulaling的博客
01-15 3264
YCbCr是色彩空间的一种，通常会用于影片中的影像连续处理，或是数字摄影系统中。Y(luminance)为颜色的亮度和浓度、Cb（chrominance-blue）为蓝色色度分量，Cr(chrominance-rad)则为红色色度分量。 从摄像头采集到的RGB数据转换到显示器使用的YCbCr数据，按照官方给出的计算公式 Y = 0.299 R + 0.587 G + 0.114 B Cb = -0.1687 R - 0.3313 G + 0.5 B + 128 Cr= 0.5 R - 0...
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

fpga和matlab

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

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

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

打赏作者

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

抵扣说明：

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

余额充值