ffmpeg 关键帧截图

#include <stdio.h>
#include "iostream"
#include <stdint.h>
extern "C"
{
#include "libavcodec/avcodec.h"
#include "libavformat/avformat.h"
#include "libswscale/swscale.h"
#include "jpeglib.h"
}
using namespace std;

char* format_time(float time)
{
	char strtime[13];
	sprintf(strtime,"%f",time);
	string strms = strtime;
	int second_time = (int)time;
	int h = second_time/3600;
	int m = second_time%3600/60;
	int s = second_time%60;
	string str = strms.substr(strms.find(".")+1,3);
	char realtime[13];
	sprintf(realtime,"%02d-%02d-%02d-%s",h,m,s,str.c_str());
	return realtime;
}
//实现视频帧的jpeg压缩
void saveFrame(AVFrame* pFrame, int width, int height, float iFrame)
{
	char fname[128] = { 0 };
	struct jpeg_compress_struct cinfo;
	struct jpeg_error_mgr jerr;
	JSAMPROW row_pointer[1];
	int row_stride;
	uint8_t *buffer;
	FILE *fp;

	buffer = pFrame->data[0];

	sprintf(fname, "%s.jpg",format_time(iFrame));

	fp = fopen(fname, "wb");

	cinfo.err = jpeg_std_error(&jerr);
	jpeg_create_compress(&cinfo);
	jpeg_stdio_dest(&cinfo, fp);
	
	cinfo.image_width = width;
	cinfo.image_height = height;
	cinfo.input_components = 3;
	cinfo.in_color_space = JCS_RGB;

	jpeg_set_defaults(&cinfo);

	jpeg_set_quality(&cinfo, 80, TRUE);

	jpeg_start_compress(&cinfo, TRUE);

	row_stride = width * 3;
	while (cinfo.next_scanline < height)
	{
		row_pointer[0] = &buffer[cinfo.next_scanline * row_stride];
		(void)jpeg_write_scanlines(&cinfo, row_pointer, 1);
	}

	jpeg_finish_compress(&cinfo);
	fclose(fp);
	jpeg_destroy_compress(&cinfo);
	return;
}
int main(int argc,char* argv[])
{
	if (argc < 4)
	{
		return 0;
	}
	AVFormatContext *pFormatCtx;
	int i, videoIndex;
	AVCodecContext *pCodecCtx = NULL;
	AVCodec *pCodec = NULL;
	
	AVPacket packet;
	int frameFinished;
	int numBytes;
	uint8_t *buffer;

	pFormatCtx = avformat_alloc_context();
	av_register_all();
	if (avformat_open_input(&pFormatCtx, argv[1], NULL, 0) != 0)
		return -1;
	if (avformat_find_stream_info(pFormatCtx, NULL) < 0)
		return -1;
	av_dump_format(pFormatCtx, 0, argv[1], 0);

	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)
	{
		fprintf(stderr, "unsupport codec\n");
		return -1;
	}
	pCodecCtx = pFormatCtx->streams[videoIndex]->codec;
	pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
	if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0)
		return -1;

	AVFrame *pFrameRGB, *pFrame;
	pFrame = av_frame_alloc();
	pFrameRGB = av_frame_alloc();
	if (pFrame == NULL)
		return -1;

	numBytes = avpicture_get_size(PIX_FMT_RGB24, atoi(argv[2]), atoi(argv[3]));
	buffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));

	avpicture_fill((AVPicture*)pFrameRGB, buffer, PIX_FMT_RGB24, atoi(argv[2]),atoi(argv[3]));
	
	i = 0;
	struct SwsContext* img_convert_ctx;
	img_convert_ctx = sws_getContext(pCodecCtx->width, pCodecCtx->height, pCodecCtx->pix_fmt,
		atoi(argv[2]), atoi(argv[3]), PIX_FMT_RGB24, SWS_BICUBIC, NULL, NULL, NULL);


	int count =0;
	while (av_read_frame(pFormatCtx, &packet) >= 0){
		if (packet.stream_index == videoIndex){
			avcodec_decode_video2(pCodecCtx, pFrame, &frameFinished, &packet);
			count++;
			if (frameFinished)
			{
				if (pFrame->key_frame == 1)
				{
					sws_scale(img_convert_ctx, pFrame->data, pFrame->linesize, 0, pCodecCtx->height, 
						pFrameRGB->data, pFrameRGB->linesize);
					//AVRational frame_rate = pFormatCtx->streams[videoIndex]->avg_frame_rate;
					float time = count*0.04;
					saveFrame(pFrameRGB, atoi(argv[2]), atoi(argv[3]), time);
				}
				
			}
		}
		av_free_packet(&packet);
	}

	av_free(buffer);
	av_free(pFrameRGB);
	av_free(pFrame);
	avcodec_close(pCodecCtx);
	return 0;
}