ffmpeg软硬编解码

最新推荐文章于 2024-07-19 16:11:08 发布
置顶 最新推荐文章于 2024-07-19 16:11:08 发布
阅读量811 收藏 3
点赞数 1
分类专栏： FFmpeg学习 文章标签： ffmpeg 计算机视觉 opencv
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43306331/article/details/107108596
版权

编码

#include <iostream>
#define __STDC_CONSTANT_MACROS

extern "C" {
#include <libavutil/opt.h>
#include <libavcodec/avcodec.h>
#include <libavutil/channel_layout.h>
#include <libavutil/common.h>
#include <libavutil/imgutils.h>
#include <libavutil/mathematics.h>
#include <libavutil/samplefmt.h>
#include "libavformat/avformat.h"
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libavutil/time.h>
};

#pragma  comment(lib,"avcodec.lib")
#pragma  comment(lib,"avdevice.lib")
#pragma  comment(lib,"avfilter.lib")
#pragma  comment(lib,"avformat.lib")
#pragma  comment(lib,"avutil.lib")
#pragma  comment(lib,"postproc.lib")
#pragma  comment(lib,"swresample.lib")
#pragma  comment(lib,"swscale.lib")

using namespace std;

#define AV_CODEC_CAP_DELAY (1<<5)
#define AVIO_FLAG_READ_WRITE (1|2)
//YUV编码为H.264
int flush_encoder(AVFormatContext* fmt_ctx, unsigned int stream_index) {
	int ret;
	int got_frame;
	AVPacket enc_pkt;
	if (!(fmt_ctx->streams[stream_index]->codec->codec->capabilities & AV_CODEC_CAP_DELAY)) return 0;
	while (1) {
		enc_pkt.data = NULL;
		enc_pkt.size = 0;
		av_init_packet(&enc_pkt);
		ret = avcodec_encode_video2(fmt_ctx->streams[stream_index]->codec, &enc_pkt, NULL, &got_frame);
		av_frame_free(NULL);
		if (ret < 0) break;
		if (!got_frame) {
			ret = 0;
			break;
		}
		printf("Flush Encoder: Succeed to encode 1 frame!\tsize:%5d\n", enc_pkt.size);
		ret = av_write_frame(fmt_ctx, &enc_pkt);
		if (ret < 0) break;
	}
}
//注释 CTRL+K CTRL+C
//取消注释 CTRL+K CTRL+U
int main(int argc, char* argv[]) {
	AVFormatContext* pFormatCtx;
	AVOutputFormat* fmt;
	AVStream* video_st;
	AVCodecContext* pCodecCtx;
	AVCodec* pCodec;
	AVPacket pkt;
	uint8_t* picture_buf;
	AVFrame* pFrame;
	int picture_size;
	int y_size;
	int framecnt = 0;
	FILE* in_file = fopen("C:/Users/37075/source/repos/ffmpeg_learn/yuv/ElephantsDream_CIF_24fps.yuv", "rb");
	int in_w = 352, in_h = 288;
	int framenum = 14315;
	const char* out_file = "C:/Users/37075/source/repos/ffmpeg_learn/h264/output2.h264";

	//注册FFmpeg所有编码器
	av_register_all();

	//Method 1.
	//pFormatCtx = avformat_alloc_context();
	//fmt = av_guess_format(NULL, out_file, NULL);
	//pFormatCtx->oformat = fmt;

	//Method 2.
	//初始化输出的码流AVFormatContext
	avformat_alloc_output_context2(&pFormatCtx, NULL, NULL, out_file);
	fmt = pFormatCtx->oformat;



	//Open output URL
	if (avio_open(&pFormatCtx->pb, out_file, AVIO_FLAG_READ_WRITE) < 0) {
		printf("Failed to open output file! \n");
		return -1;
	}

	//创建输出码流的AVStream
	video_st = avformat_new_stream(pFormatCtx, 0);
	if (video_st == NULL){
		return -1;
	}
	pCodecCtx = video_st->codec;
	pCodecCtx->codec_id = fmt->video_codec;
	pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
	pCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
	pCodecCtx->width = in_w;
	pCodecCtx->height = in_h;
	pCodecCtx->bit_rate = 400000;
	pCodecCtx->gop_size = 250;

	pCodecCtx->time_base.num = 1;
	pCodecCtx->time_base.den = 25;

	pCodecCtx->qmin = 10;
	pCodecCtx->qmax = 51;

	pCodecCtx->max_b_frames = 3;

	AVDictionary* param = 0;
	
	//H.264
	if (pCodecCtx->codec_id == AV_CODEC_ID_H264) {
		av_dict_set(&param, "preset", "slow", 0);
		av_dict_set(&param, "tune", "zerolatency", 0);
	}
	if (pCodecCtx->codec_id == AV_CODEC_ID_HEVC) {
		av_dict_set(&param, "preset", "ultrafast", 0);
		av_dict_set(&param, "tune", "zerolatency", 0);
	}

	av_dump_format(pFormatCtx, 0, out_file, 1);

	//查找编码器
	pCodec = avcodec_find_encoder(pCodecCtx->codec_id);
	if (!pCodec) {
		printf("Can not find encoder! \n");
		return -1;
	}
	
	//打开编码器
	if (avcodec_open2(pCodecCtx, pCodec, &param) < 0) {
		printf("Failed to open encoder! \n");
		return -1;
	}

	pFrame = av_frame_alloc();
	picture_size = avpicture_get_size(pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);
	picture_buf = (uint8_t*)av_malloc(picture_size);
	avpicture_fill((AVPicture*)pFrame, picture_buf, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);
	pFrame->format = pCodecCtx->pix_fmt;
	pFrame->width = pCodecCtx->width;
	pFrame->height = pCodecCtx->height;
	//Write File Header
	avformat_write_header(pFormatCtx, NULL);

	av_new_packet(&pkt, picture_size);

	y_size = pCodecCtx->width * pCodecCtx->height;
	int64_t iStart = av_gettime();
	for (int i = 0; i < framenum; i++) {
		//Read raw YUV data
		if (fread(picture_buf, 1, y_size * 3 / 2, in_file) <= 0) {
			printf("Failed to read raw data! \n");
			return -1;
		}
		else if (feof(in_file)) {
			break;
		}
		pFrame->data[0] = picture_buf;              // Y
		pFrame->data[1] = picture_buf + y_size;      // U 
		pFrame->data[2] = picture_buf + y_size * 5 / 4;  // V
		//PTS
		//pFrame->pts=i;
		pFrame->pts = i * (video_st->time_base.den) / ((video_st->time_base.num) * 25);
		int got_picture = 0;

		//Encode
		//编辑一帧视频，将AVFrame（yuv）编码为AVPacket（h264）
		int ret = avcodec_encode_video2(pCodecCtx, &pkt, pFrame, &got_picture);
		if (ret < 0) {
			printf("Failed to encode! \n");
			return -1;
		}
		if (got_picture == 1) {
		//	printf("Succeed to encode frame: %5d\tsize:%5d\n", framecnt, pkt.size);
			framecnt++;
			pkt.stream_index = video_st->index;
			//将编码后的视频码流写入文件
			ret = av_write_frame(pFormatCtx, &pkt);
			av_free_packet(&pkt);
		}
	}
	printf("time: %d\n", av_gettime() - iStart);
	//Flush Encoder
	//输入的像素数据读取完成后调用该函数
	//输出编码器中剩余的AVPacket
	int ret = flush_encoder(pFormatCtx, 0);
	if (ret < 0) {
		printf("Flushing encoder failed\n");
		return -1;
	}

	//Write file trailer
	av_write_trailer(pFormatCtx);

	//Clean
	if (video_st) {
		avcodec_close(video_st->codec);
		av_free(pFrame);
		av_free(picture_buf);
	}
	avio_close(pFormatCtx->pb);
	avformat_free_context(pFormatCtx);

	fclose(in_file);
	return 0;

}

