JPEG标准DCT优化实现

最新推荐文章于 2023-10-12 23:31:31 发布
最新推荐文章于 2023-10-12 23:31:31 发布
阅读量3.4k 收藏 13
点赞数 4
分类专栏： 视频编解码 文章标签： JPEG DCT 蝶形变换 libjpeg libjpeg-turbo
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shakingwaves/article/details/77620388
版权

1.  JPEG DCT

JPEG是众多常见的图像编码格式之一，主要分为无损压缩和有损压缩，无损压缩主要利用空域相关性进行预测，主要用于医学、卫星遥感等领域；而有损压缩主要通过DCT变换，然后进行量化来压缩数据。与现有的H264和H265视频编码标准中的整数DCT变换不同，JPEG中的DCT是浮点变换。为了加快DCT运算速度，libjpeg使用了三种DCT算法：分别是浮点DCT变换、整数化的DCT变换、快速整数DCT变换，由于硬件特性浮点DCT变换可能表现出不同的结果，整数化的DCT变换是将浮点值扩大2的幂次方倍(比如2的13次方倍)，快速整数DCT变换也是整数化的DCT变换，但精度更小，误差更大。

1.1.JPEG DCT原理

在JPEG中是以8×8大小的图像块作为DCT变换的单位。8×8二维DCT定义如下：

可以将其转换为如下公式，

其中，矩阵A的值如下所示：

2.  JPEG DCT蝶形变换

由于浮点运算和乘法运算比较耗时，所以libjpeg在做DCT变换的时候，采用了蝶形变换，通过合并同类项等，将乘法转换为加法，大大减少了运算量。

2.1.常规JPEG DCT蝶形变换

       Libjpeg中的蝶形变换主要使用了“PRACTICAL FAST 1-D DCTALGORITHMS

WITH 11 MULTIPLICATIONS”文章中的算法。如下图1(a)所示，该图中 应该改为 ，图1(b)中O1写了2次，应该为一个O0一个O1。

 

(a)蝶形变换                                  (b)注释

图1. LLM蝶形变换

 

将矩阵A和一个8×8的像素块按照矩阵乘法进行展开。可以得到如下的结果。

 

out[0]  = a * ((in[0] + in[7]) + (in[3] + in[4])) + a * ((in[1] + in[6]) + (in[2] + in[5]));
out[4]  = a * ((in[0] + in[7]) + (in[3] + in[4])) - a * ((in[2] + in[5]) + (in[1] + in[6]));
out[2]  = c * ((in[0] + in[7]) - (in[3] + in[4])) + f * ((in[1] + in[6]) - (in[2] + in[5]))
        = sin(6. * M_PI / 16.) * ((in[0] + in[7]) - (in[3] + in[4])) 
        + cos(6. * M_PI / 16.) * ((in[1] + in[6]) - (in[2] + in[5]));
out[6]  = f * ((in[0] + in[7]) - (in[3] + in[4])) + c * ((in[2] + in[5]) - (in[1] + in[6]))
        = cos(6. * M_PI / 16.) * ((in[0] + in[7]) - (in[3] + in[4]))
        - sin(6. * M_PI / 16.) * ((in[1] + in[6]) - (in[2] + in[5]));

out[3]  = d * (in[0] - in[7]) - g * (in[1] - in[6]) - b * (in[2] - in[5]) - e * (in[3] - in[4])
        = cos(3. * M_PI / 16.) * (in[0] - in[7]) - cos(7. * M_PI / 16.) * (in[1] - in[6]) 
        - cos(1. * M_PI / 16.) * (in[2] - in[5]) - cos(5. * M_PI / 16.) * (in[3] - in[4])
        = cos(3. * M_PI / 16.) * (in[0] - in[7]) - sin(1. * M_PI / 16.) * (in[1] - in[6])
        - cos(1. * M_PI / 16.) * (in[2] - in[5]) - sin(3. * M_PI / 16.) * (in[3] - in[4])
        = cos(3. * M_PI / 16.) * (in[0] - in[7]) - sin(3. * M_PI / 16.) * (in[3] - in[4])
        - cos(1. * M_PI / 16.) * (in[2] - in[5]) - sin(1. * M_PI / 16.) * (in[1] - in[6]);

