static BOOL AVIFILE_FormatsEqual(PAVISTREAM avi1, PAVISTREAM avi2)
{
LPVOID fmt1 = NULL, fmt2 = NULL;
LONG size1, size2, start1, start2;
BOOL status = FALSE;
assert(avi1 != NULL && avi2 != NULL);
/* get stream starts and check format sizes */
start1 = AVIStreamStart(avi1);
start2 = AVIStreamStart(avi2);
if (FAILED(AVIStreamFormatSize(avi1, start1, &size1)))
return FALSE;
if (FAILED(AVIStreamFormatSize(avi2, start2, &size2)))
return FALSE;
if (size1 != size2)
return FALSE;
/* sizes match, now get formats and compare them */
fmt1 = HeapAlloc(GetProcessHeap(), 0, size1);
if (fmt1 == NULL)
return FALSE;
if (SUCCEEDED(AVIStreamReadFormat(avi1, start1, fmt1, &size1))) {
fmt2 = HeapAlloc(GetProcessHeap(), 0, size1);
if (fmt2 != NULL) {
if (SUCCEEDED(AVIStreamReadFormat(avi2, start2, fmt2, &size1)))
status = (memcmp(fmt1, fmt2, size1) == 0);
}
}
HeapFree(GetProcessHeap(), 0, fmt2);
HeapFree(GetProcessHeap(), 0, fmt1);
return status;
}
sint32 AVIReadTunnelStream::FormatSize(VDPosition lFrame, long *plSize) {
LONG lFrame32 = (LONG)lFrame;
if (lFrame32 != lFrame)
lFrame32 = lFrame < 0 ? (LONG)0x80000000 : (LONG)0x7FFFFFFF;
return AVIStreamFormatSize(pas, lFrame32, plSize);
}
static HRESULT AVIFILE_OpenCompressor(IAVIStreamImpl *This)
{
HRESULT hr;
/* pre-conditions */
assert(This != NULL);
assert(This->pStream != NULL);
if (This->has != NULL)
return AVIERR_OK;
if (This->lpInFormat == NULL) {
/* decode or encode the data from pStream */
hr = AVIStreamFormatSize(This->pStream, This->sInfo.dwStart, &This->cbInFormat);
if (FAILED(hr))
return hr;
This->lpInFormat = HeapAlloc(GetProcessHeap(), 0, This->cbInFormat);
if (This->lpInFormat == NULL)
return AVIERR_MEMORY;
hr = IAVIStream_ReadFormat(This->pStream, This->sInfo.dwStart,
This->lpInFormat, &This->cbInFormat);
if (FAILED(hr))
return hr;
if (This->lpOutFormat == NULL) {
/* we must decode to default format */
This->cbOutFormat = sizeof(PCMWAVEFORMAT);
This->lpOutFormat = HeapAlloc(GetProcessHeap(), 0, This->cbOutFormat);
if (This->lpOutFormat == NULL)
return AVIERR_MEMORY;
This->lpOutFormat->wFormatTag = WAVE_FORMAT_PCM;
if (acmFormatSuggest(NULL, This->lpInFormat, This->lpOutFormat,
This->cbOutFormat, ACM_FORMATSUGGESTF_WFORMATTAG) != S_OK)
return AVIERR_NOCOMPRESSOR;
}
} else if (This->lpOutFormat == NULL)
return AVIERR_ERROR; /* To what should I encode? */
if (acmStreamOpen(&This->has, NULL, This->lpInFormat, This->lpOutFormat,
NULL, 0, 0, ACM_STREAMOPENF_NONREALTIME) != S_OK)
return AVIERR_NOCOMPRESSOR;
/* update AVISTREAMINFO structure */
This->sInfo.dwSampleSize = This->lpOutFormat->nBlockAlign;
This->sInfo.dwScale = This->lpOutFormat->nBlockAlign;
This->sInfo.dwRate = This->lpOutFormat->nAvgBytesPerSec;
This->sInfo.dwQuality = (DWORD)ICQUALITY_DEFAULT;
SetRectEmpty(&This->sInfo.rcFrame);
/* convert positions and sizes to output format */
CONVERT_STREAM_to_THIS(&This->sInfo.dwStart);
CONVERT_STREAM_to_THIS(&This->sInfo.dwLength);
CONVERT_STREAM_to_THIS(&This->sInfo.dwSuggestedBufferSize);
return AVIERR_OK;
}
void VideoReader::Open(CString strFilePath)
{
AVIFileInit();
LONG hr;
hr = AVIStreamOpenFromFile(&m_pAviStream, strFilePath, streamtypeVIDEO, 0, OF_READ, NULL);
if (hr != 0){
// Handle failure.
AfxMessageBox(L"Failed to open file, file must be an uncompressed video.");
}
else
{
HRESULT hr;
AVISTREAMINFO strhdr;
LONG lStreamSize;
// Determine the size of the format data using
// AVIStreamFormatSize.
AVIStreamFormatSize(m_pAviStream, 0, &lStreamSize);
if (lStreamSize > sizeof(m_bi)) // Format too large?
return;
lStreamSize = sizeof(m_bi);
hr = AVIStreamReadFormat(m_pAviStream, 0, &m_bi, &lStreamSize); // Read format
if (m_bi.biCompression != BI_RGB) // Wrong compression format?
return;
hr = AVIStreamInfo(m_pAviStream, &strhdr, sizeof(strhdr));
// Create new AVI file using AVIFileOpen.
hr = AVIFileOpen(&m_pf, strFilePath + L".Processed.avi", OF_WRITE | OF_CREATE, NULL);
if (hr != 0)
return;
m_currentSize = AVIStreamStart(m_pAviStream);
// Allocate memory for the bitmaps.
m_lpBuffer = (BYTE *)malloc(m_bi.biSizeImage);
}
}
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;
}
BOOL CALLBACK aviaudioOpenDevice(HWND hwnd, PAVISTREAM pavi)
{
MMRESULT mmResult;
LPVOID lpFormat;
LONG cbFormat;
AVISTREAMINFO strhdr;
if (!pavi) // no wave data to play
return FALSE;
if (shWaveOut) // already something playing
return TRUE;
spavi = pavi;
recalc = 1;
AVIStreamInfo(pavi, &strhdr, sizeof(strhdr));
slSampleSize = (LONG) strhdr.dwSampleSize;
if (slSampleSize <= 0 || slSampleSize > AUDIO_BUFFER_SIZE)
return FALSE;
//AVIStreamFormatSize(pavi, 0, &cbFormat);
AVIStreamFormatSize(pavi, AVIStreamStart(pavi), &cbFormat);
lpFormat = GlobalAllocPtr(GHND, cbFormat);
if (!lpFormat)
return FALSE;
//AVIStreamReadFormat(pavi, 0, lpFormat, &cbFormat);
AVIStreamReadFormat(pavi, AVIStreamStart(pavi), lpFormat, &cbFormat);
sdwSamplesPerSec = ((LPWAVEFORMAT) lpFormat)->nSamplesPerSec;
sdwBytesPerSec = ((LPWAVEFORMAT) lpFormat)->nAvgBytesPerSec;
mmResult = waveOutOpen(&shWaveOut, (UINT)WAVE_MAPPER, (WAVEFORMATEX *) lpFormat,
(DWORD) (UINT) hwnd, 0L, CALLBACK_WINDOW);
// Maybe we failed because someone is playing sound already.
// Shut any sound off, and try once more before giving up.
if (mmResult) {
sndPlaySound(NULL, 0);
mmResult = waveOutOpen(&shWaveOut, (UINT)WAVE_MAPPER, (WAVEFORMATEX *) lpFormat,
(DWORD) (UINT)hwnd, 0L, CALLBACK_WINDOW);
}
if (mmResult != 0) {
return FALSE;
}
for (swBuffers = 0; swBuffers < MAX_AUDIO_BUFFERS; swBuffers++) {
if (!(salpAudioBuf[swBuffers] = (LPWAVEHDR)GlobalAllocPtr(GMEM_MOVEABLE | GMEM_SHARE, (DWORD)(sizeof(WAVEHDR) + AUDIO_BUFFER_SIZE))))
break;
salpAudioBuf[swBuffers]->dwFlags = WHDR_DONE;
salpAudioBuf[swBuffers]->lpData = (LPSTR) salpAudioBuf[swBuffers] + sizeof(WAVEHDR);
salpAudioBuf[swBuffers]->dwBufferLength = AUDIO_BUFFER_SIZE;
if (!waveOutPrepareHeader(shWaveOut, salpAudioBuf[swBuffers], sizeof(WAVEHDR)))
continue;
GlobalFreePtr((LPSTR) salpAudioBuf[swBuffers]);
break;
}
if (swBuffers < MIN_AUDIO_BUFFERS) {
aviaudioCloseDevice();
return FALSE;
}
swBuffersOut = 0;
swNextBuffer = 0;
sfPlaying = FALSE;
return TRUE;
}
void VideoHelper::OpenVideo(CString strFilePath, FrameData& data)
{
AVIFileInit();
LONG hr;
hr = AVIStreamOpenFromFile(&m_pAviStream, strFilePath, streamtypeVIDEO, 0, OF_READ, NULL);
if (hr != 0){
// Handle failure.
AfxMessageBox(L"Failed to open file.");
}
else
{
PAVIFILE pf;
PAVISTREAM psSmall;
HRESULT hr;
AVISTREAMINFO strhdr;
BITMAPINFOHEADER bi;
BITMAPINFOHEADER biNew;
LONG lStreamSize;
LPVOID lpOld;
LPVOID lpNew;
// Determine the size of the format data using
// AVIStreamFormatSize.
AVIStreamFormatSize(m_pAviStream, 0, &lStreamSize);
if (lStreamSize > sizeof(bi)) // Format too large?
return;
lStreamSize = sizeof(bi);
hr = AVIStreamReadFormat(m_pAviStream, 0, &bi, &lStreamSize); // Read format
if (bi.biCompression != BI_RGB) // Wrong compression format?
return;
hr = AVIStreamInfo(m_pAviStream, &strhdr, sizeof(strhdr));
// Create new AVI file using AVIFileOpen.
hr = AVIFileOpen(&pf, strFilePath + L".Processed.avi", OF_WRITE | OF_CREATE, NULL);
if (hr != 0)
return;
// Set parameters for the new stream.
biNew = bi;
SetRect(&strhdr.rcFrame, 0, 0, (int) biNew.biWidth,
(int) biNew.biHeight);
// Create a stream using AVIFileCreateStream.
hr = AVIFileCreateStream(pf, &psSmall, &strhdr);
if (hr != 0) { //Stream created OK? If not, close file.
AVIFileRelease(pf);
return;
}
// Set format of new stream using AVIStreamSetFormat.
hr = AVIStreamSetFormat(psSmall, 0, &biNew, sizeof(biNew));
if (hr != 0) {
AVIStreamRelease(psSmall);
AVIFileRelease(pf);
return;
}
// Allocate memory for the bitmaps.
lpOld = malloc(bi.biSizeImage);
// Read the stream data using AVIStreamRead.
for (lStreamSize = AVIStreamStart(m_pAviStream); lStreamSize <
AVIStreamEnd(m_pAviStream)/*1500*/; lStreamSize++) {
//Context::Oversubscribe(true);
hr = AVIStreamRead(m_pAviStream, lStreamSize, 1, lpOld, bi.biSizeImage,
NULL, NULL);
//Context::Oversubscribe(false);
//memcpy_s(lpNew, bi.biSizeImage, lpOld, bi.biSizeImage);
data.m_BBP = bi.biBitCount;
data.m_ColorPlanes = bi.biPlanes;
data.m_EndHeight = bi.biHeight;
data.m_EndWidth = bi.biWidth;
data.m_pFrame = (BYTE*)lpOld;
data.m_Pitch = bi.biWidth * (bi.biBitCount / 8);
data.m_Size = bi.biSizeImage;
data.m_StartHeight = 0;
data.m_StartWidth = 0;
lpNew = m_pVideoAgent->ProcessFrame(data);
if(NULL != lpNew)
{
// Save the compressed data using AVIStreamWrite.
hr = AVIStreamWrite(psSmall, lStreamSize, 1, lpNew,
biNew.biSizeImage, AVIIF_KEYFRAME, NULL, NULL);
}
}
free(lpOld);
// Close the stream and file.
AVIStreamRelease(psSmall);
AVIFileRelease(pf);
}
AVIFileExit();
}
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();
}
// AVI_stream_open() will open the AVI file and prepare it for reading, but will not
// store any of the frame data.
//
// returns: 0 ==> success
// !0 ==> could not open the AVI stream
//
// The filename is expected to be an absolute pathname (or file in the current working directory)
//
int AVI_stream_open(char* filename)
{
if ( !AVI_stream_inited )
AVI_stream_init();
int hr;
PAVIFILE pfile;
PAVISTREAM pstream;
AVISTREAMINFO avi_stream_info;
Assert( !(AVI_stream.flags & AVI_STREAM_F_USED) );
// Open the AVI file
hr = AVIFileOpen(&pfile, filename, OF_SHARE_DENY_WRITE, 0);
if (hr != 0){
// nprintf(("Warning", "AVI ==> Unable to open %s", filename));
return -1;
}
strcpy(AVI_stream.filename, filename);
// Get a handle to the video stream within the AVI file
hr = AVIFileGetStream(pfile, &pstream, streamtypeVIDEO, 0);
if (hr != 0){
//nprintf(("Warning", "AVI ==> Unable to open video stream in %s", filename));
return -1;
}
// Store the pointer to stream, since we'll need it later to read from disk
AVI_stream.pstream = pstream;
AVI_stream.pfile = pfile;
// Get information on the stream
hr = AVIStreamInfo( pstream, &avi_stream_info, sizeof(AVISTREAMINFO) );
if (hr != 0){
//nprintf(("Warning", "AVI ==> Unable to retreive stream info in %s", filename));
return -1;
}
int buffer_size;
int start_sample = AVIStreamStart(pstream);
Assert( start_sample == 0 );
int end_sample = AVIStreamEnd(pstream);
Assert( end_sample >= start_sample );
// store the number of frames in the AVI_info[] structure
AVI_stream.num_frames = end_sample; // start sample must be 0
Assert(AVI_stream.num_frames == AVIStreamLength(pstream) );
// Get information on the stream
hr = AVIStreamInfo( pstream, &avi_stream_info, sizeof(AVISTREAMINFO) );
if (hr != 0){
//nprintf(("Warning", "AVI ==> Unable to retreive stream info in %s", filename));
return -1;
}
buffer_size = avi_stream_info.dwSuggestedBufferSize;
Assert( buffer_size > 0 );
AVI_stream.min_compressed_buffer_size = buffer_size;
// determine the format of the AVI image data
ubyte* format_buffer;
long format_buffer_size;
BITMAPINFO* bitmap_info;
hr = AVIStreamFormatSize(pstream, 0, &format_buffer_size);
Assert( format_buffer_size > 0 );
format_buffer = (ubyte*) malloc(format_buffer_size);
Assert(format_buffer != NULL); // format_buffer is free'ed when AVI is free'ed, since memory is used by b_info member in AVI_info[] structure
hr = AVIStreamReadFormat(pstream, 0, format_buffer, &format_buffer_size);
bitmap_info = (BITMAPINFO*)format_buffer;
switch ( bitmap_info->bmiHeader.biCompression ) {
case BI_RLE8:
break;
default:
Assert(0);
break;
}
AVI_stream.w = bitmap_info->bmiHeader.biWidth;
AVI_stream.h = bitmap_info->bmiHeader.biHeight;
AVI_stream.bpp = bitmap_info->bmiHeader.biBitCount;
// create the palette translation look-up table
//
// Transparency: If the palette color is full green, then treat as transparent
//
RGBQUAD* pal;
pal = (RGBQUAD*)(bitmap_info->bmiColors);
// Store the palette in the AVI stream structure
for ( int i = 0; i < 256; i++ ) {
AVI_stream.palette[i*3] = pal[i].rgbRed;
AVI_stream.palette[i*3+1] = pal[i].rgbGreen;
AVI_stream.palette[i*3+2] = pal[i].rgbBlue;
}
// memcpy(AVI_stream.palette, pal, 256*3);
/*
int transparent_found = 0;
for ( i = 0; i < 256; i++ ) {
//nprintf(("AVI", "AVI ==> R: %d G: %d B: %d\n", pal[i].rgbRed, pal[i].rgbGreen, pal[i].rgbBlue));
if ( pal[i].rgbRed < 5 && pal[i].rgbGreen > 250 && pal[i].rgbBlue < 5 ) {
avi_stream->pal_translation[i] = TRANSPARENT_INDEX;
break; // found transparent, continue in j for loop, since don't need check any more
}
else
avi_stream->pal_translation[i] = palette_find( pal[i].rgbRed, pal[i].rgbGreen, pal[i].rgbBlue );
}
for ( j = i+1; j < 256; j++ ) {
avi_stream->pal_translation[j] = palette_find( pal[j].rgbRed, pal[j].rgbGreen, pal[j].rgbBlue );
}
*/
free(format_buffer);
// set the flag to used, so to make sure we only process one AVI stream at a time
AVI_stream.flags |= AVI_STREAM_F_USED;
return 0;
}