#include <iostream>
#define __STDC_CONSTANT_MACROS

extern "C" {
#include <libavutil/opt.h>
#include <libavcodec/avcodec.h>
#include <libavutil/channel_layout.h>
#include <libavutil/common.h>
#include <libavutil/imgutils.h>
#include <libavutil/mathematics.h>
#include <libavutil/samplefmt.h>
#include "libavformat/avformat.h"
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libavutil/time.h>
};

#pragma  comment(lib,"avcodec.lib")
#pragma  comment(lib,"avdevice.lib")
#pragma  comment(lib,"avfilter.lib")
#pragma  comment(lib,"avformat.lib")
#pragma  comment(lib,"avutil.lib")
#pragma  comment(lib,"postproc.lib")
#pragma  comment(lib,"swresample.lib")
#pragma  comment(lib,"swscale.lib")

using namespace std;

#define AV_CODEC_CAP_DELAY (1<<5)
#define AVIO_FLAG_READ_WRITE (1|2)

//YUV编码为H.264
int flush_encoder(AVFormatContext* fmt_ctx, unsigned int stream_index) {
	int ret;
	int got_frame;
	AVPacket enc_pkt;
	if (!(fmt_ctx->streams[stream_index]->codec->codec->capabilities & AV_CODEC_CAP_DELAY)) return 0;
	while (1) {
		enc_pkt.data = NULL;
		enc_pkt.size = 0;
		av_init_packet(&enc_pkt);
		ret = avcodec_encode_video2(fmt_ctx->streams[stream_index]->codec, &enc_pkt, NULL, &got_frame);
		av_frame_free(NULL);
		if (ret < 0) break;
		if (!got_frame) {
			ret = 0;
			break;
		}
		printf("Flush Encoder: Succeed to encode 1 frame!\tsize:%5d\n", enc_pkt.size);
		ret = av_write_frame(fmt_ctx, &enc_pkt);
		if (ret < 0) break;
	}
}


