其他分享
首页 > 其他分享> > 开发RTSP 直播软件 H264 AAC 编码

开发RTSP 直播软件 H264 AAC 编码

作者:互联网

上一篇对摄像头预览,拍照做了大概的介绍,现在已经可以拿到视频帧了,在加上 RTSP 实现,就是直播的雏形,当然还要加上一些 WEB 管理和手机平台的支援,就是一整套直播软件。

介绍一些基础概念:RTP RTSP RTMP

RTP 实时传输协议,RTMP 以前  flash 用的视频协议,RTSP 目前比较流行的 直播协议

用到的软件和第三方库:ffmpeg live555 VLC

VLC 全平台播放器,win ubuntu mac os android 各个平台都有,功能强大,UI美观,还没有广告。

live555 开源 RTP RTSP 项目

ffmpeg 开源编解码器,多种格式转换,加水印,ffplay 更是全能播放器(就是控制做的不行)

ffplay 在 win 上使用时,需要加一个环境变量,否则没声音 set SDL_AUDIODRIVER=directsound

1,在本机发布一个 ts 流,用 VLC 和 手机浏览器, 进行播放。

ffmpeg -i 1-21.rm -profile:v baseline -level 3.0 -s 640x360 -start_number 0 -hls_time 10 -hls_list_size 0 -f hls 1-12.m3u8

把 ffmpeg 拆分好的文件,复制到 webroot 目录里面,然后使用 VLC 播放,也可以通过 html5 的 video 在手机上播放,手机上浏览器支持 ts 流比较好

2,RTSP 流 使用 live555 发布

http://live555.com/liveMedia/public/ 下载源码,编译安装,不得不说有的时候在 ubuntu 上开发的确比 win 上简单。

下载解压后,执行 ./genMakefiles linux 在 make 会生成 mediaServer/live555MediaServer 运行它,在它的目录放一些文件,这里放的是 mkv 的文件,这里还写了支持的其它类型的文件。

然后使用 ffplay 进行播放。

使用 wireshark 抓包查看数据包

RTSP 文档 https://www.rfc-editor.org/rfc/rfc2326.html 自己对照着看吧,如果完全自己从0开发,这些是需要知道的。

3,H264 ACC 编码

要先找一些原始数据,才能开始编码。直接从 DirectShow 中,的确是可以拿到数据,每次启动什么的还是有点麻烦,所以先生成一些数据,使用 ffmpeg 提取视频为图片

ffmpeg -i 1.mp4 -r 25 -q:v 2 -f image2 image-%5d.jpg

从 1.mp4 中提取了图片,帧率是 25 。

win 平台下载编译好的 lib 比较省心,https://ffmpeg.zeranoe.com/builds/  下载 ffmpeg-4.2.2-win32-dev.zip

linux 可以自行编译,需要下载很多库 x264 x265 啥的,这样看来,还是 win 省心,直接用现成的 lib 就行了。

参考例子 ffmpeg-4.1/doc/examples$

编译

gcc encode_video.c -lavcodec -lavutil  -o encode_video

gcc muxing.c -lavcodec -lavutil -lswscale -lswresample -lavformat -lm -o muxing

执行 ./encode_video 1.mp4 libx264  ./muxing 2.mp4

使用 ffplay 播放器打开

 

实际上这个是动的,不过 GIF 录的不好。

H264 中要求是 YUV420P 格式,JPG 默认解码 RGB  也可以解码为 JCS_YCbCr 。YCbCr 和 YUV 几种格式的区别,ffmpeg 中有以下几种:

AV_PIX_FMT_YUV444P

AV_PIX_FMT_YUV422P

AV_PIX_FMT_YUV420P

