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; }