int main(int argc, char* argv[]) {
	AVFormatContext* pFormatCtx;
	AVOutputFormat* fmt;
	AVStream* video_st;
	AVCodecContext* pCodecCtx;
	AVCodec* pCodec;
	AVPacket pkt;
	uint8_t* picture_buf;
	AVFrame* pFrame;
	int picture_size;
	int y_size;
	int framecnt = 0;
	FILE* in_file = fopen("C:/Users/37075/source/repos/ffmpeg_learn/yuv/ElephantsDream_CIF_24fps.yuv", "rb");
	int in_w = 352, in_h = 288;
	int framenum = 14315;
	const char* out_file = "C:/Users/37075/source/repos/ffmpeg_learn/h264/output2.h264";

	//注册FFmpeg所有编码器
	av_register_all();

	//Method 1.
	//pFormatCtx = avformat_alloc_context();
	//fmt = av_guess_format(NULL, out_file, NULL);
	//pFormatCtx->oformat = fmt;

	//Method 2.
	//初始化输出的码流AVFormatContext
	avformat_alloc_output_context2(&pFormatCtx, NULL, NULL, out_file);
	fmt = pFormatCtx->oformat;



	//Open output URL
	if (avio_open(&pFormatCtx->pb, out_file, AVIO_FLAG_READ_WRITE) < 0) {
		printf("Failed to open output file! \n");
		return -1;
	}

	//创建输出码流的AVStream
	video_st = avformat_new_stream(pFormatCtx, 0);
	if (video_st == NULL) {
		return -1;
	}

	AVDictionary* param = 0;

	av_dump_format(pFormatCtx, 0, out_file, 1);

	//查找编码器
	pCodec = avcodec_find_encoder_by_name("h264_nvenc");
	if (!pCodec) {
		printf("Can not find encoder! \n");
		return -1;
	}

	pCodecCtx = avcodec_alloc_context3(pCodec);
	if (!pCodecCtx) {
		printf("Can not allocate video codec context! \n");
		return -1;
	}
	pCodecCtx = video_st->codec;
	pCodecCtx->codec_id = fmt->video_codec;
	pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;
	pCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
	pCodecCtx->width = in_w;
	pCodecCtx->height = in_h;
	pCodecCtx->bit_rate = 400000;
	pCodecCtx->gop_size = 250;

	pCodecCtx->time_base.num = 1;
	pCodecCtx->time_base.den = 25;

	pCodecCtx->qmin = 10;
	pCodecCtx->qmax = 51;

	pCodecCtx->max_b_frames = 3;

	//H.264
	if (pCodecCtx->codec_id == AV_CODEC_ID_H264) {
		av_dict_set(&param, "preset", "slow", 0);
		av_dict_set(&param, "tune", "zerolatency", 0);
	}
	if (pCodecCtx->codec_id == AV_CODEC_ID_HEVC) {
		av_dict_set(&param, "preset", "ultrafast", 0);
		av_dict_set(&param, "tune", "zerolatency", 0);
	}

	//打开编码器
	if (avcodec_open2(pCodecCtx, pCodec, &param) < 0) {
		printf("Failed to open encoder! \n");
		return -1;
	}

	pFrame = av_frame_alloc();
	picture_size = avpicture_get_size(pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);
	picture_buf = (uint8_t*)av_malloc(picture_size);
	avpicture_fill((AVPicture*)pFrame, picture_buf, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);
	pFrame->format = pCodecCtx->pix_fmt;
	pFrame->width = pCodecCtx->width;
	pFrame->height = pCodecCtx->height;
	printf("width:%d\n", pFrame->width);
	printf("height:%d\n", pFrame->height);
	//Write File Header
	avformat_write_header(pFormatCtx, NULL);

	av_new_packet(&pkt, picture_size);

	y_size = pCodecCtx->width * pCodecCtx->height;
	int64_t iStart = av_gettime();
	for (int i = 0; i < framenum; i++) {
		//Read raw YUV data
		if (fread(picture_buf, 1, y_size * 3 / 2, in_file) <= 0) {
			printf("Failed to read raw data! \n");
			return -1;
		}
		else if (feof(in_file)) {
			break;
		}
		pFrame->data[0] = picture_buf;              // Y
		pFrame->data[1] = picture_buf + y_size;      // U 
		pFrame->data[2] = picture_buf + y_size * 5 / 4;  // V
		//PTS
		//pFrame->pts=i;
		pFrame->pts = i * (video_st->time_base.den) / ((video_st->time_base.num) * 25);
		int got_picture = 0;

		//Encode
		//编辑一帧视频，将AVFrame（yuv）编码为AVPacket（h264）
		int ret = avcodec_encode_video2(pCodecCtx, &pkt, pFrame, &got_picture);
		if (ret < 0) {
			printf("Failed to encode! \n");
			return -1;
		}
		if (got_picture == 1) {
		//	printf("Succeed to encode frame: %5d\tsize:%5d\n", framecnt, pkt.size);
			framecnt++;
			pkt.stream_index = video_st->index;
			//将编码后的视频码流写入文件
			ret = av_write_frame(pFormatCtx, &pkt);
			av_free_packet(&pkt);
		}
	}
	printf("time: %d\n", av_gettime() - iStart);
	//Flush Encoder
	//输入的像素数据读取完成后调用该函数
	//输出编码器中剩余的AVPacket
	int ret = flush_encoder(pFormatCtx, 0);
	if (ret < 0) {
		printf("Flushing encoder failed\n");
		return -1;
	}

	//Write file trailer
	av_write_trailer(pFormatCtx);

	//Clean
	if (video_st) {
		avcodec_close(video_st->codec);
		av_free(pFrame);
		av_free(picture_buf);
	}
	avio_close(pFormatCtx->pb);
	avformat_free_context(pFormatCtx);

	fclose(in_file);
	return 0;

}

解码

#include <iostream>
#include <highgui.h>
#include <opencv2/core/core.hpp>  
#include <opencv2/highgui/highgui.hpp>  
#include <opencv2/imgproc/imgproc.hpp>

