유리상자 속 이야기

int SaveFrameToJPEG (AVCodecContext *pCodecCtx, AVFrame *pFrame, const char * file_name, const char * save_file_name, int size){ 
	AVCodecContext         *pOCodecCtx; 
	AVCodec                *pOCodec; 
	uint8_t                *Buffer; 
	int                     BufSiz; 
	int                     BufSizActual; 
	PixelFormat             ImgFmt = PIX_FMT_YUVJ420P; //for the newer ffmpeg version, this int to pixelformat 

	BufSiz = avpicture_get_size (PixelFormat::PIX_FMT_RGB24 ,pCodecCtx->width, pCodecCtx->height ); 

	Buffer = (uint8_t *)malloc ( BufSiz ); 
	if ( Buffer == NULL ) 
		return ( 0 ); 
	memset ( Buffer, 0, BufSiz ); 

	pOCodecCtx = avcodec_alloc_context ( ); 
	if ( !pOCodecCtx ) { 
		free ( Buffer ); 
		return ( 0 ); 
	} 

	pOCodecCtx->bit_rate      = pCodecCtx->bit_rate; 
	pOCodecCtx->width         = pCodecCtx->width; 
	pOCodecCtx->height        = pCodecCtx->height; 
	pOCodecCtx->pix_fmt       = ImgFmt; 
	pOCodecCtx->codec_id      = CODEC_ID_MJPEG; 
	pOCodecCtx->codec_type    = CODEC_TYPE_VIDEO; 
	pOCodecCtx->time_base.num = pCodecCtx->time_base.num; 
	pOCodecCtx->time_base.den = pCodecCtx->time_base.den; 

	pOCodec = avcodec_find_encoder ( pOCodecCtx->codec_id ); 
	if ( !pOCodec ) { 
		free ( Buffer ); 
		return ( 0 ); 
	} 
	if ( avcodec_open ( pOCodecCtx, pOCodec ) < 0 ) { 
		free ( Buffer ); 
		return ( 0 ); 
	} 

	pOCodecCtx->mb_lmin = pOCodecCtx->lmin = pOCodecCtx->qmin * FF_QP2LAMBDA; 
	pOCodecCtx->mb_lmax = pOCodecCtx->lmax = pOCodecCtx->qmax * FF_QP2LAMBDA; 
	pOCodecCtx->flags   = CODEC_FLAG_QSCALE; 
	pOCodecCtx->global_quality = pOCodecCtx->qmin * FF_QP2LAMBDA; 

	pFrame->pts = 1; 
	pFrame->quality = pOCodecCtx->global_quality; 
	BufSizActual = avcodec_encode_video(pOCodecCtx,Buffer,BufSiz,pFrame ); 


	//ResizeImage
	void * m_buffer = ::GlobalAlloc(GMEM_MOVEABLE, BufSizActual);
	if(m_buffer) {
		void * pBuffer = ::GlobalLock(m_buffer);
		if(pBuffer) {
			CopyMemory(pBuffer, Buffer, BufSizActual);

			IStream * pStream = NULL;
			if(::CreateStreamOnHGlobal(m_buffer, FALSE, &pStream) == S_OK) {
				// 이미지 생성
				CImage image_org;
				image_org.Load(pStream);
				pStream->Release();
				
				if(image_org.GetHeight() <= size) {
					CString saveFileName(save_file_name);
					image_org.Save(saveFileName);
					image_org.Destroy();
				} else {
					// 리사이즈 크기
					int height = size;
					int width = height * image_org.GetWidth() / image_org.GetHeight();

					// 사본 생성
					CImage image_cpy;
					image_cpy.Create(width, height, image_org.GetBPP());
					HDC hdc = image_cpy.GetDC();
					SetStretchBltMode(hdc, HALFTONE);
					image_org.StretchBlt(hdc, 0, 0, width, height, SRCCOPY);
					
					// 저장
					CString saveFileName(save_file_name);
					image_cpy.Save(saveFileName);

					// 리소스 해제
					image_cpy.ReleaseDC();
					image_cpy.Destroy();
					image_org.Destroy();
				}
			}
			::GlobalUnlock(pBuffer);
		}
		::GlobalFree(m_buffer);
	}

	avcodec_close ( pOCodecCtx ); 
	free ( Buffer ); 
	return ( BufSizActual ); 
} 