out[5]  = e * (in[0] - in[7]) - b * (in[1] - in[6]) + g * (in[2] - in[5]) + d * (in[3] - in[4])
        = cos(5. * M_PI / 16.) * (in[0] - in[7]) - cos(1. * M_PI / 16.) * (in[1] - in[6])
        + cos(7. * M_PI / 16.) * (in[2] - in[5]) + cos(3. * M_PI / 16.) * (in[3] - in[4])
        = sin(3. * M_PI / 16.) * (in[0] - in[7]) - cos(1. * M_PI / 16.) * (in[1] - in[6])
        + sin(1. * M_PI / 16.) * (in[2] - in[5]) + cos(3. * M_PI / 16.) * (in[3] - in[4])
        = sin(3. * M_PI / 16.) * (in[0] - in[7]) + cos(3. * M_PI / 16.) * (in[3] - in[4])
        + sin(1. * M_PI / 16.) * (in[2] - in[5]) - cos(1. * M_PI / 16.) * (in[1] - in[6]);

out[1]  = b * (in[0] - in[7]) + d * (in[1] - in[6]) + e * (in[2] - in[5]) + g * (in[3] - in[4])
        = cos(1. * M_PI / 16.) * (in[0] - in[7]) + cos(3. * M_PI / 16.) * (in[1] - in[6])
        + cos(5. * M_PI / 16.) * (in[2] - in[5]) + cos(7. * M_PI / 16.) * (in[3] - in[4])
        = cos(1. * M_PI / 16.) * (in[0] - in[7]) + sin(1. * M_PI / 16.) * (in[3] - in[4])
        + sin(3. * M_PI / 16.) * (in[2] - in[5]) + cos(3. * M_PI / 16.) * (in[1] - in[6]);
        = cos((4. - 3.) * M_PI / 16.) * (in[0] - in[7])
        + cos((4. + 3.) * M_PI / 16.) * (in[3] - in[4])
        + cos((4. + 1.) * M_PI / 16.) * (in[2] - in[5])
        + cos((4. - 1.) * M_PI / 16.) * (in[1] - in[6])
        = (cos(4. * M_PI / 16.) * cos(3. * M_PI / 16.) + cos(4. * M_PI / 16.) * sin(3. * M_PI / 16.)) * (in[0] - in[7])
        + (cos(4. * M_PI / 16.) * cos(3. * M_PI / 16.) - cos(4. * M_PI / 16.) * sin(3. * M_PI / 16.)) * (in[3] - in[4])
        + (cos(4. * M_PI / 16.) * cos(1. * M_PI / 16.) - cos(4. * M_PI / 16.) * sin(1. * M_PI / 16.)) * (in[2] - in[5])
        + (cos(4. * M_PI / 16.) * cos(1. * M_PI / 16.) + cos(4. * M_PI / 16.) * sin(1. * M_PI / 16.)) * (in[1] - in[6])
        = sqrt(1 / 2) * (cos(3. * M_PI / 16.) + sin(3. * M_PI / 16.)) * (in[0] - in[7])
        + sqrt(1 / 2) * (cos(3. * M_PI / 16.) - sin(3. * M_PI / 16.)) * (in[3] - in[4])
        + sqrt(1 / 2) * (cos(1. * M_PI / 16.) - sin(1. * M_PI / 16.)) * (in[2] - in[5])
        + sqrt(1 / 2) * (cos(1. * M_PI / 16.) + sin(1. * M_PI / 16.)) * (in[1] - in[6])
        = sqrt(1 / 2) * (cos(3. * M_PI / 16.) * (in[0] - in[7]) - sin(3. * M_PI / 16.) * (in[3] - in[4]))
        + sqrt(1 / 2) * (sin(3. * M_PI / 16.) * (in[0] - in[7]) + cos(3. * M_PI / 16.) * (in[3] - in[4]))
        + sqrt(1 / 2) * (cos(1. * M_PI / 16.) * (in[2] - in[5]) + sin(1. * M_PI / 16.) * (in[1] - in[6]))
        + sqrt(1 / 2) * (-sin(1. * M_PI / 16.) * (in[2] - in[5]) + cos(1. * M_PI / 16.) * (in[1] - in[6]))