#define __STDC_CONSTANT_MACROS

extern "C" {
#include <libavutil/opt.h>
#include <libavcodec/avcodec.h>
#include <libavutil/channel_layout.h>
#include <libavutil/common.h>
#include <libavutil/imgutils.h>
#include <libavutil/mathematics.h>
#include <libavutil/samplefmt.h>
#include "libavformat/avformat.h"
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libavutil/time.h>
};

#pragma  comment(lib,"avcodec.lib")
#pragma  comment(lib,"avdevice.lib")
#pragma  comment(lib,"avfilter.lib")
#pragma  comment(lib,"avformat.lib")
#pragma  comment(lib,"avutil.lib")
#pragma  comment(lib,"postproc.lib")
#pragma  comment(lib,"swresample.lib")
#pragma  comment(lib,"swscale.lib")

using namespace std;
using namespace cv;

#define OUTPUT_YUV420P 0
#define SWS_BICUBIC 4
#define SDL_INIT_VIDEO 0x00000020u
#define SDL_INIT_AUDIO 0x00000010u
#define SDL_INIT_TIMER 0x00000001u
#define SDL_WINDOWPOS_UNDEFINED (0x1FFF0000|0)

void DisplayYUV(int w, int h, int fps, FILE* pFileIn)
{
	printf("yuv file w: %d, h: %d \n", w, h);

	//设置文件指针为文件末尾
	fseek(pFileIn, 0, SEEK_END);
	int frame_count = 0;
	
	//求文件帧数，对于MxN（rows x cols，M行N列）的BGR图像（CV_8UC3)，其对应的YUV420图像大小是(3M/2)xN（CV_8UC1）
	//frame_count = (int)((long long)ftell(pFileIn) / ((w * h * 3) / 2));  // ftell 用于求文件大小,fetell对大于2.1G的文件会出错
	//printf("frame num is %d \n", frame_count);
	fseek(pFileIn, 0, SEEK_SET);//文件内位置定位到文件头

	int bufLen = w * h * 3 / 2;
	unsigned char* pYuvBuf = new unsigned char[bufLen];

	for (int i = 0; i < 14315/*frame_count*/; i++)
	{
		fread(pYuvBuf, bufLen * sizeof(unsigned char), 1, pFileIn);

		Mat yuvImg;
		yuvImg.create(h * 3 / 2, w, CV_8UC1);
		memcpy(yuvImg.data, pYuvBuf, bufLen * sizeof(unsigned char));
		Mat rgbImg;
		//颜色空间转换
		cvtColor(yuvImg, rgbImg, CV_YUV2BGR_I420);

		//imshow("yuv", yuvImg);
		imshow("rgb", rgbImg);
		waitKey(1000 / fps);

		printf("cnt: %d \n", i);
	}

	delete[] pYuvBuf;


	fclose(pFileIn);
}