int ExtractFrame(const char * video_path, const char * save_file_name, int size, double pos)
{
	AVFormatContext *pFormatCtx;
	int             i, videoStream;
	AVCodecContext  *pCodecCtx;
	AVCodec         *pCodec;
	AVFrame         *pFrame; 
	AVFrame         *pFrameRGB;
	AVPacket		packet;
	int				frameFinished;
	int             numBytes;
	uint8_t         *buffer;

	// Register all formats and codecs
	av_register_all();

	// Open video file
	if(av_open_input_file(&pFormatCtx, video_path, NULL, 0, NULL)!=0)
		return -1; // Couldn't open file

	// Retrieve stream information
	if(av_find_stream_info(pFormatCtx)<0)
		return -1; // Couldn't find stream information

	// Dump information about file onto standard error
	//dump_format(pFormatCtx, 0, video_path, false);

	// Find the first video stream
	videoStream=-1;
	for(i=0; i < pFormatCtx->nb_streams; i++) {
		if(pFormatCtx->streams[i]->codec->codec_type==CODEC_TYPE_VIDEO)
		{
			videoStream=i;
			break;
		}
	}
	if(videoStream==-1)
		return -1; // Didn't find a video stream

	// Get a pointer to the codec context for the video stream
	pCodecCtx=pFormatCtx->streams[videoStream]->codec;

	// Find the decoder for the video stream
	pCodec=avcodec_find_decoder(pCodecCtx->codec_id);
	if(pCodec==NULL)
		return -1; // Codec not found

	// Open codec
	if(avcodec_open(pCodecCtx, pCodec)<0)
		return -1; // Could not open codec

	// Allocate video frame
	pFrame=avcodec_alloc_frame();

	// Allocate an AVFrame structure
	pFrameRGB=avcodec_alloc_frame();
	if(pFrameRGB==NULL)
		return -1;

	// Determine required buffer size and allocate buffer
	numBytes=avpicture_get_size(PIX_FMT_RGB24, pCodecCtx->width, pCodecCtx->height);
	buffer = (uint8_t *)av_malloc(numBytes * sizeof(uint8_t));

	// Assign appropriate parts of buffer to image planes in pFrameRGB
	avpicture_fill((AVPicture *)pFrameRGB, buffer, PIX_FMT_RGB24,pCodecCtx->width, pCodecCtx->height);

	
	// Read frames and save first five frames to disk
	i=0;
	//////////////////////////////////////////////////////////
	// Seeking
	// 
	AVStream *pStream = pFormatCtx->streams[videoStream];
	double duration = (double) pFormatCtx->duration / AV_TIME_BASE; 
	if (duration <= 0) 
	{			
		double tmpDuration = 0.0;
		if (pStream->codec->bit_rate > 0 && pFormatCtx->file_size > 0)
		{
			if (pStream->codec->bit_rate >= 8)
			{
				tmpDuration = 0.9 * pFormatCtx->file_size / (pStream->codec->bit_rate / 8);
			}
			if (tmpDuration > 0) 
			{
				duration = tmpDuration;
			}
		}
	}
	if(duration <= 0) { return -1; }
	int64_t tarPos = (long)(duration * pos);
	if(tarPos < 0) { tarPos = 0; }
	else if(tarPos >= duration) { tarPos = (duration - 1) / av_q2d(pStream->time_base); }
	else { tarPos = tarPos / av_q2d(pStream->time_base); }
	av_seek_frame(pFormatCtx, videoStream, tarPos, 0);


	while(av_read_frame(pFormatCtx, &packet) >= 0) {
		if(packet.stream_index == videoStream) {		
			//////////////////////////////////////////////////////////

			// Decode video frame
			avcodec_decode_video(pCodecCtx, pFrame, &frameFinished, packet.data, packet.size);

			if(frameFinished) {
				static int sws_flags = SWS_BICUBIC;
				struct SwsContext *img_convert_ctx;
				img_convert_ctx = sws_getContext(
					pCodecCtx->width,
					pCodecCtx->height, 
					pCodecCtx->pix_fmt, 
					pCodecCtx->width, 
					pCodecCtx->height, 
					PixelFormat::PIX_FMT_RGB24, 
					sws_flags, NULL, NULL, NULL);
				
				sws_scale(img_convert_ctx, pFrame->data, pFrame->linesize, 0, pCodecCtx->height, pFrameRGB->data, pFrameRGB->linesize);
				sws_freeContext(img_convert_ctx);

				SaveFrameToJPEG(pCodecCtx, pFrame, video_path, save_file_name, size);

				av_free_packet(&packet);
				break;
			}
		}
		av_free_packet(&packet);
	}

	av_free(buffer);
	av_free(pFrameRGB);

	// Free the YUV frame
	av_free(pFrame);

	// Close the codec
	avcodec_close(pCodecCtx);

	// Close the video file
	av_close_input_file(pFormatCtx);

	return 0;
}