out[7]  = g * (in[0] - in[7]) - e * (in[1] - in[6]) + d * (in[2] - in[5]) - b * (in[3] - in[4])
        = cos(7. * M_PI / 16.) * (in[0] - in[7]) - cos(5. * M_PI / 16.) * (in[1] - in[6]) 
        + cos(3. * M_PI / 16.) * (in[2] - in[5]) - cos(1. * M_PI / 16.) * (in[3] - in[4])
        = cos((4. + 3.) * M_PI / 16.) * (in[0] - in[7]) - cos((4 -3) * M_PI / 16.) * (in[3] - in[4])
        - cos((4 + 1) * M_PI / 16.) * (in[1] - in[6]) + cos((4 - 1) * M_PI / 16.) * (in[2] - in[5]) 
        = sqrt(1 / 2) * (cos(3. * M_PI / 16.) - sin(3. * M_PI / 16.)) * (in[0] - in[7])
        - sqrt(1 / 2) * (cos(3. * M_PI / 16.) + sin(3. * M_PI / 16.)) * (in[3] - in[4])
        - sqrt(1 / 2) * (cos(1. * M_PI / 16.) - sin(1. * M_PI / 16.)) * (in[1] - in[6])
        + sqrt(1 / 2) * (cos(1. * M_PI / 16.) + sin(1. * M_PI / 16.)) * (in[2] - in[5])
        = sqrt(1 / 2) * (cos(3. * M_PI / 16.) * (in[0] - in[7]) - sin(3. * M_PI / 16.) * (in[3] - in[4]))
        - sqrt(1 / 2) * (sin(3. * M_PI / 16.) * (in[0] - in[7]) + cos(3. * M_PI / 16.) * (in[3] - in[4]))
        - sqrt(1 / 2) * (cos(1. * M_PI / 16.) * (in[1] - in[6]) - sin(1. * M_PI / 16.) * (in[2] - in[5]))
        + sqrt(1 / 2) * (sin(1. * M_PI / 16.) * (in[1] - in[6]) + cos(1. * M_PI / 16.) * (in[2] - in[5]))

所以，图1(a)的具体实现如下：

 

// Naive implementation of LLM DCT.
// Easier to read, but uses more multiplications for rotation.
void llm_dct(const double in[8], double out[8]) {
  // After stage 1:
  const double s1_0 =  in[0] + in[7];
  const double s1_1 =  in[1] + in[6];
  const double s1_2 =  in[2] + in[5];
  const double s1_3 =  in[3] + in[4];
  const double s1_4 = -in[4] + in[3];
  const double s1_5 = -in[5] + in[2];
  const double s1_6 = -in[6] + in[1];
  const double s1_7 = -in[7] + in[0];

  // After stage 2:
  const double s2_0 =  s1_0 + s1_3;
  const double s2_1 =  s1_1 + s1_2;
  const double s2_2 = -s1_2 + s1_1;
  const double s2_3 = -s1_3 + s1_0;

  const double s2_4 =  s1_4 * cos(3. * M_PI / 16.) + s1_7 * sin(3. * M_PI / 16.);
  const double s2_7 = -s1_4 * sin(3. * M_PI / 16.) + s1_7 * cos(3. * M_PI / 16.);

  const double s2_5 =  s1_5 * cos(1. * M_PI / 16.) + s1_6 * sin(1. * M_PI / 16.);
  const double s2_6 = -s1_5 * sin(1. * M_PI / 16.) + s1_6 * cos(1. * M_PI / 16.);

  // After stage 3:
  const double s3_0 =  s2_0 + s2_1;
  const double s3_1 = -s2_1 + s2_0;

  const double s3_2 = sqrt(2.) * ( s2_2 * cos(6. * M_PI / 16.) + s2_3 * sin(6. * M_PI / 16.));
  const double s3_3 = sqrt(2.) * (-s2_2 * sin(6. * M_PI / 16.) + s2_3 * cos(6. * M_PI / 16.));

  const double s3_4 =  s2_4 + s2_6;
  const double s3_5 = -s2_5 + s2_7;
  const double s3_6 = -s2_6 + s2_4;
  const double s3_7 =  s2_7 + s2_5;

  // After stage 4:
  const double s4_4 = -s3_4 + s3_7;
  const double s4_5 =  s3_5 * sqrt(2.);
  const double s4_6 =  s3_6 * sqrt(2.);
  const double s4_7 =  s3_7 + s3_4;

  // Shuffle and scaling:
  out[0] = s3_0 / sqrt(8.);
  out[4] = s3_1 / sqrt(8.);
  out[2] = s3_2 / sqrt(8.);
  out[6] = s3_3 / sqrt(8.);
  out[7] = s4_4 / sqrt(8.);
  out[3] = s4_5 / sqrt(8.);
  out[5] = s4_6 / sqrt(8.);
  out[1] = s4_7 / sqrt(8.);
}