int main(int argc, char* argv[]) {

	AVFormatContext* pFormatCtx;
	int i, videoindex;
	AVCodecContext* pCodecCtx;

	AVCodec* pCodec;
	//存放yuv
	AVFrame* pFrame, * pFrameYUV;
	unsigned char* out_buffer;
	//存放h264
	AVPacket* packet;
	struct SwsContext* img_convert_ctx;

	int y_size;

	FILE* fp_yuv;
	int ret, got_picture;

	char filepath[] = "c:/users/37075/source/repos/ffmpeg_learn/h264/output2.h264";


	//初始化
	av_register_all();
	avformat_network_init();
	pFormatCtx = avformat_alloc_context();

	//打开文件
	if (avformat_open_input(&pFormatCtx, filepath, NULL, NULL) != 0) {
		printf("Couldn't open input stream.\n");
		return -1;
	}
	//获取流的信息
	if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
		printf("Couldn't find stram information.\n");
		return -1;
	}
	videoindex = -1;
	for (i = 0; i < pFormatCtx->nb_streams; i++)
		//判断是否是视频
		if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
			videoindex = i;
			break;
		}

	if (videoindex == -1) {
		printf("Didn't find a video stream.\n");
		return -1;
	}

	//获取解码器
	pCodecCtx = pFormatCtx->streams[videoindex]->codec;
	if ((pCodec = avcodec_find_decoder(pCodecCtx->codec_id)) == NULL) {
		printf("Codec not found.\n");
		return -1;
	}
	//打开解码器
	if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
		printf("Could not open codec.\n");
		return -1;
	}

	FILE* fp = fopen("c:/users/37075/source/repos/ffmpeg_learn/info/output.txt", "wb+");

	fprintf(fp, "Duration: %d\n", pFormatCtx->duration);
	fprintf(fp, "Long Name: %s\n", pFormatCtx->iformat->long_name);
	fprintf(fp, "Width*Height: %d*%d\n", pFormatCtx->streams[videoindex]->codec->width, pFormatCtx->streams[videoindex]->codec->height);

	fclose(fp);

	//申请AVFrame结构，申请内存
	pFrame = av_frame_alloc();
	pFrameYUV = av_frame_alloc();

	//申请内存
	out_buffer = (unsigned char*)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1));

	//设置data和linesize
	av_image_fill_arrays(pFrameYUV->data, pFrameYUV->linesize, out_buffer, AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1);
	packet = (AVPacket*)av_malloc(sizeof(AVPacket));
	printf("--------------- File Information ----------------\n");
	// Dump information about file onto standard error
	av_dump_format(pFormatCtx, 0, filepath, 0);
	printf("-------------------------------------------------\n");
	img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);

	fp_yuv = fopen("c:/users/37075/source/repos/ffmpeg_learn/yuv/output.yuv", "wb+");

	//FILE* fp_h264 = fopen("c:/users/37075/source/repos/ffmpeg_learn/h264/test.h264", "wb+");
	//读取整个视频流，解码成帧，转换为yuv并保存
	//输入一个AVFrame，输出一个AVPacket
	int64_t iStart = av_gettime();
	while (av_read_frame(pFormatCtx, packet) >= 0) {
		// Is this a packet from the video stream?
		if (packet->stream_index == videoindex) {
			//fwrite(packet->data, 1, packet->size, fp_h264);
			//解码
			ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
			if (ret < 0) {
				printf("Decode Error.\n");
				return -1;
			}
			if (got_picture) {
				sws_scale(img_convert_ctx, (const unsigned char* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height,
					pFrameYUV->data, pFrameYUV->linesize);
				y_size = pCodecCtx->width * pCodecCtx->height;
				fwrite(pFrameYUV->data[0], 1, y_size, fp_yuv); //Y
				fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_yuv);	//U
				fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_yuv);	//V
			}
		}
		av_free_packet(packet);
	}

	printf("time: %d\n", av_gettime() - iStart);
	//fclose(fp_h264);

	while (1) {
		ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
		if (ret < 0) break;
		if (got_picture) break;
		sws_scale(img_convert_ctx, (const unsigned char* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height,
			pFrameYUV->data, pFrameYUV->linesize);
		y_size = pCodecCtx->width * pCodecCtx->height;
		fwrite(pFrameYUV->data[0], 1, y_size, fp_yuv); //Y
		fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_yuv); //U
		fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_yuv); //V
	}

	//ifstream fp_in;
	//fp_in.open("c:/users/37075/source/repos/ffmpeg_learn/yuv/output.yuv", ios_base::in | ios_base::binary);
	//if (fp_in.fail()) {
	//	cout << "the file is error" << endl;
	//	return -1;
	//}

	sws_freeContext(img_convert_ctx);
	
	DisplayYUV(pCodecCtx->width, pCodecCtx->height, 25, fp_yuv);

	fclose(fp_yuv);
	
	av_frame_free(&pFrameYUV);
	av_frame_free(&pFrame);
	avcodec_close(pCodecCtx);
	avformat_close_input(&pFormatCtx);

	return 0;
}

#include <iostream>
#include <highgui.h>
#include <opencv2/core/core.hpp>  
#include <opencv2/highgui/highgui.hpp>  
#include <opencv2/imgproc/imgproc.hpp>

#define __STDC_CONSTANT_MACROS

extern "C" {
#include <libavutil/opt.h>
#include <libavcodec/avcodec.h>
#include <libavutil/channel_layout.h>
#include <libavutil/common.h>
#include <libavutil/imgutils.h>
#include <libavutil/mathematics.h>
#include <libavutil/samplefmt.h>
#include "libavformat/avformat.h"
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>
#include <libavutil/time.h>
};

#pragma  comment(lib,"avcodec.lib")
#pragma  comment(lib,"avdevice.lib")
#pragma  comment(lib,"avfilter.lib")
#pragma  comment(lib,"avformat.lib")
#pragma  comment(lib,"avutil.lib")
#pragma  comment(lib,"postproc.lib")
#pragma  comment(lib,"swresample.lib")
#pragma  comment(lib,"swscale.lib")

using namespace std;
using namespace cv;

#define OUTPUT_YUV420P 0
#define SWS_BICUBIC 4
#define SDL_INIT_VIDEO 0x00000020u
#define SDL_INIT_AUDIO 0x00000010u
#define SDL_INIT_TIMER 0x00000001u
#define SDL_WINDOWPOS_UNDEFINED (0x1FFF0000|0)

void DisplayYUV(int w, int h, int fps, FILE* pFileIn)
{
	printf("yuv file w: %d, h: %d \n", w, h);

	//设置文件指针为文件末尾
	fseek(pFileIn, 0, SEEK_END);
	int frame_count = 0;

	//求文件帧数，对于MxN（rows x cols，M行N列）的BGR图像（CV_8UC3)，其对应的YUV420图像大小是(3M/2)xN（CV_8UC1）
	//frame_count = (int)((long long)ftell(pFileIn) / ((w * h * 3) / 2));  // ftell 用于求文件大小,fetell对大于2.1G的文件会出错
	//printf("frame num is %d \n", frame_count);
	fseek(pFileIn, 0, SEEK_SET);//文件内位置定位到文件头

	int bufLen = w * h * 3 / 2;
	unsigned char* pYuvBuf = new unsigned char[bufLen];

	for (int i = 0; i < 14315/*frame_count*/; i++)
	{
		fread(pYuvBuf, bufLen * sizeof(unsigned char), 1, pFileIn);

		Mat yuvImg;
		yuvImg.create(h * 3 / 2, w, CV_8UC1);
		memcpy(yuvImg.data, pYuvBuf, bufLen * sizeof(unsigned char));
		Mat rgbImg;
		//颜色空间转换
		cvtColor(yuvImg, rgbImg, CV_YUV2BGR_I420);

		//imshow("yuv", yuvImg);
		imshow("rgb", rgbImg);
		waitKey(1000 / fps);

		printf("cnt: %d \n", i);
	}

	delete[] pYuvBuf;


	fclose(pFileIn);
}

