红薯 video4linux2编程实例

最新推荐文章于 2023-11-26 15:52:35 发布
最新推荐文章于 2023-11-26 15:52:35 发布
阅读量1.2k 收藏
点赞数
分类专栏： video4linux2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/adrian169/article/details/9328475
版权

http://www.oschina.net/code/snippet_12_368?from=rss

         使用video4linux2编程接口，获得笔记本摄像头影像后，用SDL显示在X Window下的情景
关键点有二：
其一，从video4linux2的编程接口笔者了解到其笔记本摄像头支持YUYV视频帧格式，显示在SDL上需要将YUYV格式转换成SDL支持的显示格式RGB。
其二，要学会使用video4linux2获得摄像头YUYV数据流的程序框架。

YUV到RGB颜色空间的转换，可阅读video4linux2的文献，网址如下：
http://www.linuxtv.org/downloads/video4linux/API/V4L2_API/spec/ch02s02.html

YUYV数据流每个字节的含义，可阅读video4linux2的文献，网址如下：
http://www.linuxtv.org/downloads/video4linux/API/V4L2_API/spec/re09.html

举个例子，4x4像素的视频帧，内存中每个字节的存放情况如下：
start + 0:  Y'[00] Cb[00] Y'[01] Cr[00] Y'[02] Cb[01] Y'[03] Cr[01]
start + 8:  Y'[10] Cb[10] Y'[11] Cr[10] Y'[12] Cb[11] Y'[13] Cr[11]
start + 16: Y'[20] Cb[20] Y'[21] Cr[20] Y'[22] Cb[21] Y'[23] Cr[21]
start + 24: Y'[30] Cb[30] Y'[31] Cr[30] Y'[32] Cb[31] Y'[33] Cr[31]
一个Y'对应一个视频帧的像素。
[swc目录结构]
--------------------------------------------------------------------
.
|-- Makefile
|-- book-2010-05-21
|-- opt.c
|-- opt.h
|-- screen.c
|-- screen.h
|-- swc.c
|-- video.c
`-- video.h
标签： <无>

代码片段(8)[全屏查看所有代码]

1. [代码]Makefile    

01CC = gcc
02CFLAGS = -Wall -Werror -Wcast-align -g
03LDFLAGS =
04 
05SWCOBJECT = swc.o opt.o video.o screen.o
06 
07all: swc
08 
09swc: $(SWCOBJECT)
10    $(CC) $(LDFLAGS) `pkg-config --libs sdl` $(SWCOBJECT) -o $@
11 
12swc.o: swc.c
13    $(CC) $(CFLAGS) `pkg-config --cflags sdl` -c $<
14 
15opt.o: opt.c opt.h
16    $(CC) $(CFLAGS) -c $<
17 
18video.o: video.c video.h
19    $(CC) $(CFLAGS) -c $<
20 
21screen.o: screen.c screen.h
22    $(CC) $(CFLAGS) `pkg-config --cflags sdl` -c $<
23 
24clean:
25    rm -f *.o *~ swc
26 
27.PHONY: all clean

2. [代码]screen.h    

01#ifndef SCREEN_H
02#define SCREEN_H
03 
04#include <SDL.h>
05 
06struct rgb_surface {
07  SDL_Surface *surface;
08  unsigned int rmask;
09  unsigned int gmask;
10  unsigned int bmask;
11  unsigned int amask;
12  int width;
13  int height;
14  int bpp;
15  int pitch;
16  unsigned char *pixels;
17  int pixels_num;
18};
19 
20struct screen {
21  SDL_Surface *display;
22  SDL_Event event;
23  int width;
24  int height;
25  int bpp;
26  int running;
27  struct rgb_surface rgb;
28};
29 
30void screen_init();
31void screen_quit();
32void screen_mainloop();
33 
34#endif

3. [代码]opt.h    

01#ifndef OPT_H
02#define OPT_H
03 
04struct options {
05  int verbose;
06  int width;
07  int height;
08};
09 
10void options_init();
11void options_deal(int argc, char *argv[]);
12 
13#endif

4. [代码]screen.c    

001#include <stdio.h>
002#include <stdlib.h>
003#include <string.h>
004#include "screen.h"
005#include "opt.h"
006#include "video.h"
007 
008extern struct options opt;
009extern struct video video;
010struct screen screen;
011 
012static void sdl_init();
013static void create_rgb_surface();
014static void update_rgb_surface(int index);
015static void update_rgb_pixels(const void *start);
016static void yuv2rgb(unsigned char Y,
017            unsigned char Cb,
018            unsigned char Cr,
019            int *ER,
020            int *EG,
021            int *EB);
022static int clamp(double x);
023 
024static void
025sdl_init()
026{
027  if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER | SDL_INIT_EVENTTHREAD) < 0) {
028    perror("SDL_Init");
029    exit(EXIT_FAILURE);
030  }
031  SDL_WM_SetCaption("Simple WebCam", NULL);
032  atexit(SDL_Quit);
033}
034 
035static void
036create_rgb_surface()
037{
038  screen.rgb.rmask = 0x000000ff;
039  screen.rgb.gmask = 0x0000ff00;
040  screen.rgb.bmask = 0x00ff0000;
041  screen.rgb.amask = 0xff000000;
042  screen.rgb.width = screen.width;
043  screen.rgb.height = screen.height;
044  screen.rgb.bpp = screen.bpp;
045  screen.rgb.pitch = screen.width * 4;
046  screen.rgb.pixels_num = screen.width * screen.height * 4;
047  screen.rgb.pixels = (unsigned char *)malloc(screen.rgb.pixels_num);
048  memset(screen.rgb.pixels, 0, screen.rgb.pixels_num);
049  screen.rgb.surface = SDL_CreateRGBSurfaceFrom(screen.rgb.pixels,
050                        screen.rgb.width,
051                        screen.rgb.height,
052                        screen.rgb.bpp,
053                        screen.rgb.pitch,
054                        screen.rgb.rmask,
055                        screen.rgb.gmask,
056                        screen.rgb.bmask,
057                        screen.rgb.amask);
058}
059 
060static void
061update_rgb_surface(int index)
062{
063  update_rgb_pixels(video.buffer.buf[index].start);
064  SDL_BlitSurface(screen.rgb.surface, NULL, screen.display, NULL);
065  SDL_Flip(screen.display);
066}
067 
068static void
069update_rgb_pixels(const void *start)
070{
071  unsigned char *data = (unsigned char *)start;
072  unsigned char *pixels = screen.rgb.pixels;
073  int width = screen.rgb.width;
074  int height = screen.rgb.height;
075  unsigned char Y, Cr, Cb;
076  int r, g, b;
077  int x, y;
078  int p1, p2, p3, p4;
079 
080  for (y = 0; y < height; y++) {
081    for (x = 0; x < width; x++) {
082      p1 = y * width * 2 + x * 2;
083      Y = data[p1];
084      if (x % 2 == 0) {
085    p2 = y * width * 2 + (x * 2 + 1);
086    p3 = y * width * 2 + (x * 2 + 3);
087      }
088      else {
089    p2 = y * width * 2 + (x * 2 - 1);
090    p3 = y * width * 2 + (x * 2 + 1);
091      }
092      Cb = data[p2];
093      Cr = data[p3];
094      yuv2rgb(Y, Cb, Cr, &r, &g, &b);
095      p4 = y * width * 4 + x * 4;
096      pixels[p4] = r;
097      pixels[p4 + 1] = g;
098      pixels[p4 + 2] = b;
099      pixels[p4 + 3] = 255;
100    }
101  }
102}
103 
104static void
105yuv2rgb(unsigned char Y,
106    unsigned char Cb,
107    unsigned char Cr,
108    int *ER,
109    int *EG,
110    int *EB)
111{
112  double y1, pb, pr, r, g, b;
113 
114  y1 = (255 / 219.0) * (Y - 16);
115  pb = (255 / 224.0) * (Cb - 128);
116  pr = (255 / 224.0) * (Cr - 128);
117  r = 1.0 * y1 + 0 * pb + 1.402 * pr;
118  g = 1.0 * y1 - 0.344 * pb - 0.714 * pr;
119  b = 1.0 * y1 + 1.722 * pb + 0 * pr;
120/* 用GDB调试了这么久终于将BUG找出来了:), 是v4l2的文档有问题 */
121/* 不应该为clamp(r * 255) */
122  *ER = clamp(r);
123  *EG = clamp(g);
124  *EB = clamp(b);
125}
126 
127static int
128clamp(double x)
129{
130  int r = x;
131  if (r < 0)
132    return 0;
133  else if (r > 255)
134    return 255;
135  else
136    return r;
137}
138 
139void
140screen_init()
141{
142  screen.width = opt.width;
143  screen.height = opt.height;
144  screen.bpp = 32;
145  screen.running = 1;
146  screen.display = SDL_SetVideoMode(screen.width,
147                    screen.height,
148                    screen.bpp,
149                    SDL_SWSURFACE | SDL_DOUBLEBUF);
150  if (screen.display == NULL) {
151    perror("SDL_SetVideoMode");
152    exit(EXIT_FAILURE);
153  }
154  sdl_init();
155  create_rgb_surface();
156}
157 
158void
159screen_quit()
160{
161  SDL_FreeSurface(screen.display);
162  SDL_FreeSurface(screen.rgb.surface);
163  free(screen.rgb.pixels);
164  SDL_Quit();
165}
166 
167void
168screen_mainloop()
169{
170  int i;
171 
172  for (i = 0; screen.running && i <= video.buffer.req.count; i++) {
173    if (i == video.buffer.req.count) {
174      i = 0;
175    }
176    buffer_dequeue(i);
177    update_rgb_surface(i);
178    if (SDL_PollEvent(&screen.event) == 1) {
179      switch (screen.event.type) {
180      case SDL_KEYDOWN:
181    switch (screen.event.key.keysym.sym) {
182    case SDLK_q:
183      puts("bye");
184      screen.running = 0;
185      break;
186    default:
187      break;
188    }
189    break;
190      case SDL_QUIT:
191    screen.running = 0;
192    break;
193      default:
194    break;
195      }
196    }
197    buffer_enqueue(i);
198  }
199}

5. [代码]video.h    

01#ifndef VIDEO_H
02#define VIDEO_H
03 
04#include <linux/videodev2.h>
05 
06struct buffer {
07  struct v4l2_requestbuffers req; // 请求/
08  struct v4l2_buffer query;      // 获取/
09  struct {              // 缓冲/
10    void *start;
11    size_t length;
12  } *buf;
13};
14 
15struct video {
16  int fd;
17  struct v4l2_format format;    // 视频帧格式
18  struct buffer buffer;        // 视频缓冲
19};
20 
21void video_init();
22void video_quit();
23void buffer_enqueue(int index);
24void buffer_dequeue(int index);
25 
26#endif

6. [代码]video.c    

001#include <stdio.h>
002#include <stdlib.h>
003#include <string.h>
004#include <sys/types.h>
005#include <sys/stat.h>
006#include <sys/ioctl.h>
007#include <sys/mman.h>
008#include <fcntl.h>
009#include <unistd.h>
010#include <errno.h>
011#include <assert.h>
012#include "video.h"
013#include "opt.h"
014 
015#define BUFFER_NUM 5
016 
017static int stream_flag = V4L2_BUF_TYPE_VIDEO_CAPTURE;
018extern struct options opt;
019struct video video;
020 
021static void video_open();
022static void video_close();
023static void video_set_format();
024static void video_streamon();
025static void video_streamoff();
026static void buffer_init();
027static void buffer_free();
028static void buffer_request();
029static void buffer_mmap(int index);
030 
031static void
032video_open()
033{
034  int i, fd;
035  char device[13];
036 
037  for (i = 0; i < 99; i++) {
038    sprintf(device, "%s%d", "/dev/video", i);
039    fd = open(device, O_RDWR);
040    if (fd != -1) {
041      if (opt.verbose) {
042    printf("open %s success\n", device);
043      }
044      break;
045    }
046  }
047  if (i == 100) {
048    perror("video open fail");
049    exit(EXIT_FAILURE);
050  }
051  video.fd = fd;
052}
053 
054static void
055video_close()
056{
057  close(video.fd);
058}
059 
060static void
061video_set_format()
062{
063  memset(&video.format, 0, sizeof(video.format));
064  video.format.type = stream_flag;
065  video.format.fmt.pix.width = opt.width;
066  video.format.fmt.pix.height = opt.height;
067  video.format.fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
068  if (ioctl(video.fd, VIDIOC_S_FMT, &video.format) == -1) {
069    perror("VIDIOC_S_FORMAT");
070    exit(EXIT_FAILURE);
071  }
072}
073 
074static void
075video_streamon()
076{
077  if (ioctl(video.fd, VIDIOC_STREAMON, &stream_flag) == -1) {
078    if (errno == EINVAL) {
079      perror("streaming i/o is not support");
080    }
081    else {
082      perror("VIDIOC_STREAMON");
083    }
084    exit(EXIT_FAILURE);
085  }
086}
087 
088static void
089video_streamoff()
090{
091  if (ioctl(video.fd, VIDIOC_STREAMOFF, &stream_flag) == -1) {
092    if (errno == EINVAL) {
093      perror("streaming i/o is not support");
094    }
095    else {
096      perror("VIDIOC_STREAMOFF");
097    }
098    exit(EXIT_FAILURE);
099  }
100}
101 
102static void
103buffer_init()
104{
105  int i;
106 
107  buffer_request();
108  for (i = 0; i < video.buffer.req.count; i++) {
109    buffer_mmap(i);
110    buffer_enqueue(i);
111  }
112}
113 
114static void
115buffer_free()
116{
117  int i;
118 
119  for (i = 0; i < video.buffer.req.count; i++) {
120    munmap(video.buffer.buf[i].start, video.buffer.buf[i].length);
121  }
122  free(video.buffer.buf);
123}
124 
125static void
126buffer_request()
127{
128 
129  memset(&video.buffer.req, 0, sizeof(video.buffer.req));
130  video.buffer.req.type = stream_flag;
131  video.buffer.req.memory = V4L2_MEMORY_MMAP;
132  video.buffer.req.count = BUFFER_NUM;
133  /* 设置视频帧缓冲规格 */
134  if (ioctl(video.fd, VIDIOC_REQBUFS, &video.buffer.req) == -1) {
135    if (errno == EINVAL) {
136      perror("video capturing or mmap-streaming is not support");
137    }
138    else {
139      perror("VIDIOC_REQBUFS");
140    }
141    exit(EXIT_FAILURE);
142  }
143  if (video.buffer.req.count < BUFFER_NUM) {
144    perror("no enough buffer");
145    exit(EXIT_FAILURE);
146  }
147  video.buffer.buf = calloc(video.buffer.req.count,
148                sizeof(*video.buffer.buf));
149  assert(video.buffer.buf != NULL);
150}
151 
152static void
153buffer_mmap(int index)
154{
155  memset(&video.buffer.query, 0, sizeof(video.buffer.query));
156  video.buffer.query.type = video.buffer.req.type;
157  video.buffer.query.memory = V4L2_MEMORY_MMAP;
158  video.buffer.query.index = index;
159  /* 视频帧缓冲映射 */
160  if (ioctl(video.fd, VIDIOC_QUERYBUF, &video.buffer.query) == -1) {
161    perror("VIDIOC_QUERYBUF");
162    exit(EXIT_FAILURE);
163  }
164  video.buffer.buf[index].length = video.buffer.query.length;
165  video.buffer.buf[index].start = mmap(NULL,
166                       video.buffer.query.length,
167                       PROT_READ | PROT_WRITE,
168                       MAP_SHARED,
169                       video.fd,
170                       video.buffer.query.m.offset);
171  if (video.buffer.buf[index].start == MAP_FAILED) {
172    perror("mmap");
173    exit(EXIT_FAILURE);
174  }
175}
176 
177void
178video_init()
179{
180  video_open();
181  video_set_format();
182  buffer_init();
183  video_streamon();
184}
185 
186void
187video_quit()
188{
189  video_streamoff();
190  video_close();
191  buffer_free();
192}
193 
194void
195buffer_enqueue(int index)
196{
197    memset(&video.buffer.query, 0, sizeof(video.buffer.query));
198    video.buffer.query.type = video.buffer.req.type;
199    video.buffer.query.memory = V4L2_MEMORY_MMAP;
200    video.buffer.query.index = index;
201    /* 视频帧缓冲入队 */
202    if (ioctl(video.fd, VIDIOC_QBUF, &video.buffer.query) == -1) {
203      perror("VIDIOC_QBUF");
204      exit(EXIT_FAILURE);
205    }
206}
207 
208void
209buffer_dequeue(int index)
210{
211    memset(&video.buffer.query, 0, sizeof(video.buffer.query));
212    video.buffer.query.type = video.buffer.req.type;
213    video.buffer.query.memory = V4L2_MEMORY_MMAP;
214    video.buffer.query.index = index;
215    /* 视频帧缓冲出队 */
216    if (ioctl(video.fd, VIDIOC_DQBUF, &video.buffer.query) == -1) {
217      perror("VIDIOC_DQBUF");
218      exit(EXIT_FAILURE);
219    }
220}

7. [代码]swc.c    

01#include <stdlib.h>
02#include "opt.h"
03#include "video.h"
04#include "screen.h"
05 
06int
07main(int argc, char *argv[])
08{
09  options_init();
10  options_deal(argc, argv);
11  video_init();
12  screen_init();
13  screen_mainloop();
14  screen_quit();
15  video_quit();
16  exit(EXIT_SUCCESS);
17}

8. [代码]opt.c    

01#include <stdio.h>
02#include <stdlib.h>
03#include <unistd.h>
04#include "opt.h"
05 
06struct options opt;
07 
08static void show_usage();
09 
10static void
11show_usage()
12{
13  printf("usage: swc [options]\n\
14-h 打印该帮助信息\n\
15-v 显示程序内部提示\n");
16}
17 
18void
19options_init()
20{
21  opt.verbose = 0;
22  opt.width = 640;
23  opt.height = 480;
24}
25 
26void
27options_deal(int argc, char *argv[])
28{
29  int my_opt;
30 
31  while ((my_opt = getopt(argc, argv, "hv")) != -1) {
32    switch(my_opt) {
33    case 'h':
34      show_usage();
35      break;
36    case 'v':
37      opt.verbose = 1;
38      break;
39    default:
40      show_usage();
41      exit(EXIT_FAILURE);
42    }
43  }
44}

惜海
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
video4linux2编程实例
01-15
v4l2编程实例。。。。。。。。。。。。
Video4Linux 中文解析
嵌入精灵
05-26 1749
Video4linux 中文解析 收藏 •Video4linux（简称V4L),是linux中关于视频设备的内核驱动。•现在已有Video4linux2，还未加入linux内核，使用需自己下载补丁•在Linux中，视频设备是设备文件，可以像访问普通文件一样对其进行读写•摄像头在/dev/video0下1.打开视频设备：2. 读取设备信息3.更改设备当前设置（如果有必要）
video4linux2
03-09
Video4linux2（简称V4L2),是linux中关于视频设备的内核驱动。
video4linux2--2
zjbo_123的专栏
01-06 596
Video standards当然世界上现在有多个视频标准，如NTSC和PAL，他们又细分为好多种，那么我们的设备输入/输出究竟支持什么样的标准呢？我们的当前在使用的输入和输出正在使用的是哪个标准呢？我们怎么设置我们的某个输入输出使用的标准呢？这都是有方法的。（1）查询，我们的输入支持什么标准，首先就得找到当前的这个输入的index，然后查出它的属性，在其属性里面可以得到该输入所支持的标准，将它所
video4linux2--1
zjbo_123的专栏
01-06 861
1。 video for linux 现在是第2版 2。 号称是支持multiple opens，当然前提是这多个open最好不要是在都要进行数据传输的情况下的，比如一个process可以控制它的一些参数，一个process在进行在线的video recoding。 3。 Shared Data Streams  数据流的共享，建议是在应用级去实现，在底层我们用一个proxy单独去管理获取数据，再
烤红薯创业计划书2篇.doc
09-17
烤红薯创业计划书2篇.doc
Linux基本命令操作
03-11
实验1：查看目录、新建目录、复制目录文件、查看文件内容、文件权限修改、建立链接；实验2：用户管理、挂载和卸载、压缩、查看进程、网卡参数、ping命令、安装.deb；实验3：vim编辑器的使用。内附笔记
关于红薯饮料技术的开发2收集.pdf
02-16
红薯饮料技术的开发主要面临两大挑战，一是口感的优化，二是淀粉老化导致的后沉淀问题。对于口感，理想的红薯饮料应具有良好的口感，符合大众尤其是年轻白领群体的口味，同时带有红薯独特的烤味。澄清型红薯饮料呈现...
CN201611254391.5A 红薯酒精废水的处理方法 1-4.pdf
11-13
CN201611254391.5A 红薯酒精废水的处理方法 1-4.pdf
Linux 基本常用命令查看
我爱吃红薯的博客
11-11 1675
补充知识： a，查询端口占用情况 netstat -nultp 查看80端口的pid,可以方便 kill -9 + pid netstat -anp|grep 80 b，杀死进程 : kill -9 pid c，查询进程：（例：nginx） ps -aux|grep nginx ps -ef|grep nginx d，docker 根据名称/ID停止一个镜像 docker stop name/ID 删除镜像 docker rm name/ID 删除容器 docke...
基于video4linux2的双usb摄像头图像获取显示
06-22
采用的摄像头是现代的，uvc免驱动的，如果想改为单usb摄像头的话只需要稍微修改一下就行了，linux内核版本采用的是2.6.30的，其他版本应该也能用
video4linux驱动的一些参考文档（经典）
03-14
视频采集在linux下的驱动移植和文档，主要提供了是针对了ADI公司的Blackfin系列在uclinux下的驱动移植的一些参考文档
了解V4L2(video 4 linux 2)
sphone89的专栏
12-04 987
很多人知道v4l2可以用来在linux上采集摄像头的图片，但其实v4l2还有更多的功能。其主要功能使程序有发现设备和操作设备的能力.它主要是用一系列的回调函数来实现这些功能。像设置摄像头的频率、帧频、视频压缩格式和图像参数等等。当然也可以用于其他多媒体的开发，如音频等。　　但是此框架只能运行在Linux操作系统之上。  可以支持多种设备,它可以有以下几种接口: 1. 视频采集接口(vide
video4linux2笔记
uyiwfn的专栏
01-03 680
video4linux2笔记 1 主要使用的操作就是open, close, ioctl 2 Querying Capabilities 虽然这是个标准，但不是强制性的，因此不同的设备对功能的支持不同，所以地提供一个功能查询机制，而这个功能查询机制应该是必需的。All V4L2 drivers must support VIDIOC_QUERYCAP. Applications
Video4Linux2 part 4: inputs and outputs
weixin_34072458的博客
07-04 162
come fromhttp://lwn.net/Articles/213798/ This is the fourth article in the irregular LWN series on writing video drivers for Linux. Those who have not yet readthe introductory articlemay...
Video4Linux2 第二部分：注册和打开
╰☆╮EvilCode的专栏╭☆╯
04-25 2166
<br /><br />Video4Linux2 part 2: registration and open()<br />V4L2 第二部分：注册和打开<br />This is the second article in the LWN series on writing drivers for the Video4Linux2 kernel interface; those who have not yet seen the introductory articlemay wish to start
一文读懂V4L2（Video for Linux 2）框架
最新发布
小灰灰的博客
11-26 3256
V4L2（Video for Linux 2）是Linux操作系统中用于支持摄像头和视频设备的框架。它提供了一组API和驱动程序接口，用于在Linux系统中进行视频采集、视频流处理和视频播放等操作。设备抽象层：V4L2框架提供了一个设备抽象层，使得应用程序可以与各种不同类型的视频设备进行通信，包括摄像头、视频采集卡等。统一的控制接口：V4L2定义了一套统一的控制接口，可以通过这些接口来配置和调整视频设备的各种参数，比如亮度、对比度、饱和度等。
Video4Linux2第一部分 API: 简介
╰☆╮EvilCode的专栏╭☆╯
04-25 3006
<br /><br />原文地址：http://lwn.net/Articles/203924/The Video4Linux2 API: an introduction <br />[Posted October 11, 2006 by corbet]<br />Video4Linux2 API: 简介<br />Your editor has recently had the opportunity to write a Linux driver for a camera device - the c
Linux运维新趋势：开发融合与多元化发展
《Linux运维趋势第20期》是一期由51CTO系统频道策划的针对Linux/Unix系统运维人员的专业电子杂志，旨在提供最新、实用的运维知识和技术动态。本期内容丰富多样，涵盖了以下几个关键知识点： 1. **技术转型与新兴...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值