2.2.旋转操作

在LLM蝶形变换的stage2和stage3阶段用到的乘法和加法操作较多，可以通过旋转操作的方法，减少运算，如图2所示。

 

图2. 旋转操作

 

 

 

旋转操作的基本算法如下：

void rot1(const double x1, const double y1, const double theta,
          double* x2, double* y2) {
  const double s = sin(theta);
  const double c = cos(theta);
  *x2 = x1 * c - y1 * s;
  *y2 = y1 * c + x1 * s;
}

该操作需要4个乘法，1个加法，1个减法。

 

对基本的操作进行一些变形可以得到如下所示的算法：

void rot2(const double x1, const double y1, const double theta,
          double* x2, double* y2) {
  const double s = sin(theta);
  const double c = cos(theta);
  const double z = x1 * (s + c);
  *x2 = z - (x1 + y1) * s;
  *y2 = z + (y1 - x1) * c;
}

该操作需要3个乘法，3个加法，2个减法

如果旋转的角度是个常量，可以优化成下面所示的算法：

void rot3(const double x1, const double y1,
          double* x2, double* y2) {
  const double s = sin(1. * M_PI / 16.);
  const double c = cos(1. * M_PI / 16.);
  const double z = c * (x1 + y1);
  *x2 = (-s-c) * y1 + z;
  *y2 = ( s-c) * x1 + z;
}

该操作需要3个乘法3个加法，因为(-s-c)和(s-c)是常量，可以提前计算他们的值。

经过旋转优化后的蝶形变换算法如下所示：

// Implementation of LLM DCT.
void llm_dct(const double in[8], double out[8]) {
  // Constants:
  const double s1 = sin(1. * M_PI / 16.);
  const double c1 = cos(1. * M_PI / 16.);
  const double s3 = sin(3. * M_PI / 16.);
  const double c3 = cos(3. * M_PI / 16.);
  const double r2s6 = sqrt(2.) * sin(6. * M_PI / 16.);
  const double r2c6 = sqrt(2.) * cos(6. * M_PI / 16.);

  // After stage 1:
  const double s1_0 =  in[0] + in[7];
  const double s1_1 =  in[1] + in[6];
  const double s1_2 =  in[2] + in[5];
  const double s1_3 =  in[3] + in[4];
  const double s1_4 = -in[4] + in[3];
  const double s1_5 = -in[5] + in[2];
  const double s1_6 = -in[6] + in[1];
  const double s1_7 = -in[7] + in[0];

  // After stage 2:
  const double s2_0 =  s1_0 + s1_3;
  const double s2_1 =  s1_1 + s1_2;
  const double s2_2 = -s1_2 + s1_1;
  const double s2_3 = -s1_3 + s1_0;

  const double z1 = c3 * (s1_7 + s1_4);
  const double s2_4 = ( s3-c3) * s1_7 + z1;
  const double s2_7 = (-s3-c3) * s1_4 + z1;

  const double z2 = c1 * (s1_6 + s1_5);
  const double s2_5 = ( s1-c1) * s1_6 + z2;
  const double s2_6 = (-s1-c1) * s1_5 + z2;

  // After stage 3:
  const double s3_0 =  s2_0 + s2_1;
  const double s3_1 = -s2_1 + s2_0;

  const double z3 = r2c6 * (s2_3 + s2_2);
  const double s3_2 = ( r2s6-r2c6) * s2_3 + z3;
  const double s3_3 = (-r2s6-r2c6) * s2_2 + z3;

  const double s3_4 =  s2_4 + s2_6;
  const double s3_5 = -s2_5 + s2_7;
  const double s3_6 = -s2_6 + s2_4;
  const double s3_7 =  s2_7 + s2_5;

  // After stage 4:
  const double s4_4 = -s3_4 + s3_7;
  const double s4_5 =  s3_5 * sqrt(2.);
  const double s4_6 =  s3_6 * sqrt(2.);
  const double s4_7 =  s3_7 + s3_4;

  // Shuffle and scaling:
  out[0] = s3_0 / sqrt(8.);
  out[4] = s3_1 / sqrt(8.);
  out[2] = s3_2 / sqrt(8.);
  out[6] = s3_3 / sqrt(8.);
  out[7] = s4_4 / sqrt(8.);
  out[3] = s4_5 / sqrt(8.);  // Alternative: s3_5 / 2
  out[5] = s4_6 / sqrt(8.);
  out[1] = s4_7 / sqrt(8.);
}