int main(int argc, char* argv[]) {

	AVFormatContext* pFormatCtx;
	int i, videoindex;
	AVCodecContext* pCodecCtx;

	AVCodec* pCodec;
	//存放yuv
	AVFrame* pFrame, * pFrameYUV;
	unsigned char* out_buffer;
	//存放h264
	AVPacket* packet;
	struct SwsContext* img_convert_ctx;

	int y_size;

	FILE* fp_yuv;
	int ret, got_picture;

	char filepath[] = "c:/users/37075/source/repos/ffmpeg_learn/h264/output2.h264";

	//初始化
	av_register_all();
	avcodec_register_all();
	avformat_network_init();
	pFormatCtx = avformat_alloc_context();

	//打开文件
	if (avformat_open_input(&pFormatCtx, filepath, NULL, NULL) != 0) {
		printf("Couldn't open input stream.\n");
		return -1;
	}
	//获取流的信息
	if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
		printf("Couldn't find stram information.\n");
		return -1;
	}
	videoindex = -1;
	for (i = 0; i < pFormatCtx->nb_streams; i++)
		//判断是否是视频
		if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
			videoindex = i;
			break;
		}

	if (videoindex == -1) {
		printf("Didn't find a video stream.\n");
		return -1;
	}

	//获取解码器
	pCodecCtx = pFormatCtx->streams[videoindex]->codec;
	pCodec = avcodec_find_decoder_by_name("h264_cuvid");
	if(!pCodec){
		printf("Codec not found.\n");
		return -1;
	}
	//打开解码器
	if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
		printf("Could not open codec.\n");
		return -1;
	}

	FILE* fp = fopen("c:/users/37075/source/repos/ffmpeg_learn/info/output.txt", "wb+");

	fprintf(stderr, "Duration: %d\n", pFormatCtx->duration);
	fprintf(stderr, "Long Name: %s\n", pFormatCtx->iformat->long_name);
	fprintf(stderr, "Width*Height: %d*%d\n", pFormatCtx->streams[videoindex]->codec->width, pFormatCtx->streams[videoindex]->codec->height);

	printf("height: %d\n", pCodecCtx->width);
	printf("width: %d\n", pCodecCtx->height);
	fclose(fp);

	//申请AVFrame结构，申请内存
	pFrame = av_frame_alloc();
	pFrameYUV = av_frame_alloc();

	//申请内存
	out_buffer = (unsigned char*)av_malloc(av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1));

	//设置data和linesize
	av_image_fill_arrays(pFrameYUV->data, pFrameYUV->linesize, out_buffer, AV_PIX_FMT_YUV420P, pCodecCtx->width, pCodecCtx->height, 1);
	pFrameYUV->width = pCodecCtx->width;
	pFrameYUV->height = pCodecCtx->height;
	pFrame->width = pCodecCtx->width;
	pFrame->height = pCodecCtx->height;
	packet = (AVPacket*)av_malloc(sizeof(AVPacket));
	printf("--------------- File Information ----------------\n");
	// Dump information about file onto standard error
	av_dump_format(pFormatCtx, 0, filepath, 0);
	printf("-------------------------------------------------\n");
	img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);

	fp_yuv = fopen("c:/users/37075/source/repos/ffmpeg_learn/yuv/output.yuv", "wb+");

	//FILE* fp_h264 = fopen("c:/users/37075/source/repos/ffmpeg_learn/h264/test.h264", "wb+");
	//读取整个视频流，解码成帧，转换为yuv并保存
	//输入一个AVFrame，输出一个AVPacket
	int64_t iStart = av_gettime();
	while (av_read_frame(pFormatCtx, packet) >= 0) {
		// Is this a packet from the video stream?
		if (packet->stream_index == videoindex) {
			//fwrite(packet->data, 1, packet->size, fp_h264);
			//解码
			ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
			if (ret < 0) {
				printf("Decode Error.\n");
				return -1;
			}
			if (got_picture) {
				sws_scale(img_convert_ctx, (const unsigned char* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height,
					pFrameYUV->data, pFrameYUV->linesize);
				y_size = pCodecCtx->width * pCodecCtx->height;
				fwrite(pFrameYUV->data[0], 1, y_size, fp_yuv); //Y
				fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_yuv);	//U
				fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_yuv);	//V
			}
		}
		av_free_packet(packet);
	}

	printf("time: %d\n", (av_gettime() - iStart));
	//fclose(fp_h264);

	while (1) {
		ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
		if (ret < 0) break;
		if (got_picture) break;
		sws_scale(img_convert_ctx, (const unsigned char* const*)pFrame->data, pFrame->linesize, 0, pCodecCtx->height,
			pFrameYUV->data, pFrameYUV->linesize);
		y_size = pCodecCtx->width * pCodecCtx->height;
		fwrite(pFrameYUV->data[0], 1, y_size, fp_yuv); //Y
		fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_yuv); //U
		fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_yuv); //V
	}

	//ifstream fp_in;
	//fp_in.open("c:/users/37075/source/repos/ffmpeg_learn/yuv/output.yuv", ios_base::in | ios_base::binary);
	//if (fp_in.fail()) {
	//	cout << "the file is error" << endl;
	//	return -1;
	//}

	sws_freeContext(img_convert_ctx);

	DisplayYUV(pCodecCtx->width, pCodecCtx->height, 25, fp_yuv);

	fclose(fp_yuv);

	av_frame_free(&pFrameYUV);
	av_frame_free(&pFrame);
	avcodec_close(pCodecCtx);
	avformat_close_input(&pFormatCtx);

	return 0;
}
东山阿强
关注
专栏目录
基于QT+FFmpeg+dxva2硬解码的，音视频播放软件，同时也支持播放url，本机摄像头等
11-11
软件使用的是ffandplayer的库，是基于基于QT+FFmpeg+dxva2硬解码，测试过程中可以对H265 4K高清等流畅的播放，适合研究QT+FFmpeg音视频同步的小伙子。 其中ffandplayer是开源的项目，作者巧妙的替换了FFmpeg原生的D3D device，使得可以在外部自己创建D3D device，从而更好的维护。
ffmpeg硬编解码 Inter QSV
宝安小雨
06-08 6674
硬编解码除了使用Nvidia的GPU之外，Inter的QSV也是一种不错的方案，跟Nvidia不同的是，如果希望使用ffmepg的Inter QSV编解码，需要在编译ffmepg时开启QSV的支持，即加上编译选项：–enable-libmfx。查看ffmpeg中已开启的对h264协议支持的库：ffmpeg -hide_banner -codecs | grep h264查看一下ffmpeg对Inter QSV的参数支持： 使用举例： 通过ffmpeg -h encoder=h264与ffmpeg -h d
深入理解FFmpeg--软/硬件解码流程
最新发布
Lemon_D1999的博客
07-19 1357
FFmpeg是一款强大的多媒体处理工具，支持软件和硬件解码。软件解码利用CPU执行解码过程，适用于各种平台，但可能对性能要求较高。硬件解码则利用GPU或其他专用硬件加速解码，能显著降低CPU负载，提升解码效率和能效。FFmpeg结合这两种解码方式，提供了灵活的多媒体解决方案，适合于视频处理、流媒体和多媒体应用开发。1、FFmpeg支持多种硬件加速类型，用于编解码视频，以提升性能和效率。这些硬件加速类型使FFmpeg在处理高分辨率视频时更加高效，减少了CPU负载，提高了多媒体处理的整体性能。
如何使用ffmpeg为Mac进行视频硬解码/硬编码（在Qt环境）
P_Leung的技术博客
01-15 4773
如何使用ffmpeg为Mac进行硬解/编码（Qt环境）科普前期准备安装ffmpeg将ffmpeg的库文件添加到Qt的.pro文件中在源文件用引入头文件第一步：先查看本机支持哪种硬件加速第二步：查看这个硬件加速方案支持哪种编码器&解码器第三步：在Qt源码中指定使用哪个编码器或解码器核心代码MacBook自带摄像头参数设置总结 科普 ffmpeg正确读法: f - f - m - peg 而不...
调用ffmpeg的vaapi编码h264
weixin_30632899的博客
03-09 1714
ffmpeg3.2的版本已经支持vaapi的硬件编码。 本文主要是讲解如何用C代码调用ffmpeg的vaapi硬件来编码H264。 具体代码请参考 https://github.com/wintersuny/call-vaapi-ffmpeg 转载于:https://www.cnblogs.com/syusst/p/6524027.html...
ffmpeg4教程12:intel media sdk(qsv)硬解码的使用方法+qt5 openggl显示AV_PIX_FMT_NV12
Java_lilin的专栏
01-17 8947
讨论群261074724 1.安装intel media sdk 请对于处理器的版本代号 2.参考ffmpeg官方的examples下的 qsvdec.c改造 如果差#include &lt;mfx/mfxvideo.h&gt;头文件需要将 文件下的include 重命名为mfx 考到工程   主要加了一个转换城rgb24的窗口显示 #include "pch.h" #include...
ffmpeg硬解码-jetson平台
05-14
在Jetson平台上实现FFmpeg的硬解码，首先需要确保FFmpeg源码支持相应的硬件加速库，如NVIDIA的VAAPI（Video Acceleration API）或NVDEC（NVIDIA Decode）。通常，这些库允许FFmpeg调用硬件的解码功能。在描述中提到...
用Ffmpeg进行h265编解码的实例
02-28
FFmpeg是一款强大的开源多媒体处理工具，它包含了各种用于音视频处理的库，如libavcodec（编解码库）、libavformat（容器格式处理库）和libavfilter（滤镜库）。在这个实例中，我们将专注于FFmpeg如何进行HEVC（High...
Android Ffmpeg解码。
04-04
本文将深入探讨如何在Android环境中使用FFmpeg进行解码，并结合OpenCV进行视频处理，以及利用JNI技术来实现软硬件解码和断线重连功能。 首先，我们需要了解FFmpeg的基本架构。FFmpeg包含多个组件，如libavformat...
ffmpeg5.1(支持openssl，支持AAC，PCM，支持h264、h265软硬解码等)
08-12
视频编解码方面，FFmpeg 5.1对h264和h265（也称为HEVC，High Efficiency Video Coding）的软解码和硬解码支持，为用户提供更多的灵活性。h264是当前最广泛使用的视频编码标准，尤其是在网络视频和蓝光光盘领域。h265...
iOS FFmpeg软编码demo
12-18
总的来说，iOS上的FFmpeg软编码涉及到音视频处理的基本概念，包括编码器、解码器、容器格式、像素格式转换等。通过学习和实践这个demo，开发者可以深入了解多媒体处理的底层机制，并具备在实际项目中应用的能力。
嵌入式设备上ffmpeg取摄像头+硬编码+rtmp推送
engine_men的博客
02-20 1791
手中的板子的CPU是三星coretex-a9的，板子有硬编能力（至于是哪个芯片没仔细看），通过一至两周的努力，成功实现硬编码成H.264并投递到rtmp服务器。大体实现如下： 1.使用ffmpeg取摄像头YUV数据； 2.将YUV数据喂给三星硬编API； 3.将硬编的数据通过librtmp投递； 废话少说，上代码，代码有些糙，将就看： #include <stdio.h> #inclu...
FFmpeg —— 12.示例程序（六）：视频编码器（YUV编码为H264）
热门推荐
天空的博客
04-18 1万+
参考： https://blog.csdn.net/leixiaohua1020/article/details/25430425 https://www.jianshu.com/p/5d661ba25ffa 流程 下面附一张使用FFmpeg编码视频的流程图。使用该流程，不仅可以编码H.264的视频，而且可以编码MPEG4/MPEG2/VP8等等各种FFmpeg支持的视频。图中蓝色背景的函...
FFMPEG硬件编解码器使用
江海细流的专栏
08-14 1万+
在前文《视频编解码硬件方案漫谈》中我们介绍硬件视频编解码的一般方案，本文我们进一步介绍音视频编解码如何在ffmpeg使用显卡硬件进行加速。 一、基本概况 ffmpeg对显卡厂家SDK进行封装和集成，实现部分的硬件编解码 NVIDIA AMD INTEL 编码器 xxx_nvenc xxx_amf xxxx_qsv ...
ffmpeg硬解码与软解码的压测对比
weixin_47407737的博客
02-09 3150
ffmpeg硬解码与软解码的压测脚本编写及结果对比分析
jni 学习FFmpeg-learning 笔记
yyo201的博客
04-30 272
没有找到比helloworld稍微复杂一点点的jni学习相关资料，但是找到ffmpeg 相关的demo，看起来还挺难的。 项目地址：https://github.com/whenSunSet/FFmpeg-learning/tree/master/app 他的简书：https://www.jianshu.com/u/45661204c0d6 这个项目是别的博主的源码地址，也在他自己的博客里...
【FFmpeg】调用ffmpeg进行H264软编
weixin_42877471的博客
04-29 1056
从上面这一系列的函数调用来看，大致操作流程和数据走向大约是 1.编码器的创建和初始化（avcodec_find_encoder） 2.编码器上下文的创建和初始化（avcodec_alloc_context3） 3.创建编码器输出信息，使用AVPacket进行存储（av_packet_alloc） 4.打开编码器（avcodec_open2） 5.创建编码器输入信息，使用AVFrame进行存储（av_frame_alloc） 6.获取编码器输入信息的数据Buffer（av_frame_get_buffer）
FFmpeg 软编码H.264与H.265
m0_60259116的博客
04-20 5805
当前网络中常见的视频编码格式要数H.264最为火热，支持H.264的封装格式有很多，如FLV ，MP4 ， HLS（M3U8），MKV ，TS等格式； FFMpeg本身并不支持H.264的编码器，而是由FFMpeg的第三方模块对其进行支持，例如x264和OpenH264，二者各有各的优势。由于OpenH264开源比较晚，所以x264还是当前最常用的编码器，这里将重点介绍FFMpeg中x264的使用；使用x264进行h.264编码时，所支持的像素格式主要包括yuy420p，yuvj420p，yuv422p,
FFmpeg系列之35：FFmpeg+CUDA硬件加速原理与案例
03-15
FFmpeg+CUDA硬件加速原理与案例实战FFmpeg系列之35FFmpeg第2季编解码专题之5：FFmpeg+CUDA硬件加速原理与案例实战本课程主要讲解的知识点包括：GPU高性能编程CUDA入门、CUDA编程模型的原理解析、CUDA编程小白案例入门实战、CUDA官方经典案例实战与解析、FFmpeg+CUVID硬件加速原理与命令行、Qt+FFmpeg实现cuda硬解码加速代码实战等。---------------------------------------------------------------目前FFmpeg第二季【编解码专题】，主要包括以下课程：FFmpeg4.3系列之31：图像格式与压缩FFmpeg4.3系列之32：MPEG-1/2视频编解码FFmpeg4.3系列之33：H.264/H.265视频编码FFmpeg4.3系列之34：FFmpeg+DXVA2+D3D硬件加速FFmpeg4.3系列之35：FFmpeg+CUDA硬件加速
qt把ffmpeg软解码改为硬解码
08-26
通过以上步骤，你可以将Qt中的FFmpeg软解码改为硬解码。这样可以提高视频解码的效率和性能，并减少CPU的占用。<span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值