其它 RGB 也有几种 RGB24 - 888 RGB16 - 565 

  1 /**
  2  * author:nejidev
  3  * date:2020-03-14 12:32
  4  */
  5 #include <stdio.h>
  6 #include <stdlib.h>
  7 #include <dirent.h>
  8 #include <string.h>
  9 #include <jpeglib.h>
 10 #include <setjmp.h>
 11 
 12 #include <libavformat/avformat.h>
 13 #include <libavcodec/avcodec.h>
 14 #include <libswscale/swscale.h>
 15 
 16 #include <libavutil/opt.h>
 17 #include <libavutil/imgutils.h>
 18 struct my_error_mgr {
 19     struct jpeg_error_mgr pub;
 20     jmp_buf setjmp_buffer;
 21 };
 22 
 23 typedef struct my_error_mgr *my_error_ptr;
 24 
 25 void my_error_exit(j_common_ptr cinfo)
 26 {
 27     my_error_ptr myerr = (my_error_ptr) cinfo->err;
 28     (*cinfo->err->output_message) (cinfo);
 29     longjmp(myerr->setjmp_buffer, 1);
 30 }
 31 
 32 int read_jpeg(const char *filename, int *out_width, int *out_height, char **out_rgb_buff)
 33 {
 34     struct jpeg_decompress_struct cinfo;
 35     struct my_error_mgr jerr;
 36     FILE *infile;
 37     char *buffer;
 38     char *p;
 39     int row_stride;
 40 
 41     if(NULL == (infile = fopen(filename, "rb")))
 42     {
 43         fprintf(stderr, "can't open %s\n", filename);
 44         return 0;
 45     }
 46 
 47     cinfo.err = jpeg_std_error(&jerr.pub);
 48     jerr.pub.error_exit = my_error_exit;
 49     if(setjmp(jerr.setjmp_buffer))
 50     {
 51         jpeg_destroy_decompress(&cinfo);
 52         fclose(infile);
 53         return 0;
 54     }
 55     jpeg_create_decompress(&cinfo);
 56     jpeg_stdio_src(&cinfo, infile);
 57     (void)jpeg_read_header(&cinfo, TRUE);
 58 
 59     (void) jpeg_start_decompress(&cinfo);
 60 
 61     row_stride = cinfo.output_width * cinfo.output_components;
 62     buffer = (char *)malloc(row_stride * cinfo.output_height);
 63     memset(buffer, 0, row_stride * cinfo.output_height);
 64     *out_rgb_buff = buffer;
 65 
 66     *out_width  = cinfo.output_width;
 67     *out_height = cinfo.output_height;
 68 
 69     while(cinfo.output_scanline < cinfo.output_height)
 70     {
 71         p = buffer + cinfo.output_scanline * row_stride;
 72         (void) jpeg_read_scanlines(&cinfo, (JSAMPARRAY)&p, 1);
 73     }
 74 
 75     (void) jpeg_finish_decompress(&cinfo);
 76     jpeg_destroy_decompress(&cinfo);
 77     fclose(infile);
 78     return 1;
 79 }
 80 
 81 static void encode(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *pkt,
 82                    FILE *outfile)
 83 {
 84     int ret;
 85 
 86     /* send the frame to the encoder */
 87     if (frame)
 88         printf("Send frame %3"PRId64"\n", frame->pts);
 89 
 90     ret = avcodec_send_frame(enc_ctx, frame);
 91     if (ret < 0) {
 92         fprintf(stderr, "Error sending a frame for encoding\n");
 93         exit(1);
 94     }
 95 
 96     while (ret >= 0) {
 97         ret = avcodec_receive_packet(enc_ctx, pkt);
 98         if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
 99             return;
100         else if (ret < 0) {
101             fprintf(stderr, "Error during encoding\n");
102             exit(1);
103         }
104 
105         printf("Write packet %3"PRId64" (size=%5d)\n", pkt->pts, pkt->size);
106         fwrite(pkt->data, 1, pkt->size, outfile);
107         av_packet_unref(pkt);
108     }
109 }
110 
111 int get_video_size(const char *dir_path, int *out_width, int *out_height)
112 {
113     DIR *dir;
114     struct dirent *file;
115     char filename[256];
116     char *image_buff;
117 
118     dir = opendir(dir_path);
119     while(NULL != (file = readdir(dir)))
120     {
121         if(0 != strcmp(".", file->d_name) && 0 != strcmp("..", file->d_name))
122         {
123             snprintf(filename, 256, "%s/%s", dir_path, file->d_name);
124             read_jpeg(filename, out_width, out_height, &image_buff);
125             free(image_buff);
126             break;
127         }
128     }
129 
130     closedir(dir);
131     return 0;
132 }
133 
134 int main(int argc, char **argv)
135 {
136     const char *filename, *dir_path, *codec_name = "libx264";
137     const AVCodec *codec;
138     AVCodecContext *c= NULL;
139     int i, ret, x, y;
140     FILE *f;
141     AVFrame *frame;
142     AVPacket *pkt;
143     uint8_t endcode[] = { 0, 0, 1, 0xb7 };
144 
145     struct SwsContext *sws_ctx = NULL;
146     int video_width;
147     int video_height;
148     int fps = 25;
149 
150     DIR *dir;
151     struct dirent *file;
152     char file_image[256];
153     char *image_buff;
154 
155     if (argc <= 2) {
156         fprintf(stderr, "Usage: %s <output file> <image dir>\n", argv[0]);
157         exit(0);
158     }
159     filename = argv[1];
160     dir_path = argv[2];
161 
162     if(get_video_size(dir_path, &video_width, &video_height))
163     {
164         fprintf(stderr, "get video size failed\n");
165         exit(1);
166     }
167 
168     /* find the mpeg1video encoder */
169     codec = avcodec_find_encoder_by_name(codec_name);
170     if (!codec) {
171         fprintf(stderr, "Codec '%s' not found\n", codec_name);
172         exit(1);
173     }
174 
175     c = avcodec_alloc_context3(codec);
176     if (!c) {
177         fprintf(stderr, "Could not allocate video codec context\n");
178         exit(1);
179     }
180 
181     pkt = av_packet_alloc();
182     if (!pkt)
183         exit(1);
184 
185     /* put sample parameters */
186     c->bit_rate = 400000;
187     /* resolution must be a multiple of two */
188     c->width = video_width;
189     c->height = video_height;
190     /* frames per second */
191     c->time_base = (AVRational){1, fps};
192     c->framerate = (AVRational){fps, 1};
193 
194     /* emit one intra frame every ten frames
195      * check frame pict_type before passing frame
196      * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
197      * then gop_size is ignored and the output of encoder
198      * will always be I frame irrespective to gop_size
199      */
200     c->gop_size = 10;
201     c->max_b_frames = 0;
202     c->pix_fmt = AV_PIX_FMT_YUV420P;
203 
204     if (codec->id == AV_CODEC_ID_H264)
205         av_opt_set(c->priv_data, "preset", "slow", 0);
206 
207     /* open it */
208     ret = avcodec_open2(c, codec, NULL);
209     if (ret < 0) {
210         fprintf(stderr, "Could not open codec: %s\n", av_err2str(ret));
211         exit(1);
212     }
213 
214     f = fopen(filename, "wb");
215     if (!f) {
216         fprintf(stderr, "Could not open %s\n", filename);
217         exit(1);
218     }
219 
220     frame = av_frame_alloc();
221     if (!frame) {
222         fprintf(stderr, "Could not allocate video frame\n");
223         exit(1);
224     }
225     frame->format = c->pix_fmt;
226     frame->width  = c->width;
227     frame->height = c->height;
228 
229     ret = av_frame_get_buffer(frame, 32);
230     if (ret < 0) {
231         fprintf(stderr, "Could not allocate the video frame data\n");
232         exit(1);
233     }
234 
235     //rgb24 to yun420p
236     sws_ctx = sws_getContext(frame->width, frame->height, AV_PIX_FMT_BGR24,
237                 frame->width, frame->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC,
238                 NULL,NULL,NULL);
239 
240     struct dirent **namelist;
241     int n;
242 
243     n = scandir(dir_path, &namelist, NULL, alphasort);
244     for(i = 0; i < n; i++)
245     {
246         if(0 != strcmp(".", namelist[i]->d_name) && 0 != strcmp("..", namelist[i]->d_name))
247         {
248             snprintf(file_image, sizeof(file_image), "%s/%s", dir_path, namelist[i]->d_name);
249 
250             printf("file_image:%s\n", file_image);
251             read_jpeg(file_image, &video_width, &video_height, &image_buff);
252 
253             uint8_t *indata[AV_NUM_DATA_POINTERS] = { 0 };
254             indata[0] = image_buff;
255             int inlinesize[AV_NUM_DATA_POINTERS] = { 0 };
256             inlinesize[0] = frame->width * 3;
257 
258             ret = sws_scale(sws_ctx, indata, inlinesize, 0, frame->height, frame->data, frame->linesize);
259             
260             /* make sure the frame data is writable */
261             ret = av_frame_make_writable(frame);
262             if (ret < 0) exit(1);
263 
264             frame->pts = i;
265 
266             /* encode the image */
267             encode(c, frame, pkt, f);
268 
269             free(image_buff);
270         }
271         free(namelist[i]);
272     }
273     free(namelist);
274     sws_freeContext(sws_ctx);
275 
276     closedir(dir);
277 
278     /* flush the encoder */
279     encode(c, NULL, pkt, f);
280 
281     /* add sequence end code to have a real MPEG file */
282     fwrite(endcode, 1, sizeof(endcode), f);
283     fclose(f);
284 
285     avcodec_free_context(&c);
286     av_frame_free(&frame);
287     av_packet_free(&pkt);
288 
289     return 0;
290 }

这个是 把 上面拆分的 jpg 图片合成 264 编码,编译方式:gcc encode_video_h264.c -lavcodec -lavutil -lswscale -lswresample -lavformat -ljpeg

这里使用读取文件夹内的所有 jpg ,read_jpeg() 是一个用 libjpeg 实现的,得到 jpeg 解码 RGB 数据的方法,但是 编码器需要 YUV420P 所以使用 sws_scale 进行转换。

将转换好的 xin.264 文件复制到  mediaServer 下面,启动 live555MediaServer 用 VLC 播放。

 

最终要完成的软件是 windows 版 摄像头直播软件,采用技术方案 MFC 、DirectShow、ffmpeg 、live555 。

原理是 DirectShow 采集 RGB 和 PCM 经过 h264 和 aac 编码以后,送到 live555 通过 RTSP RTP 传输,在理想点就是实现 P2P 以减少服务器压力。

 

标签:AAC,H264,frame,RTSP,cinfo,height,video,ret,jpeg
来源: https://www.cnblogs.com/ningci/p/12463198.html