2.3.JPEG DCT奇数部分优化

上图中的奇数部分算法最多的时候需要2个乘法操作，仍然不够优化，所以论文中对奇数部分的y1、y3、y5和y7使用了新的算法，如图3所示。图3(a)中，i0、i1、i2和i3是图1(a)中stage2部分的输入，例如：y7=-c1*i0+c3*i1-c5*i2+c7*i3。

(a)

(b)

(c)

(d)

图3. 奇数部分优化

图3(b)和3(c)是根据3(a)进行的扩展优化，最终得到图(d)所示的蝶形变换图。

shakingWaves
关注
  • 4
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
DCT/IDCT 硬件实现
06-21
DCT IDCT核使用verilog编写的，用到了stratix中的乘加模块。 压缩包里共有两个核
jpeg2dct
05-11
直接来自JPEG的更快的神经网络：jpeg2dct子例程 该存储库包含源代码，这些源代码可用于再现 （ICLR workshop 2018）中提出的结果： @inproceedings{gueguen_2018_ICLR title={Faster Neural Networks Straight from JPEG}, author={Lionel Gueguen and Alex Sergeev and Ben Kadlec and Rosanne Liu and Jason Yosinski}, booktitle={International Conference on Learning Representations}, year={2018} } jpeg2dct子例程 jpeg2dct库提供了本机Python函数和TensorFlow运算符，可从JPEG格式
基于DCT变换图像去噪算法的进一步优化（100W像素30ms）
weixin_39450742的博客
07-01 1457
本篇博文来自博主Imageshop，打赏或想要查阅更多内容可以移步至Imageshop。 转载自：https://www.cnblogs.com/Imageshop/p/9584024.html侵删 　　在优化IPOL网站中基于DCT（离散余弦变换）的图像去噪算法（附源代码）一文中，我们曾经优化过基于DCT变换的图像去噪算法，在那文所提供的Demo中，处理一副1000*1000左右的灰度噪音图像耗时约450ms，如果采用所谓的快速模式耗时约150ms，说实在的，这个速度确实还是有点慢，后续曾尝试...
JPEG编码器的硬件实现
wudpekerlily的博客
03-30 568
JPEG编码器的硬件实现
mpeg 变换DCT
deyangliu的专栏
08-19 1290
uncorrelated image has more sharp intensity vairations--> has more high frequency content. has its energy spread out low spatial content energy compactiioncorrelation 1维N点FDCT和IDCT:  C(u) =\
理解JPEG图像压缩算法,DCT变换
nemo的博客
07-03 1万+
理解JEPG原理 JEPG不是一种文件格式,而是一类图像压缩算法. 1.彩色图像 灰度图像 灰度,一个pixel取值0-255. 彩色图像 需要比灰度图像更多的存储空间, 事实上, 所有颜色都可以用红绿蓝三原色的组合表示, 彩色图像可用RGB三通道表示. YCbCr 研究发现对于图像压缩, RGB的表示不是最佳的. 人脑对亮度(luminance)和色差(...
数据压缩实验5——JPEG编解码
JCL的博客
06-06 1119
1 实验目的 掌握JPEG编解码系统的基本原理。初步掌握复杂的数据压缩算法实现，并能根据理论分析需要实现所对应数据的输出。 2 JPEG编解码原理 两张量化表——亮度，色度 四张Huffman码表——亮度DC，亮度AC，色度DC，色度AC 2.1 Level Offset 零偏置 对于灰度级是 2n 的像素，通过减去 2n-1 ，将无符号的整数值变成有符号数。 例如：n=8，灰度级0 ~ 255，通过减去128，转化为-128 ~ 127 目的：使像素的绝对值出现3位10进制的概率大大降低。
对于灰度图的二维离散余弦变换
最新发布
misszzs2002的博客
10-12 722
离散余弦变换(Discrete Cosine Transform)，简称DCT变换，能够将空域的信号转换到频域上，在这个专题中就是将二维的像素值转换为二维的频率信号。
JPEG压缩原理与DCT离散余弦变换
热门推荐
newchenxf的专栏
06-20 6万+
入门介绍----JPEG压缩原理与DCT离散余弦变换，能让你有个大致的理解。
Practical Fast 1-D DCT Algorithms with 11 Mutltiplications
01-15
LLM格式的DCT快速算法 论文 学习FFMPEG ， x264 等压缩技术会用到。
JPEG-DCT代码
08-31
JPEG-DCT 代码
JPEG.rar_jpeg encoder dct
09-24
JPEG编码硬件加速器，采用DCT算法，其中含有skew circular convolution单元，其构架设计能以精简的电路，同时满足DCT与IDCT的需求。
DCT与JPEG编码
11-22
PPT讲述了JPEG编码中DCT变换的理论推导和实际应用。。。
dct.rar_JPEG DCT_jpeg compression
09-24
jpeg compression and expansion :P
JPEG解码原理详解
shakingWaves的专栏
09-03 1万+
1.  JPEG JPEG是众多常见的图像编码格式之一，主要分为无损压缩和有损压缩，无损压缩利用空域相关性进行预测，主要用于医学、卫星遥感等领域；有损压缩主要通过DCT变换，然后进行量化来压缩数据。本文将以一个简单的16×8灰度图像作为例子，简单讲述JPEG图像解码的主要过程。 1.1.JPEG图片结构        图1(a)所示的图片是一个简单的16×8的JPEG灰度图片，是由图1(b)
CABAC 基础二-算术编码
shakingWaves的专栏
09-03 8758
1.  算术编码 与变长编码不同，算术编码的本质是为整个输入序列分配一个码字，而不是给每个字符分别指定码字，因此平均意义上可以为单个字符分配码长小于1的码字。 算术编码用到两个基本的参数：符号的概率和它的编码间隔。信源符号的概率决定压缩编码的效率，也决定编码过程中信源符号的间隔，而这些间隔包含在L到H之间。编码过程中的间隔决定了符号压缩后的输出。 给定事件序列的算术编码步骤如下： 1.
CABAC基础四-CABAC熵解码算法FFmpeg实现
shakingWaves的专栏
11-06 5197
1.  CABAC熵解码算法FFmpeg实现 本章主要讲解FFmpeg中对CABAC熵解码算法的实现和优化思路。由于算术编码算术在H264和H265中没有发生变化，所以FFmpeg中H265的熵解码仍然采用了H264中的实现方式，所以，在H265的CABAC部分，仍然可以看到有的数组的定义中带有H264的名字，如ff_h264_lps_range和ff_h264_mlps_state等等。 1
VLC一--零阶指数哥伦布码解码原理和实现
shakingWaves的专栏
12-18 4691
指数哥伦布编码属于变长编码，其基本原理是用短码字表示出现频率较高的信息，用长码字表示出现频率较低的信息。      1.1.  指数哥伦布编解码原理 指数哥伦布编码也是变长编码的一种，指数哥伦布编码也是由前缀和后缀组成。K阶指数哥伦布码的组成如图1(a)所示：分为m个前缀0，一个比特1和m+k个后缀。解析时首先从比特流当前位置开始寻找第一个非零比特，并将找到的0比特个数记为m，第一个非零比特
jpeg压缩纯c语言实现
07-14
对于完整的JPEG压缩实现，需要进一步深入学习和理解相关的JPEG标准和算法。 ### 回答2： JPEG（Joint Photographic Experts Group）是一种广泛应用于图像压缩的标准。实现JPEG图像压缩算法可以通过纯C语言编写。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值