bool CAviHelper::AVI_resolution(const wstring& strAviFileName, int& width, int& height)
{
AVIFileInit();
PAVIFILE avi;
int res = AVIFileOpen(&avi, WS2S(strAviFileName).c_str(), OF_READ, NULL);
int n = GetLastError();
if (res!=AVIERR_OK)
{
//an error occures
if (avi!=NULL)
AVIFileRelease(avi);
return false;
}
AVIFILEINFO avi_info;
memset(&avi_info, 0, sizeof(AVIFILEINFO));
res = AVIFileInfo(avi, &avi_info, sizeof(AVIFILEINFO));
if( res != AVIERR_OK)
{
AVIFileExit();
return false;
}
width = avi_info.dwWidth;
height = avi_info.dwHeight;
AVIFileExit();
return true;
}
bool AviFrameGraber::_Open(void){
//thread_handle_ !=NULL means it is already opened
if (thread_handle_!=NULL) return false;
int res=AVIFileOpen(&avi_file_, file_path_.c_str(), OF_READ, NULL);
if (res!=AVIERR_OK){
woodychang0611::diagnostics::SendError(_T("AviFrameGraber Open File Fail"));
_Close();
return false;
}
res=AVIFileGetStream(avi_file_, &stream_, streamtypeVIDEO, 0/*first stream*/);
if (res!=AVIERR_OK){
woodychang0611::diagnostics::SendError(_T("AviFrameGraber Get Stream Fail"));
_Close();
return false;
}
if (AVIStreamStart(stream_)==-1 || AVIStreamLength(stream_)==-1){
woodychang0611::diagnostics::SendError(_T("AviFrameGraber Stream Start or Length no correct"));
_Close();
return false;
}
AVIFileInfo(avi_file_, &avi_info_, sizeof(AVIFILEINFO));
BITMAPINFOHEADER bih;
bih.biSize = sizeof(BITMAPINFOHEADER);
bih.biWidth = avi_info_.dwWidth;
bih.biHeight = avi_info_.dwHeight;
bih.biPlanes = 1;
bih.biBitCount = 24;
bih.biCompression = BI_RGB;
bih.biSizeImage = 0;
bih.biXPelsPerMeter = 0;
bih.biYPelsPerMeter = 0;
bih.biClrUsed = 0;
bih.biClrImportant = 0;
frame_=AVIStreamGetFrameOpen(stream_, (LPBITMAPINFOHEADER) &bih);
if (frame_ !=NULL){
start_frame_ = AVIStreamStart(stream_);
frame_length_ = AVIStreamLength(stream_);
current_frame_ = start_frame_;
//Set Frame info
frame_info_.start_frame_=start_frame_;
frame_info_.frame_length_ =frame_length_;
frame_info_.frame_per_second_=(FLOAT32)avi_info_.dwRate/avi_info_.dwScale;
frame_info_.frame_width_=(UINT16) avi_info_.dwWidth;
frame_info_.frame_height_=(UINT16) avi_info_.dwHeight;
_status = FRAME_SUBJECT_PAUSE;
thread_handle_ =CreateThread(NULL ,0,this->_ThreadFunc,this,0,NULL);
return true;
}else{
woodychang0611::diagnostics::SendError(_T("AviFrameGraber Get Frame Failed"));
}
return false;
}
BOOL FMPlayerDShow::GetAVIInfo(const tchar* pFileName)
{
AVIFileInit();
PAVIFILE pfile;
BOOL bOK = FALSE;
if(AVIFileOpen(&pfile, pFileName, OF_SHARE_DENY_NONE, 0L) == 0)
{
AVIFILEINFO afi;
memset(&afi, 0, sizeof(afi));
AVIFileInfo(pfile, &afi, sizeof(AVIFILEINFO));
CComPtr<IAVIStream> pavi;
if(AVIFileGetStream(pfile, &pavi, streamtypeVIDEO, 0) == AVIERR_OK)
{
AVISTREAMINFO si;
AVIStreamInfo(pavi, &si, sizeof(si));
m_FourCC = FormatFourCC(si.fccHandler);
m_FrameRate = (double)si.dwRate / (double)si.dwScale;
LONG lFormat;
if (0 == AVIStreamFormatSize(pavi, 0, &lFormat))
{
char* pBuf = new char[lFormat];
if (0 == AVIStreamReadFormat(pavi, 0, pBuf, &lFormat))
{
BITMAPINFOHEADER* pHeader = (BITMAPINFOHEADER*)pBuf;
m_StreamFormat = FormatFourCC(pHeader->biCompression);
}
delete[] pBuf;
}
bOK = TRUE;
}
AVIFileRelease(pfile);
}
AVIFileExit();
return bOK;
}
static int avisynth_read_header(AVFormatContext *s, AVFormatParameters *ap)
{
AVISynthContext *avs = s->priv_data;
HRESULT res;
AVIFILEINFO info;
DWORD id;
AVStream *st;
AVISynthStream *stream;
AVIFileInit();
res = AVIFileOpen(&avs->file, s->filename, OF_READ|OF_SHARE_DENY_WRITE, NULL);
if (res != S_OK)
{
av_log(s, AV_LOG_ERROR, "AVIFileOpen failed with error %ld", res);
AVIFileExit();
return -1;
}
res = AVIFileInfo(avs->file, &info, sizeof(info));
if (res != S_OK)
{
av_log(s, AV_LOG_ERROR, "AVIFileInfo failed with error %ld", res);
AVIFileExit();
return -1;
}
avs->streams = av_mallocz(info.dwStreams * sizeof(AVISynthStream));
for (id=0; id<info.dwStreams; id++)
{
stream = &avs->streams[id];
stream->read = 0;
if (AVIFileGetStream(avs->file, &stream->handle, 0, id) == S_OK)
{
if (AVIStreamInfo(stream->handle, &stream->info, sizeof(stream->info)) == S_OK)
{
if (stream->info.fccType == streamtypeAUDIO)
{
WAVEFORMATEX wvfmt;
LONG struct_size = sizeof(WAVEFORMATEX);
if (AVIStreamReadFormat(stream->handle, 0, &wvfmt, &struct_size) != S_OK)
continue;
st = av_new_stream(s, id);
st->codec->codec_type = CODEC_TYPE_AUDIO;
st->codec->block_align = wvfmt.nBlockAlign;
st->codec->channels = wvfmt.nChannels;
st->codec->sample_rate = wvfmt.nSamplesPerSec;
st->codec->bit_rate = wvfmt.nAvgBytesPerSec * 8;
st->codec->bits_per_sample = wvfmt.wBitsPerSample;
stream->chunck_samples = wvfmt.nSamplesPerSec * (uint64_t)info.dwScale / (uint64_t)info.dwRate;
stream->chunck_size = stream->chunck_samples * wvfmt.nChannels * wvfmt.wBitsPerSample / 8;
st->codec->codec_tag = wvfmt.wFormatTag;
st->codec->codec_id = wav_codec_get_id(wvfmt.wFormatTag, st->codec->bits_per_sample);
}
else if (stream->info.fccType == streamtypeVIDEO)
{
BITMAPINFO imgfmt;
LONG struct_size = sizeof(BITMAPINFO);
stream->chunck_size = stream->info.dwSampleSize;
stream->chunck_samples = 1;
if (AVIStreamReadFormat(stream->handle, 0, &imgfmt, &struct_size) != S_OK)
continue;
st = av_new_stream(s, id);
st->codec->codec_type = CODEC_TYPE_VIDEO;
st->r_frame_rate.num = stream->info.dwRate;
st->r_frame_rate.den = stream->info.dwScale;
st->codec->width = imgfmt.bmiHeader.biWidth;
st->codec->height = imgfmt.bmiHeader.biHeight;
st->codec->bits_per_sample = imgfmt.bmiHeader.biBitCount;
st->codec->bit_rate = (uint64_t)stream->info.dwSampleSize * (uint64_t)stream->info.dwRate * 8 / (uint64_t)stream->info.dwScale;
st->codec->codec_tag = imgfmt.bmiHeader.biCompression;
st->codec->codec_id = codec_get_id(codec_bmp_tags, imgfmt.bmiHeader.biCompression);
st->duration = stream->info.dwLength;
}
else
{
AVIStreamRelease(stream->handle);
continue;
}
avs->nb_streams++;
st->codec->stream_codec_tag = stream->info.fccHandler;
av_set_pts_info(st, 64, info.dwScale, info.dwRate);
st->start_time = stream->info.dwStart;
}
}
}
return 0;
}
int avisynth_read_header() {
avs = (AVISynthContext *) av_mallocz(sizeof(AVISynthContext));
HRESULT res;
AVIFILEINFO info;
DWORD id;
AVIFileInit();
res = AVIFileOpen(&avs->file, read_config_filepath(), OF_READ|OF_SHARE_DENY_WRITE, NULL);
if (res != S_OK)
{
av_log(s, AV_LOG_ERROR, "AVIFileOpen failed with error %ld", res);
AVIFileExit();
return -1;
}
res = AVIFileInfo(avs->file, &info, sizeof(info));
if (res != S_OK)
{
av_log(s, AV_LOG_ERROR, "AVIFileInfo failed with error %ld", res);
AVIFileExit();
return -1;
}
avs->streams = (AVISynthStream *) av_mallocz(info.dwStreams * sizeof(AVISynthStream));
assert(info.dwStreams == 1);
for (id=0; id<info.dwStreams; id++)
{
stream = &avs->streams[id];
stream->read = 0;
if (AVIFileGetStream(avs->file, &stream->handle, 0, id) == S_OK)
{
if (AVIStreamInfo(stream->handle, &stream->info, sizeof(stream->info)) == S_OK)
{
if (stream->info.fccType == streamtypeAUDIO)
{
assert(false); // don't do audio yet
LONG struct_size = sizeof(WAVEFORMATEX);
if (AVIStreamReadFormat(stream->handle, 0, &wvfmt, &struct_size) != S_OK)
continue;
/* audio:
st = avformat_new_stream(s, NULL);
st->id = id;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->block_align = wvfmt.nBlockAlign;
st->codec->channels = wvfmt.nChannels;
st->codec->sample_rate = wvfmt.nSamplesPerSec;
st->codec->bit_rate = wvfmt.nAvgBytesPerSec * 8;
st->codec->bits_per_coded_sample = wvfmt.wBitsPerSample;
st->codec->codec_tag = wvfmt.wFormatTag;
st->codec->codec_id = ff_wav_codec_get_id(wvfmt.wFormatTag, st->codec->bits_per_coded_sample);
*/
stream->chunck_samples = wvfmt.nSamplesPerSec * (__int64)info.dwScale / (__int64) info.dwRate;
stream->chunck_size = stream->chunck_samples * wvfmt.nChannels * wvfmt.wBitsPerSample / 8;
}
else if (stream->info.fccType == streamtypeVIDEO)
{
LONG struct_size = sizeof(BITMAPINFO);
stream->chunck_size = stream->info.dwSampleSize;
stream->chunck_samples = 1;
if (AVIStreamReadFormat(stream->handle, 0, &savedVideoFormat, &struct_size) != S_OK)
continue;
/*
stream->info.dwRate is numerator
stream->info.dwScale is denominator [?]
savedVideoFormat.bmiHeader.biWidth
*/
/*st = avformat_new_stream(s, NULL);
st->id = id;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->r_frame_rate.num = stream->info.dwRate;
st->r_frame_rate.den = stream->info.dwScale;
st->codec->width = savedVideoFormat.bmiHeader.biWidth;
st->codec->height = savedVideoFormat.bmiHeader.biHeight;
st->codec->bits_per_coded_sample = savedVideoFormat.bmiHeader.biBitCount;
st->codec->bit_rate = (uint64_t)stream->info.dwSampleSize * (uint64_t)stream->info.dwRate * 8 / (uint64_t)stream->info.dwScale;
st->codec->codec_tag = savedVideoFormat.bmiHeader.biCompression;
st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, savedVideoFormat.bmiHeader.biCompression);
if (st->codec->codec_id == CODEC_ID_RAWVIDEO && savedVideoFormat.bmiHeader.biCompression== BI_RGB) {
st->codec->extradata = av_malloc(9 + FF_INPUT_BUFFER_PADDING_SIZE);
if (st->codec->extradata) {
st->codec->extradata_size = 9;
memcpy(st->codec->extradata, "BottomUp", 9);
}
}
st->duration = stream->info.dwLength;
*/
}
else
{
AVIStreamRelease(stream->handle);
continue;
}
avs->nb_streams++;
// st->codec->stream_codec_tag = stream->info.fccHandler;
//avpriv_set_pts_info(st, 64, info.dwScale, info.dwRate);
//st->start_time = stream->info.dwStart; // wow what is the dshow equivalent? hmm...
}
}
}
return 0;
}
static int avisynth_read_header(AVFormatContext *s)
{
AVISynthContext *avs = s->priv_data;
HRESULT res;
AVIFILEINFO info;
DWORD id;
AVStream *st;
AVISynthStream *stream;
wchar_t filename_wchar[1024] = { 0 };
char filename_char[1024] = { 0 };
AVIFileInit();
/* avisynth can't accept UTF-8 filename */
MultiByteToWideChar(CP_UTF8, 0, s->filename, -1, filename_wchar, 1024);
WideCharToMultiByte(CP_THREAD_ACP, 0, filename_wchar, -1, filename_char, 1024, NULL, NULL);
res = AVIFileOpen(&avs->file, filename_char, OF_READ|OF_SHARE_DENY_WRITE, NULL);
if (res != S_OK)
{
av_log(s, AV_LOG_ERROR, "AVIFileOpen failed with error %ld", res);
AVIFileExit();
return -1;
}
res = AVIFileInfo(avs->file, &info, sizeof(info));
if (res != S_OK)
{
av_log(s, AV_LOG_ERROR, "AVIFileInfo failed with error %ld", res);
AVIFileExit();
return -1;
}
avs->streams = av_mallocz(info.dwStreams * sizeof(AVISynthStream));
for (id=0; id<info.dwStreams; id++)
{
stream = &avs->streams[id];
stream->read = 0;
if (AVIFileGetStream(avs->file, &stream->handle, 0, id) == S_OK)
{
if (AVIStreamInfo(stream->handle, &stream->info, sizeof(stream->info)) == S_OK)
{
if (stream->info.fccType == streamtypeAUDIO)
{
WAVEFORMATEX wvfmt;
LONG struct_size = sizeof(WAVEFORMATEX);
if (AVIStreamReadFormat(stream->handle, 0, &wvfmt, &struct_size) != S_OK)
continue;
st = avformat_new_stream(s, NULL);
st->id = id;
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->block_align = wvfmt.nBlockAlign;
st->codec->channels = wvfmt.nChannels;
st->codec->sample_rate = wvfmt.nSamplesPerSec;
st->codec->bit_rate = wvfmt.nAvgBytesPerSec * 8;
st->codec->bits_per_coded_sample = wvfmt.wBitsPerSample;
stream->chunck_samples = wvfmt.nSamplesPerSec * (uint64_t)info.dwScale / (uint64_t)info.dwRate;
stream->chunck_size = stream->chunck_samples * wvfmt.nChannels * wvfmt.wBitsPerSample / 8;
st->codec->codec_tag = wvfmt.wFormatTag;
st->codec->codec_id = ff_wav_codec_get_id(wvfmt.wFormatTag, st->codec->bits_per_coded_sample);
}
else if (stream->info.fccType == streamtypeVIDEO)
{
BITMAPINFO imgfmt;
LONG struct_size = sizeof(BITMAPINFO);
stream->chunck_size = stream->info.dwSampleSize;
stream->chunck_samples = 1;
if (AVIStreamReadFormat(stream->handle, 0, &imgfmt, &struct_size) != S_OK)
continue;
st = avformat_new_stream(s, NULL);
st->id = id;
st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
st->r_frame_rate.num = stream->info.dwRate;
st->r_frame_rate.den = stream->info.dwScale;
st->codec->width = imgfmt.bmiHeader.biWidth;
st->codec->height = imgfmt.bmiHeader.biHeight;
st->codec->bits_per_coded_sample = imgfmt.bmiHeader.biBitCount;
st->codec->bit_rate = (uint64_t)stream->info.dwSampleSize * (uint64_t)stream->info.dwRate * 8 / (uint64_t)stream->info.dwScale;
st->codec->codec_tag = imgfmt.bmiHeader.biCompression;
st->codec->codec_id = ff_codec_get_id(ff_codec_bmp_tags, imgfmt.bmiHeader.biCompression);
if (st->codec->codec_id == CODEC_ID_RAWVIDEO && imgfmt.bmiHeader.biCompression== BI_RGB) {
st->codec->extradata = av_malloc(9 + FF_INPUT_BUFFER_PADDING_SIZE);
if (st->codec->extradata) {
st->codec->extradata_size = 9;
memcpy(st->codec->extradata, "BottomUp", 9);
}
}
st->duration = stream->info.dwLength;
}
else
{
AVIStreamRelease(stream->handle);
continue;
}
avs->nb_streams++;
st->codec->stream_codec_tag = stream->info.fccHandler;
avpriv_set_pts_info(st, 64, info.dwScale, info.dwRate);
st->start_time = stream->info.dwStart;
}
}
}
return 0;
}
BOOL ExtractAVIFrames(CString szFileName)
{
AVIFileInit();
PAVIFILE avi;
int res = AVIFileOpen(&avi, szFileName, OF_READ, NULL);
if (res != AVIERR_OK)
{
//an error occures
if (avi != NULL)
AVIFileRelease(avi);
return FALSE;
}
AVIFILEINFO avi_info;
AVIFileInfo(avi, &avi_info, sizeof(AVIFILEINFO));
CString szFileInfo;
szFileInfo.Format("Dimention: %dx%d\n"
"Length: %d frames\n"
"Max bytes per second: %d\n"
"Samples per second: %d\n"
"Streams: %d\n"
"File Type: %d", avi_info.dwWidth,
avi_info.dwHeight,
avi_info.dwLength,
avi_info.dwMaxBytesPerSec,
(DWORD)(avi_info.dwRate / avi_info.dwScale),
avi_info.dwStreams,
avi_info.szFileType);
AfxMessageBox(szFileInfo, MB_ICONINFORMATION | MB_OK);
PAVISTREAM pStream;
res = AVIFileGetStream(avi, &pStream, streamtypeVIDEO /*video stream*/,
0 /*first stream*/);
if (res != AVIERR_OK)
{
if (pStream != NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return FALSE;
}
//do some task with the stream
int iNumFrames;
int iFirstFrame;
iFirstFrame = AVIStreamStart(pStream);
if (iFirstFrame == -1)
{
//Error getteing the frame inside the stream
if (pStream != NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return FALSE;
}
iNumFrames = AVIStreamLength(pStream);
if (iNumFrames == -1)
{
//Error getteing the number of frames inside the stream
if (pStream != NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return FALSE;
}
//getting bitmap from frame
BITMAPINFOHEADER bih;
ZeroMemory(&bih, sizeof(BITMAPINFOHEADER));
bih.biBitCount = 24; //24 bit per pixel
bih.biClrImportant = 0;
bih.biClrUsed = 0;
bih.biCompression = BI_RGB;
bih.biPlanes = 1;
bih.biSize = 40;
bih.biXPelsPerMeter = 0;
bih.biYPelsPerMeter = 0;
//calculate total size of RGBQUAD scanlines (DWORD aligned)
bih.biSizeImage = (((bih.biWidth * 3) + 3) & 0xFFFC) * bih.biHeight;
PGETFRAME pFrame;
pFrame = AVIStreamGetFrameOpen(pStream,
NULL/*(BITMAPINFOHEADER*) AVIGETFRAMEF_BESTDISPLAYFMT*/ /*&bih*/);
//Get the first frame
int index = 0;
for (int i = iFirstFrame; i<iNumFrames; i++)
{
index = i - iFirstFrame;
BYTE* pDIB = (BYTE*)AVIStreamGetFrame(pFrame, index);
CreateFromPackedDIBPointer(pDIB, index);
}
AVIStreamGetFrameClose(pFrame);
//close the stream after finishing the task
if (pStream != NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return TRUE;
}
void CRotateAVIDlg::ProcessAVI(const TCHAR *source_filename, const TCHAR *dest_filename, eRotation rot)
{
TCHAR error_buf[1024];
PAVIFILE source_avi = 0;
PAVIFILE dest_avi = 0;
PAVISTREAM pSrcVidStream = 0;
PAVISTREAM pSrcAudioStream = 0;
PAVISTREAM pDestVidStream = 0;
PAVISTREAM pDestAudioStream = 0;
char *pSrcBuffer = 0;
char *pJPGBuffer = 0;
char *pDecompBuffer = 0;
char *pRotateBuffer = 0;
char *pDestBuffer = 0;
AVIFileInit();
// source setup
if (AVIFileOpen(&source_avi, source_filename, OF_READ, NULL) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Couldn't open file %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
AVIFILEINFO src_avi_info;
AVIFileInfo(source_avi, &src_avi_info, sizeof(AVIFILEINFO));
if (AVIFileGetStream(source_avi, &pSrcVidStream, streamtypeVIDEO, 0) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("No video stream in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
BITMAPINFOHEADER srcBIH;
long srcvidstreamsize;
AVIStreamFormatSize(pSrcVidStream, 0, &srcvidstreamsize);
if (srcvidstreamsize > sizeof(BITMAPINFOHEADER))
{
_stprintf(error_buf, TEXT("Unable to handle video stream format in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
srcvidstreamsize = sizeof(BITMAPINFOHEADER);
if (AVIStreamReadFormat(pSrcVidStream, 0, &srcBIH, &srcvidstreamsize) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error reading stream format in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
if (srcBIH.biCompression != MKFOURCC('M','J','P','G'))
{
_stprintf(error_buf, TEXT("%s is not motion JPEG format"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
AVISTREAMINFO vidstream_info;
if (AVIStreamInfo(pSrcVidStream, &vidstream_info, sizeof(AVISTREAMINFO)) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error reading stream info in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
int firstVidSrcFrame = AVIStreamStart(pSrcVidStream);
if (firstVidSrcFrame == -1)
{
_stprintf(error_buf, TEXT("Video stream start error in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
int numVidSrcFrames = AVIStreamLength(pSrcVidStream);
if (numVidSrcFrames == -1)
{
_stprintf(error_buf, TEXT("Video stream length error in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
AVIFileGetStream(source_avi, &pSrcAudioStream, streamtypeAUDIO, 0);
int firstAudioSrcFrame = 0;
int numAudioSrcFrames = 0;
if (pSrcAudioStream)
{
firstAudioSrcFrame = AVIStreamStart(pSrcAudioStream);
if (firstAudioSrcFrame == -1)
{
_stprintf(error_buf, TEXT("Audio stream start error in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
numAudioSrcFrames = AVIStreamLength(pSrcAudioStream);
if (numAudioSrcFrames == -1)
{
_stprintf(error_buf, TEXT("Audio stream length error in %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
}
// dest setup
BITMAPINFOHEADER destBIH;
destBIH = srcBIH;
if (rot != CW_180)
{
destBIH.biWidth = srcBIH.biHeight;
destBIH.biHeight = srcBIH.biWidth;
}
if (AVIFileOpen(&dest_avi, dest_filename, OF_CREATE | OF_WRITE, NULL) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Couldn't open file %s"), dest_filename);
MessageBox(error_buf);
goto cleanup;
}
vidstream_info.rcFrame.left = vidstream_info.rcFrame.top = 0;
vidstream_info.rcFrame.right = destBIH.biWidth;
vidstream_info.rcFrame.bottom = destBIH.biHeight;
if (AVIFileCreateStream(dest_avi, &pDestVidStream, &vidstream_info) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error creating video stream in %s"), dest_filename);
MessageBox(error_buf);
goto cleanup;
}
if (AVIStreamSetFormat(pDestVidStream, 0, &destBIH, sizeof(BITMAPINFOHEADER)) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error setting video stream format in %s"), dest_filename);
MessageBox(error_buf);
goto cleanup;
}
if (AVIStreamSetFormat(pDestVidStream, 0, &destBIH, sizeof(BITMAPINFOHEADER)) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error setting video stream format in %s"), dest_filename);
MessageBox(error_buf);
goto cleanup;
}
// video memory
int img_rgb_size = srcBIH.biHeight * srcBIH.biWidth * 3;
pSrcBuffer = new char[img_rgb_size];
pJPGBuffer = new char[img_rgb_size];
pDecompBuffer = new char[img_rgb_size];
pRotateBuffer = new char[img_rgb_size];
pDestBuffer = new char[img_rgb_size];
long bytes_read;
long bytes_written;
for (int i = firstVidSrcFrame; i < numVidSrcFrames; ++i)
{
if (AVIStreamRead(pSrcVidStream, i, 1, pSrcBuffer, img_rgb_size, &bytes_read, 0) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error reading video stream from %s"), source_filename);
MessageBox(error_buf);
goto cleanup;
}
// well-form the jpg
int jpglen = ConstructWellFormedJPEG(pSrcBuffer, pJPGBuffer, bytes_read);
// decompress
JPEGHandler jpgh_decomp(pJPGBuffer, jpglen);
jpgh_decomp.DecompressToRGB(pDecompBuffer, img_rgb_size);
// rotate
int destx, desty;
char *pRotSrc;
char *pRotDest;
switch (rot)
{
case CW_90:
for (int srcy = 0; srcy < srcBIH.biHeight; ++srcy)
{
for (int srcx = 0; srcx < srcBIH.biWidth; ++srcx)
{
destx = srcBIH.biHeight-1-srcy;
desty = srcx;
pRotSrc = &pDecompBuffer[(srcy * srcBIH.biWidth + srcx) * 3];
pRotDest = &pRotateBuffer[(desty * srcBIH.biHeight + destx) * 3];
*pRotDest++ = *pRotSrc++;
*pRotDest++ = *pRotSrc++;
*pRotDest++ = *pRotSrc++;
}
}
break;
case CW_180:
for (int srcy = 0; srcy < srcBIH.biHeight; ++srcy)
{
for (int srcx = 0; srcx < srcBIH.biWidth; ++srcx)
{
destx = srcBIH.biWidth-1-srcx;
desty = srcBIH.biHeight-1-srcy;
pRotSrc = &pDecompBuffer[(srcy * srcBIH.biWidth + srcx) * 3];
pRotDest = &pRotateBuffer[(desty * srcBIH.biWidth + destx) * 3];
*pRotDest++ = *pRotSrc++;
*pRotDest++ = *pRotSrc++;
*pRotDest++ = *pRotSrc++;
}
}
break;
case ACW_90:
for (int srcy = 0; srcy < srcBIH.biHeight; ++srcy)
{
for (int srcx = 0; srcx < srcBIH.biWidth; ++srcx)
{
destx = srcy;
desty = srcBIH.biWidth-1-srcx;
pRotSrc = &pDecompBuffer[(srcy * srcBIH.biWidth + srcx) * 3];
pRotDest = &pRotateBuffer[(desty * srcBIH.biHeight + destx) * 3];
*pRotDest++ = *pRotSrc++;
*pRotDest++ = *pRotSrc++;
*pRotDest++ = *pRotSrc++;
}
}
break;
}
// compress
JPEGHandler jpgh_comp(pRotateBuffer, img_rgb_size);
if (rot != CW_180)
destBIH.biSizeImage = jpgh_comp.CompressFromRGB(pDestBuffer, img_rgb_size, srcBIH.biHeight, srcBIH.biWidth);
else
destBIH.biSizeImage = jpgh_comp.CompressFromRGB(pDestBuffer, img_rgb_size, srcBIH.biWidth, srcBIH.biHeight);
if (AVIStreamWrite(pDestVidStream, i, 1, pDestBuffer, destBIH.biSizeImage, AVIIF_KEYFRAME, NULL, &bytes_written) != AVIERR_OK)
{
_stprintf(error_buf, TEXT("Error writing video stream to %s"), dest_filename);
MessageBox(error_buf);
goto cleanup;
}
}
cleanup:
delete[] pSrcBuffer;
delete[] pDestBuffer;
delete[] pJPGBuffer;
delete[] pDecompBuffer;
delete[] pRotateBuffer;
if (pDestAudioStream) AVIStreamRelease(pDestAudioStream);
if (pDestVidStream) AVIStreamRelease(pDestVidStream);
if (pSrcAudioStream) AVIStreamRelease(pSrcAudioStream);
if (pSrcVidStream) AVIStreamRelease(pSrcVidStream);
if (dest_avi) AVIFileRelease(dest_avi);
if (source_avi) AVIFileRelease(source_avi);
AVIFileExit();
}
void CAviHelper::AVItoBmp(const wstring& strAVIFileName, const wstring& strBmpDir)
{
AVIFileInit();
PAVIFILE avi;
int res = AVIFileOpen(&avi, WS2S(strAVIFileName).c_str(), OF_READ, NULL);
int n = GetLastError();
if (res!=AVIERR_OK)
{
//an error occures
if (avi!=NULL)
AVIFileRelease(avi);
return ;
}
AVIFILEINFO avi_info;
AVIFileInfo(avi, &avi_info, sizeof(AVIFILEINFO));
PAVISTREAM pStream;
res=AVIFileGetStream(avi, &pStream, streamtypeVIDEO /*video stream*/, 0 /*first stream*/);
if (res!=AVIERR_OK)
{
if (pStream!=NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return ;
}
//do some task with the stream
int iNumFrames;
int iFirstFrame;
iFirstFrame = AVIStreamStart(pStream);
if (iFirstFrame==-1)
{
//Error getteing the frame inside the stream
if (pStream!=NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return ;
}
iNumFrames = AVIStreamLength(pStream);
if (iNumFrames==-1)
{
//Error getteing the number of frames inside the stream
if (pStream!=NULL)
AVIStreamRelease(pStream);
AVIFileExit();
return ;
}
//getting bitmap from frame
BITMAPINFOHEADER bih;
ZeroMemory(&bih, sizeof(BITMAPINFOHEADER));
bih.biBitCount=24; //24 bit per pixel
bih.biClrImportant=0;
bih.biClrUsed = 0;
bih.biCompression = BI_RGB;
bih.biPlanes = 1;
bih.biSize = 40;
bih.biXPelsPerMeter = 0;
bih.biYPelsPerMeter = 0;
//calculate total size of RGBQUAD scanlines (DWORD aligned)
bih.biSizeImage = (((bih.biWidth * 3) + 3) & 0xFFFC) * bih.biHeight ;
PGETFRAME pFrame;
pFrame=AVIStreamGetFrameOpen(pStream, NULL );
AVISTREAMINFO streaminfo;
AVIStreamInfo(pStream,&streaminfo,sizeof(AVISTREAMINFO));
//Get the first frame
BITMAPINFOHEADER bih2;
long lsize = sizeof(bih2);
int index= 0;
for (int i = iFirstFrame; i < iNumFrames; i++)
{
index= i-iFirstFrame;
BYTE* pDIB = (BYTE*) AVIStreamGetFrame(pFrame, index); //
AVIStreamReadFormat(pStream,index,&bih2,&lsize);
BITMAPFILEHEADER stFileHdr;
BYTE* Bits=new BYTE[bih2.biSizeImage];
AVIStreamRead(pStream,index,1,Bits,bih2.biSizeImage,NULL,NULL);
//RtlMoveMemory(Bits, pDIB + sizeof(BITMAPINFOHEADER), bih2.biSizeImage);
bih2.biClrUsed =0;
stFileHdr.bfOffBits=sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);
stFileHdr.bfSize=sizeof(BITMAPFILEHEADER);
stFileHdr.bfType=0x4d42;
CString FileName;
FileName.Format(_T("Frame-%05d.bmp"), index);
CString strtemp;
strtemp.Format(_T("%s\\%s"), strBmpDir.c_str(), FileName);
FILE* fp=_tfopen(strtemp ,_T("wb"));
fwrite(&stFileHdr,1,sizeof(BITMAPFILEHEADER),fp);
fwrite(&bih2,1,sizeof(BITMAPINFOHEADER),fp);
int ff = fwrite(Bits,1,bih2.biSizeImage,fp);
int e = GetLastError();
fclose(fp);
/////
delete Bits;
//CreateFromPackedDIBPointer(pDIB, index);
}
AVIStreamGetFrameClose(pFrame);
//close the stream after finishing the task
if (pStream!=NULL)
AVIStreamRelease(pStream);
AVIFileExit();
}
