able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/media/avi/compman/icm.c

2164 lines
69 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
///////////////////////////////////////////////////////////////////////////////
//
// ICM.C
//
// Helper routines for compressing/decompressing/and choosing compressors.
//
// (C) Copyright Microsoft Corp. 1991-1995. All rights reserved.
//
// You have a royalty-free right to use, modify, reproduce and
// distribute the Sample Files (and/or any modified version) in
// any way you find useful, provided that you agree that
// Microsoft has no warranty obligations or liability for any
// Sample Application Files.
//
// If you did not get this from Microsoft Sources, then it may not be the
// most current version. This sample code in particular will be updated
// and include more documentation.
//
// Sources are:
// CompuServe: WINSDK forum, MDK section.
// Anonymous FTP from ftp.uu.net vendor\microsoft\multimedia
//
///////////////////////////////////////////////////////////////////////////////
#pragma warning(disable:4103)
//
// define these before compman.h, so our functions get declared right.
//
#ifndef _WIN32
#define VFWAPI FAR PASCAL _loadds
#define VFWAPIV FAR CDECL _loadds
#endif
#include <win32.h>
#include <mmsystem.h>
#include <vfw.h>
#include <profile.h>
#ifdef DEBUG
static BOOL fDebug = -1;
static void CDECL dprintf(LPSTR, ...);
#define DPF(x) dprintf x
#else
#define DPF(x)
#endif
// macro to get the number of chars (byte or word) in a buffer
//
#if !defined NUMELMS
#define NUMELMS(aa) (sizeof(aa)/sizeof((aa)[0]))
#endif
#define NOMMREG
#define NOMSACM
#define NOAVICAP
#include "icm.rc"
#define AVIStreamGetFrameOpen XAVIStreamGetFrameOpen
#define AVIStreamGetFrame XAVIStreamGetFrame
#define AVIStreamGetFrameClose XAVIStreamGetFrameClose
HMODULE havifile;
PGETFRAME (STDAPICALLTYPE *XAVIStreamGetFrameOpen)(PAVISTREAM pavi,
LPBITMAPINFOHEADER lpbiWanted);
LPVOID (STDAPICALLTYPE *XAVIStreamGetFrame)(PGETFRAME pgf, LONG pos);
HRESULT (STDAPICALLTYPE *XAVIStreamGetFrameClose)(PGETFRAME pgf);
#ifdef _WIN32
extern HANDLE ghInst;
#else
extern HINSTANCE ghInst;
#endif
///////////////////////////////////////////////////////////////////////////////
// DIB Macros
///////////////////////////////////////////////////////////////////////////////
#define WIDTHBYTES(i) ((unsigned)((i+31)&(~31))/8) /* ULONG aligned ! */
#define DibWidthBytes(lpbi) (UINT)WIDTHBYTES((UINT)(lpbi)->biWidth * (UINT)((lpbi)->biBitCount))
#define DibSizeImage(lpbi) ((DWORD)(UINT)DibWidthBytes(lpbi) * (DWORD)(UINT)((lpbi)->biHeight))
#define DibSize(lpbi) ((lpbi)->biSize + (lpbi)->biSizeImage + (int)(lpbi)->biClrUsed * sizeof(RGBQUAD))
#define DibPtr(lpbi) (LPVOID)(DibColors(lpbi) + (UINT)(lpbi)->biClrUsed)
#define DibColors(lpbi) ((LPRGBQUAD)((LPBYTE)(lpbi) + (int)(lpbi)->biSize))
#define DibNumColors(lpbi) ((lpbi)->biClrUsed == 0 && (lpbi)->biBitCount <= 8 \
? (int)(1 << (int)(lpbi)->biBitCount) \
: (int)(lpbi)->biClrUsed)
// !!! Someday write this so you don't have to call ICCompressorChoose if you
// !!! know what you want. Choose would then call this.
// InitCompress(pc, hic/fccHandler, lQuality, lKey, lpbiIn, lpbiOut)
/*****************************************************************************
* @doc EXTERNAL COMPVARS ICAPPS
*
* @types COMPVARS | This structure describes
* compressor when using functions such as <f ICCompressorChoose>,
* <f ICSeqCompressFrame>, or <f ICCompressorFree>.
*
* @field LONG | cbSize | Set this to the size of this structure in bytes.
* This member must be set to validate the structure
* before calling any function using this structure.
*
* @field DWORD | dwFlags | Specifies the flags for this structure:
*
* @flag ICMF_COMPVARS_VALID | Indicates this structure has valid data.
* Set this flag if you fill out this structure manually before
* calling any functions. Do not set this flag if you let
* <f ICCompressorChoose> initialize this structure.
*
* @field HIC | hic | Specifies the handle of the compressor to use.
* The <f ICCompressorChoose> function opens the chosen compressor and
* returns the handle to the compressor in this
* member. The compressor is closed by <t ICCompressorFree>.
*
* @field DWORD | fccType | Specifies the type of compressor being used.
* Currently only ICTYPE_VIDEO is supported. This can be set to zero.
*
* @field DWORD | fccHandler | Specifies the four-character code
* of the compressor. NULL indicates the data is not
* to be recompressed and and 'DIB ' indicates the data is full framed
* (uncompressed). You can use this member to specify which
* compressor is selected by default when the dialog box is
* displayed.
*
* @field LPBITMAPINFO | lpbiIn | Specifies the input format. Used internally.
*
* @field LPBITMAPINFO | lpbiOut | Specifies the output format. Ths member
* is set by <f ICCompressorChoose>. The <f ICSeqCompressFrameStart>
* function uses this member to determine the compressed output format.
* If you do not want to use the default format, specify
* the preferred one.
*
* @field LPVOID | lpBitsOut | Used internally for compression.
*
* @field LPVOID | lpBitsPrev | Used internally for temporal compression.
*
* @field LONG | lFrame | Used internally to count the number of frames
* compressed in a sequence.
*
* @field LONG | lKey | Set by <f ICCompressorChoose> to indicate the key frame
* rate selected in the dialog box. The also specifies the rate that
* <f ICSeqCompressFrameStart> uses for making key frames.
*
* @field LONG | lDataRate | Set by <f ICCompressorChoose> to indicate the
* data rate selected in the dialog box. The units are kilobytes per second.
*
* @field LONG | lQ | Set by <f ICCompressChoose> to indicate the quality
* selected in the dialog box. This also specifies the quality
* <f ICSeqCompressFrameStart> will use. ICQUALITY_DEFAULT specifies
* default quality.
*
* @field LONG | lKeyCount | Used internally to count key frames.
*
* @field LPVOID | lpState | Set by <f ICCompressorChoose> to the state selected
* in the configuration dialog box for the compressor. The system
* uses this information to restore the state of the dialog box if
* it is redisplayed. Used internally.
*
* @field LONG | cbState | Used internally for the size of the state information.
*
***************************************************************************/
/*******************************************************************
* @doc EXTERNAL ICCompressorFree ICAPPS
*
* @api void | ICCompressorFree | This function frees the resources
* in the <t COMPVARS> structure used by other IC functions.
*
* @parm PCOMPVARS | pc | Specifies a pointer to the <t COMPVARS>
* structure containing the resources to be freed.
*
* @comm After using the <f ICCompressorChoose>, <f ICSeqCompressFrameStart>,
* <f ICSeqCompressFrame>, and <f ICSeqCompressFrameEnd> functions, call
* this function to release the resources in the <t COMPVARS> structure.
*
* @xref <f ICCompressChoose> <f ICSeqCompressFrameStart> <f ICSeqCompressFrame>
* <f ICSeqCompressFrameEnd>
*
*******************************************************************/
///////////////////////////////////////////////////////////////////////////////
//
// ICCompressorFree
//
///////////////////////////////////////////////////////////////////////////////
void VFWAPI ICCompressorFree(PCOMPVARS pc)
{
/* We were passed an invalid COMPPARMS */
if (pc == NULL || pc->cbSize != sizeof(COMPVARS))
return;
// This function frees every thing in the structure (excuse my
// french).
/* Close the compressor */
if (pc->hic) {
ICClose(pc->hic);
pc->hic = NULL;
}
/* Free the output format */
if (pc->lpbiOut) {
GlobalFreePtr(pc->lpbiOut);
pc->lpbiOut = NULL;
}
/* Free the buffer for compressed image */
if (pc->lpBitsOut) {
GlobalFreePtr(pc->lpBitsOut);
pc->lpBitsOut = NULL;
}
/* Free the buffer for the decompressed previous frame */
if (pc->lpBitsPrev) {
GlobalFreePtr(pc->lpBitsPrev);
pc->lpBitsPrev = NULL;
}
/* Free the compressor state buffer */
if (pc->lpState) {
GlobalFreePtr(pc->lpState);
pc->lpState = NULL;
}
/* This structure is no longer VALID */
pc->dwFlags = 0;
}
/*******************************************************************
* @doc EXTERNAL ICSeqCompressFrameStart ICAPPS
*
* @api BOOL | ICSeqCompressFrameStart | This function initializes the system
* prior to using <f ICSeqCompressFrame>.
*
* @parm PCOMPVARS | pc | Specifies a pointer to a <t COMPVARS> structure
* initialized with information for compression.
*
* @parm LPBITMAPINFO | lpbiIn | Specifies the format of the data to be
* compressed.
*
* @rdesc Returns TRUE if successful; otherwise it returns FALSE.
*
* @comm Prior to using this function, use <f ICCompressorChoose> to let the
* user specify a compressor, or initialize a <t COMPVARS> structure
* manually. Use <f ICSeqCompressFrameStart>, <f ICSeqCompressFrame>
* and <f ICSeqCompressFrameEnd> to compress a sequence of
* frames to a specified data rate and number of key frames.
* When finished comressing data, use
* <f ICCompressorFree> to release the resources
* specified in the <t COMPVARS> structure.
*
* If you do not use <f ICCompressorChoose> you must
* initialize the following members of the <t COMPVARS> structure:
*
* <e COMPVARS.cbSize> Set to the sizeof(COMPVARS) to validate the structure.
*
* <e COMPVARS.hic> Set to the handle of a compressor you have opened with
* <f ICOpen>. You do not need to close it (<f ICCompressorFree>
* will do this for you).
*
* <e COMPVARS.lpbiOut> Optionally set this to force the compressor
* to compress to a specific format instead of the default.
* This will be freed by <f ICCompressorFree>.
*
* <e COMPVARS.lKey> Set this to the key-frame frequency you want
* or zero for none.
*
* <e COMPVARS.lQ> Set this to the quality level to use or ICQUALITY_DEFAULT.
*
* <e COMPVARS.dwFlags> Set ICMF_COMPVARS_VALID flag to indicate the structure is initialized.
*
* @xref <f ICCompressorChoose> <f ICSeqCompressFrame> <f ICSeqCompressFrameEnd>
* <f ICCompressorFree>
*
*******************************************************************/
///////////////////////////////////////////////////////////////////////////////
//
// ICSeqCompressFrameStart
//
///////////////////////////////////////////////////////////////////////////////
BOOL VFWAPI ICSeqCompressFrameStart(PCOMPVARS pc, LPBITMAPINFO lpbiIn)
{
DWORD dwSize;
ICINFO icinfo;
if (pc == NULL || pc->cbSize != sizeof(COMPVARS))
return FALSE;
if (pc->hic == NULL || lpbiIn == NULL)
return FALSE;
//
// make sure the found compressor can handle something
// if not, force back to the default setting
//
if (ICCompressQuery(pc->hic, lpbiIn, pc->lpbiOut) != ICERR_OK) {
// If the input format has changed since the output was selected,
// force a reinitialization of the output format
if (pc->lpbiOut) {
GlobalFreePtr (pc->lpbiOut);
pc->lpbiOut = NULL;
}
}
//
// fill in defaults: key frame every frame, and default quality
//
if (pc->lKey < 0)
pc->lKey = 1;
if (pc->lQ == ICQUALITY_DEFAULT)
pc->lQ = ICGetDefaultQuality(pc->hic);
//
// If no output format is given, use a default
//
if (pc->lpbiOut == NULL) {
dwSize = ICCompressGetFormatSize(pc->hic, lpbiIn);
if (!dwSize || !(pc->lpbiOut = (LPBITMAPINFO)GlobalAllocPtr(GMEM_MOVEABLE,dwSize)))
goto StartError;
ICCompressGetFormat(pc->hic, lpbiIn, pc->lpbiOut);
}
pc->lpbiOut->bmiHeader.biSizeImage =
ICCompressGetSize (pc->hic, lpbiIn, pc->lpbiOut);
pc->lpbiOut->bmiHeader.biClrUsed = DibNumColors(&(pc->lpbiOut->bmiHeader));
//
// Set the input format and initialize the key frame count
//
pc->lpbiIn = lpbiIn;
pc->lKeyCount = pc->lKey;
pc->lFrame = 0; // first frame we'll be compressing is 0
if (ICCompressQuery(pc->hic, lpbiIn, pc->lpbiOut) != ICERR_OK)
goto StartError;
//
// Allocate a buffer for the compressed bits
//
dwSize = pc->lpbiOut->bmiHeader.biSizeImage;
// !!! Hack for VidCap... make it big enough for two RIFF structs and
// !!! pad records.
//
dwSize += 2048 + 16;
if (!(pc->lpBitsOut = GlobalAllocPtr(GMEM_MOVEABLE, dwSize)))
goto StartError;
//
// Allocate a buffer for the decompressed previous frame if it can do
// key frames and we want key frames and it needs such a buffer.
//
ICGetInfo(pc->hic, &icinfo, sizeof(icinfo));
if ((pc->lKey != 1) && (icinfo.dwFlags & VIDCF_TEMPORAL) &&
!(icinfo.dwFlags & VIDCF_FASTTEMPORALC)) {
dwSize = lpbiIn->bmiHeader.biSizeImage;
if (!(pc->lpBitsPrev = GlobalAllocPtr(GMEM_MOVEABLE, dwSize)))
goto StartError;
}
//
// now get compman ready for the big job
//
if (ICCompressBegin(pc->hic, lpbiIn, pc->lpbiOut) != ICERR_OK)
goto StartError;
//
// Get ready to decompress previous frames if we're doing key frames
// If we can't decompress, we must do all key frames
//
if (pc->lpBitsPrev) {
if (ICDecompressBegin(pc->hic, pc->lpbiOut, lpbiIn) != ICERR_OK) {
pc->lKey = pc->lKeyCount = 1;
GlobalFreePtr(pc->lpBitsPrev);
pc->lpBitsPrev = NULL;
}
}
return TRUE;
StartError:
// !!! Leave stuff allocated because ICCompressorFree() will clear things
return FALSE;
}
/*******************************************************************
* @doc EXTERNAL ICSeqCompressFrameEnd ICAPPS
*
* @api void | ICSeqCompressFrameEnd | This function terminates sequence
* compression using <f ICSeqCompressFrame>.
*
* @parm PCOMPVARS | pc | Specifies a pointer to a <t COMPVARS> structure
* used during sequence compression.
*
* @comm Use <f ICCompressorChoose> to let the
* user specify a compressor to use, or initialize a <t COMPVARS> structure
* manually. Use <f ICSeqCompressFrameStart>, <f ICSeqCompressFrame>
* and <f ICSeqCompressFrameEnd> functions to compress a sequence of
* frames to a specified data rate and number of key frames. When
* finished with compression, use <f ICCompressorFree> to
* release the resources specified by the <t COMPVARS> structure.
*
* @xref <f ICCompressorChoose> <f ICSeqCompressFrame> <f ICCompressorFree>
* <f ICSeqCompressFrameStart>
*
*******************************************************************/
///////////////////////////////////////////////////////////////////////////////
//
// ICSeqCompressFrameEnd
//
///////////////////////////////////////////////////////////////////////////////
void VFWAPI ICSeqCompressFrameEnd(PCOMPVARS pc)
{
if (pc == NULL || pc->cbSize != sizeof(COMPVARS))
return;
// This function still leaves pc->hic and pc->lpbiOut alloced and open
// since they were set by ICCompressorChoose
// Seems we've already freed everything - don't call ICCompressEnd twice
if (pc->lpBitsOut == NULL)
return;
/* Stop compressing */
if (pc->hic) {
ICCompressEnd(pc->hic);
if (pc->lpBitsPrev)
ICDecompressEnd(pc->hic);
}
/* Free the buffer for compressed image */
if (pc->lpBitsOut) {
GlobalFreePtr(pc->lpBitsOut);
pc->lpBitsOut = NULL;
}
/* Free the buffer for the decompressed previous frame */
if (pc->lpBitsPrev) {
GlobalFreePtr(pc->lpBitsPrev);
pc->lpBitsPrev = NULL;
}
}
/*******************************************************************
* @doc EXTERNAL ICSeqCompressFrame ICAPPS
*
* @api LPVOID | ICSeqCompressFrame | This function compresses a
* frame in a sequence of frames. The data rate for the sequence
* as well as the key-frame frequency can be specified. Use this function
* once for each frame to be compressed.
*
* @parm PCOMPVARS | pc | Specifies a pointer to a <t COMPVARS> structure
* initialized with information about the compression.
*
* @parm UINT | uiFlags | Specifies flags for this function. Set this
* parameter to zero.
*
* @parm LPVOID | lpBits | Specifies a pointer the data bits to compress.
* (The data bits excludes header or format information.)
*
* @parm BOOL FAR * | pfKey | Returns whether or not the frame was compressed
* into a keyframe.
*
* @parm LONG FAR * | plSize | Specifies the maximum size desired for
* the compressed image. The compressor might not be able to
* compress the data to within this size. When the function
* returns, the parameter points to the size of the compressed
* image. Images sizes are specified in bytes.
*
* @rdesc Returns a pointer to the compressed bits.
*
* @comm Use <f ICCompressorChoose> to let the
* user specify a compressor to use, or initialize a <t COMPVARS> structure
* manually. Use <f ICSeqCompressFrameStart>, <f ICSeqCompressFrame>
* and <f ICSeqCompressFrameEnd> functions to compress a sequence of
* frames to a specified data rate and number of key frames. When
* finished with compression, use <f ICCompressorFree> to
* release the resources specified by the <t COMPVARS> structure.
*
* Use this function repeatedly to compress a video sequence one
* frame at a time. Use this function instead of <f ICCompress>
* to compress a video sequence. This function supports creating key frames
* in the compressed sequence at any frequency you like and handles
* much of the initialization process.
* @xref <f ICCompressorChoose> <f ICSeqCompressFrameEnd> <f ICCompressorFree>
* <f ICCompressorFreeStart>
*
*******************************************************************/
///////////////////////////////////////////////////////////////////////////////
//
// ICSeqCompressFrame
//
// compresses a given image but supports KEY FRAMES EVERY
//
// input:
// pc stuff
// uiFlags flags (not used, must be 0)
// lpBits input DIB bits
// lQuality the reqested compression quality
// pfKey did this frame end up being a key frame?
//
// returns:
// a HANDLE to the converted image. The handle is a DIB in CF_DIB
// format, ie a packed DIB. The caller is responsible for freeing
// the memory. NULL is returned if error.
//
///////////////////////////////////////////////////////////////////////////////
LPVOID VFWAPI ICSeqCompressFrame(
PCOMPVARS pc, // junk set up by Start()
UINT uiFlags, // flags
LPVOID lpBits, // input DIB bits
BOOL FAR *pfKey, // did it end up being a key frame?
LONG FAR *plSize) // requested size/size of returned image
{
LONG l;
DWORD dwFlags = 0;
DWORD ckid = 0;
BOOL fKey;
LONG lSize = plSize ? *plSize : 0;
// Is it time to make a keyframe?
// First frame will always be a keyframe cuz they initialize to the same
// value.
if (fKey = (pc->lKeyCount >= pc->lKey)) {
// For compatibility with existing old apps
dwFlags = AVIIF_KEYFRAME;
}
l = ICCompress(pc->hic,
fKey ? ICCOMPRESS_KEYFRAME : 0, // flags
(LPBITMAPINFOHEADER)pc->lpbiOut, // output format
pc->lpBitsOut, // output data
(LPBITMAPINFOHEADER)pc->lpbiIn, // format of frame to compress
lpBits, // frame data to compress
&ckid, // ckid for data in AVI file
&dwFlags, // flags in the AVI index.
pc->lFrame, // frame number of seq.
lSize, // reqested size in bytes. (if non zero)
pc->lQ, // quality
fKey ? NULL : (LPBITMAPINFOHEADER)pc->lpbiIn, // fmt of prev frame
fKey ? NULL : pc->lpBitsPrev); // previous frame
if (l < ICERR_OK)
goto FrameError;
/* Return the size of the compressed data */
if (plSize)
*plSize = pc->lpbiOut->bmiHeader.biSizeImage;
// note: we do not reset biSizeImage... despite the fact that we
// allocated this structure, we know its size, and after compression
// the size is wrong!!
/* Now decompress the frame into our buffer for the previous frame */
if (pc->lpBitsPrev) {
l = ICDecompress(pc->hic,
0,
(LPBITMAPINFOHEADER)pc->lpbiOut,
pc->lpBitsOut,
(LPBITMAPINFOHEADER)pc->lpbiIn, // !!! should check for this.
pc->lpBitsPrev);
if (l != ICERR_OK)
goto FrameError;
}
/* Was the compressed image a keyframe? */
*pfKey = (BOOL)(dwFlags & AVIIF_KEYFRAME);
/* After making a keyframe, reset our counter that tells us when we MUST */
/* make another one. */
if (*pfKey)
pc->lKeyCount = 0;
// Never make a keyframe again after the first one if we don't want them.
// Increment our counter of how long its been since the last one if we do.
if (pc->lKey)
pc->lKeyCount++;
else
pc->lKeyCount = -1;
// Next time we're called we're on the next frame
pc->lFrame++;
return (pc->lpBitsOut);
FrameError:
return NULL;
}
/*******************************************************************
* @doc EXTERNAL ICImageCompress ICAPPS
*
* @api HANDLE | ICImageCompress | This function provides
* convenient method of compressing an image to a given
* size. This function does not require use of initialization functions.
*
* @parm HIC | hic | Specifies the handle to a compressor to
* opened with <f ICOpen> or NULL. Use NULL to choose a
* default compressor for your compression format.
* Applications can use the compressor handle returned
* by <f ICCompressorChoose> in the <e COMPVARS.hic> member
* of the <t COMPVARS> structure if they want the user to
* select the compressor. This compressor is already opened.
*
* @parm UINT | uiFlags | Specifies flags for this function. Set this
* to zero.
*
* @parm LPBITMAPINFO | lpbiIn | Specifies the input data format.
*
* @parm LPVOID | lpBits | Specifies a pointer to input data bits to compress.
* (The data bits excludes header or format information.)
*
* @parm LPBITMAPINFO | lpbiOut | Specifies the compressed output format or NULL.
* If NULL, the compressor uses a default format.
*
* @parm LONG | lQuality | Specifies the quality value the compressor.
*
* @parm LONG FAR * | plSize | Specifies the maximum size desired for
* the compressed image. The compressor might not be able to
* compress the data to within this size. When the function
* returns, the parameter points to the size of the compressed
* image. Images sizes are specified in bytes.
*
*
* @rdesc Returns a handle to a compressed DIB. The image data follows the
* format header.
*
* @comm This function returns a DIB with the format and image data.
* To obtain the format information from the <t LPBITMAPINFOHEADER> structure,
* use <f GlobalLock> to lock the data. Use <f GlobalFree> to free the
* DIB when you have finished with it.
*
* @xref <f ICImageDecompress>
*
*******************************************************************/
///////////////////////////////////////////////////////////////////////////////
//
// ICImageCompress
//
// compresses a given image.
//
// input:
// hic compressor to use, if NULL is specifed a
// compressor will be located that can handle the conversion.
// uiFlags flags (not used, must be 0)
// lpbiIn input DIB format
// lpBits input DIB bits
// lpbiOut output format, if NULL is specifed the default
// format choosen be the compressor will be used.
// lQuality the reqested compression quality
// plSize the reqested size for the image/returned size
//
// returns:
// a handle to a DIB which is the compressed image.
//
///////////////////////////////////////////////////////////////////////////////
HANDLE VFWAPI ICImageCompress(
HIC hic, // compressor (NULL if any will do)
UINT uiFlags, // flags
LPBITMAPINFO lpbiIn, // input DIB format
LPVOID lpBits, // input DIB bits
LPBITMAPINFO lpbiOut, // output format (NULL => default)
LONG lQuality, // the reqested quality
LONG FAR * plSize) // requested size for compressed frame
{
LONG l;
BOOL fNuke;
DWORD dwFlags = 0;
DWORD ckid = 0;
LONG lSize = plSize ? *plSize : 0;
LPBITMAPINFOHEADER lpbi=NULL;
//
// either locate a compressor or use the one supplied.
//
if (fNuke = (hic == NULL))
{
hic = ICLocate(ICTYPE_VIDEO, 0L, (LPBITMAPINFOHEADER)lpbiIn,
(LPBITMAPINFOHEADER)lpbiOut, ICMODE_COMPRESS);
if (hic == NULL)
return NULL;
}
//
// make sure the found compressor can compress something ??? WHY BOTHER ???
//
if (ICCompressQuery(hic, lpbiIn, NULL) != ICERR_OK)
goto error;
if (lpbiOut)
{
l = lpbiOut->bmiHeader.biSize + 256 * sizeof(RGBQUAD);
}
else
{
//
// now make a DIB header big enough to hold the output format
//
l = ICCompressGetFormatSize(hic, lpbiIn);
if (l <= 0)
goto error;
}
lpbi = (LPVOID)GlobalAllocPtr(GHND, l);
if (lpbi == NULL)
goto error;
//
// if the compressor likes the passed format, use it else use the default
// format of the compressor.
//
if (lpbiOut == NULL || ICCompressQuery(hic, lpbiIn, lpbiOut) != ICERR_OK)
ICCompressGetFormat(hic, lpbiIn, lpbi);
else
hmemcpy(lpbi, lpbiOut, lpbiOut->bmiHeader.biSize +
lpbiOut->bmiHeader.biClrUsed * sizeof(RGBQUAD));
lpbi->biSizeImage = ICCompressGetSize(hic, lpbiIn, lpbi);
lpbi->biClrUsed = DibNumColors(lpbi);
//
// now resize the DIB to be the maximal size.
//
lpbi = (LPVOID)GlobalReAllocPtr(lpbi,DibSize(lpbi), 0);
if (lpbi == NULL)
goto error;
//
// now compress it.
//
if (ICCompressBegin(hic, lpbiIn, lpbi) != ICERR_OK)
goto error;
if (lpBits == NULL)
lpBits = DibPtr((LPBITMAPINFOHEADER)lpbiIn);
if (lQuality == ICQUALITY_DEFAULT)
lQuality = ICGetDefaultQuality(hic);
l = ICCompress(hic,
0, // flags
(LPBITMAPINFOHEADER)lpbi, // output format
DibPtr(lpbi), // output data
(LPBITMAPINFOHEADER)lpbiIn,// format of frame to compress
lpBits, // frame data to compress
&ckid, // ckid for data in AVI file
&dwFlags, // flags in the AVI index.
0, // frame number of seq.
lSize, // requested size in bytes. (if non zero)
lQuality, // quality
NULL, // format of previous frame
NULL); // previous frame
if (l < ICERR_OK) {
DPF(("ICCompress returned %ld!\n", l));
ICCompressEnd(hic);
goto error;
}
// Return the size of the compressed data
if (plSize)
*plSize = lpbi->biSizeImage;
if (ICCompressEnd(hic) != ICERR_OK)
goto error;
//
// now resize the DIB to be the real size.
//
lpbi = (LPVOID)GlobalReAllocPtr(lpbi, DibSize(lpbi), 0);
//
// all done return the result to the caller
//
if (fNuke)
ICClose(hic);
GlobalUnlock(GlobalPtrHandle(lpbi));
return GlobalPtrHandle(lpbi);
error:
if (lpbi)
GlobalFreePtr(lpbi);
if (fNuke)
ICClose(hic);
return NULL;
}
/*******************************************************************
*
* @doc EXTERNAL ICImageDecompress ICAPPS
*
* @api HANDLE | ICImageDecompress | This function provides
* convenient method of decompressing an image without
* using initialization functions.
**
* @parm HIC | hic | Specifies the handle to a decompressor opened
* with <f ICOpen> or NULL. Use NULL to choose a default
* decompressor for your format.
*
* @parm UINT | uiFlags | Specifies flags for this function. Set this
* to zero.
*
* @parm LPBITMAPINFO | lpbiIn | Specifies the compressed input data format.
*
* @parm LPVOID | lpBits | Specifies a pointer to input data bits to compress.
* (The data bits excludes header or format information.)
*
* @parm LPBITMAPINFO | lpbiOut | Specifies the decompressed output format or NULL.
* If NULL, the decompressor uses a default format.
*
* @rdesc Returns a handle to an uncompressed DIB in the CF_DIB format,
* or NULL for an error. The image data follows the format header.
*
* @comm This function returns a DIB with the format and image data.
* To obtain the format information from the <t LPBITMAPINFOHEADER> structure,
* use <f GlobalLock> to lock the data. Use <f GlobalFree> to free the
* DIB when you have finished with it.
*
* @xref <f ICImageCompress>
*
*******************************************************************/
///////////////////////////////////////////////////////////////////////////////
//
// ICImageDecompress
//
// decompresses a given image.
//
// input:
// hic compressor to use, if NULL is specifed a
// compressor will be located that can handle the conversion.
// uiFlags flags (not used, must be 0)
// lpbiIn input DIB format
// lpBits input DIB bits
// lpbiOut output format, if NULL is specifed the default
// format choosen be the compressor will be used.
//
// returns:
// a HANDLE to the converted image. The handle is a DIB in CF_DIB
// format, ie a packed DIB. The caller is responsible for freeing
// the memory. NULL is returned if error.
//
///////////////////////////////////////////////////////////////////////////////
HANDLE VFWAPI ICImageDecompress(
HIC hic, // compressor (NULL if any will do)
UINT uiFlags, // flags
LPBITMAPINFO lpbiIn, // input DIB format
LPVOID lpBits, // input DIB bits
LPBITMAPINFO lpbiOut) // output format (NULL => default)
{
LONG l;
BOOL fNuke;
DWORD dwFlags = 0;
DWORD ckid = 0;
LPBITMAPINFOHEADER lpbi=NULL;
//
// either locate a compressor or use the one supplied.
//
if (fNuke = (hic == NULL))
{
hic = ICLocate(ICTYPE_VIDEO, 0L, (LPBITMAPINFOHEADER)lpbiIn,
(LPBITMAPINFOHEADER)lpbiOut, ICMODE_DECOMPRESS);
if (hic == NULL)
return NULL;
}
//
// make sure the found compressor can decompress at all ??? WHY BOTHER ???
//
if (ICDecompressQuery(hic, lpbiIn, NULL) != ICERR_OK)
goto error;
if (lpbiOut)
{
l = lpbiOut->bmiHeader.biSize + 256 * sizeof(RGBQUAD);
}
else
{
//
// now make a DIB header big enough to hold the output format
//
l = ICDecompressGetFormatSize(hic, lpbiIn);
if (l <= 0)
goto error;
}
lpbi = (LPVOID)GlobalAllocPtr(GHND, l);
if (lpbi == NULL)
goto error;
//
// if we didn't provide an output format, use a default.
//
if (lpbiOut == NULL)
ICDecompressGetFormat(hic, lpbiIn, lpbi);
else
hmemcpy(lpbi, lpbiOut, lpbiOut->bmiHeader.biSize +
lpbiOut->bmiHeader.biClrUsed * sizeof(RGBQUAD));
//
// For decompress make sure the palette (ie color table) is correct
// just in case they provided an output format and the decompressor used
// that format but not their palette.
//
if (lpbi->biBitCount <= 8)
ICDecompressGetPalette(hic, lpbiIn, lpbi);
lpbi->biSizeImage = DibSizeImage(lpbi); // ICDecompressGetSize(hic, lpbi);
lpbi->biClrUsed = DibNumColors(lpbi);
//
// now resize the DIB to be the right size.
//
lpbi = (LPVOID)GlobalReAllocPtr(lpbi,DibSize(lpbi),0);
if (lpbi == NULL)
goto error;
//
// now decompress it.
//
if (ICDecompressBegin(hic, lpbiIn, lpbi) != ICERR_OK)
goto error;
if (lpBits == NULL)
lpBits = DibPtr((LPBITMAPINFOHEADER)lpbiIn);
l = ICDecompress(hic,
0, // flags
(LPBITMAPINFOHEADER)lpbiIn, // format of frame to decompress
lpBits, // frame data to decompress
(LPBITMAPINFOHEADER)lpbi, // output format
DibPtr(lpbi)); // output data
if (l < ICERR_OK) {
ICDecompressEnd(hic);
goto error;
}
if (ICDecompressEnd(hic) != ICERR_OK)
goto error;
//
// now resize the DIB to be the real size.
//
lpbi = (LPVOID)GlobalReAllocPtr(lpbi,DibSize(lpbi),0);
//
// all done return the result to the caller
//
if (fNuke)
ICClose(hic);
GlobalUnlock(GlobalPtrHandle(lpbi));
return GlobalPtrHandle(lpbi);
error:
if (lpbi)
GlobalFreePtr(lpbi);
if (fNuke)
ICClose(hic);
return NULL;
}
///////////////////////////////////////////////////////////////////////////////
//
// ICCompressorChooseStuff
//
///////////////////////////////////////////////////////////////////////////////
INT_PTR VFWAPI ICCompressorChooseDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
typedef struct {
DWORD fccType;
DWORD fccHandler;
UINT uiFlags;
LPVOID pvIn;
LPVOID lpData;
HWND hwnd;
HIC hic;
LONG lQ;
LONG lKey;
LONG lDataRate;
ICINFO icinfo;
LPSTR lpszTitle;
PAVISTREAM pavi;
AVISTREAMINFOW info;
HDRAWDIB hdd;
PGETFRAME pgf;
LPVOID lpState;
LONG cbState;
BOOL fClosing;
} ICCompressorChooseStuff, FAR *PICCompressorChooseStuff;
/*******************************************************************
* @doc EXTERNAL ICCompressorChoose ICAPPS
*
* @api BOOL | ICCompressorChoose | Displays a dialog box for choosing a
* compressor. It optionally provides a data rate box, key frame box, preview
* window, and filtering to display only compressors that can handle a
* specific format.
*
* @parm HWND | hwnd | Specifies the parent window for the dialog box.
*
* @parm UINT | uiFlags | Specifies flags for this function. The following
* flags are defined:
*
* @flag ICMF_CHOOSE_KEYFRAME | Displays a check box and edit box to enter the
* frequency of key frames.
*
* @flag ICMF_CHOOSE_DATARATE | Displays a check box and edit box to enter the
* data rate for the movie.
*
* @flag ICMF_CHOOSE_PREVIEW | Displays a button to expand the dialog box to
* include a preview window. The preview window shows how
* frames of your movie will appear when compressed with the
* current settings.
*
* @flag ICMF_CHOOSE_ALLCOMPRESSORS | Indicates all compressors should
* should appear in the selection list. If this flag is not specified,
* just the compressors that can handle the input format appear in
* the selection list.
*
* @parm LPVOID | pvIn | Specifies the uncompressed
* data input format. This parameter is optional.
*
* @parm LPVOID | lpData | Specifies a <t PAVISTREAM> of type
* streamtypeVIDEO to use in the preview window. This parameter
* is optional.
*
* @parm PCOMPVARS | pc | Specifies a pointer to a <t COMPVARS>
* structure. The information returned initializes the
* structure for use with other functions.
*
* @parm LPSTR | lpszTitle | Points to a optional zero-terminated string
* containing a title for the dialog box.
*
* @rdesc Returns TRUE if the user chooses a compressor, and presses OK. Returns
* FALSE for an error, or if the user presses CANCEL.
*
* @comm This function lets the user select a compressor from a list.
* Before using it, set the <e COMPVARS.cbSize> member of the <t COMPVARS>
* structure to sizeof(COMPVARS). Initialize the rest of the structure
* to zeros unless you want to specify some valid defaults for
* the dialog box. If specifing defaults, set the <e COMPVARS.dwFlags>
* member to ICMF_COMPVARS_VALID, and initialize the other members of
* the structure. See <f ICSeqCompressorFrameStart> and <t COMPVARS>
* for more information about initializing the structure.
*
* @xref <f ICCompressorFree> <f ICSeqCompressFrameStart> <f ICSeqCompressFrame>
* <f ICSeqCompressFrameEnd>
*
*******************************************************************/
///////////////////////////////////////////////////////////////////////////////
//
// ICCompressorChoose
//
// Brings up a dialog and allows the user to choose a compression
// method and a quality level, and/or a key frame frequency.
// All compressors in the system are displayed or can be optionally
// filtered by "ability to compress" a specifed format.
//
// the dialog allows the user to configure or bring up the compressors
// about box.
//
// A preview window can be provided to show a preview of a specific
// compression.
//
// the selected compressor is opened (via ICOpen) and returned to the
// caller, it must be disposed of by calling ICCompressorFree.
//
// input:
// HWND hwnd parent window for dialog box.
// UINT uiFlags flags
// LPVOID pvIn input format (optional), only compressors that
// handle this format will be displayed.
// LPVOID pavi input stream for the options preview
// PCOMPVARS pcj returns COMPVARS struct for use with other APIs
// LPSTR lpszTitle Optional title for dialog box
//
// returns:
// TRUE if dialog shown and user chose a compressor.
// FALSE if dialog was not shown or user hit cancel.
//
///////////////////////////////////////////////////////////////////////////////
BOOL VFWAPI ICCompressorChoose(
HWND hwnd, // parent window for dialog
UINT uiFlags, // flags
LPVOID pvIn, // input format (optional)
LPVOID pavi, // input stream (for preview - optional)
PCOMPVARS pcj, // state of compressor/dlg
LPSTR lpszTitle) // dialog title (if NULL, use default)
{
INT_PTR f;
PICCompressorChooseStuff p;
DWORD dwSize;
if (pcj == NULL || pcj->cbSize != sizeof(COMPVARS))
return FALSE;
//
// !!! Initialize the structure - unless the user has already done it
//
if (!(pcj->dwFlags & ICMF_COMPVARS_VALID)) {
pcj->hic = NULL;
pcj->fccType = 0;
pcj->fccHandler = 0;
pcj->lQ = ICQUALITY_DEFAULT;
pcj->lKey = -1; // means default
pcj->lDataRate = 300;
pcj->lpbiOut = NULL;
pcj->lpBitsOut = NULL;
pcj->lpBitsPrev = NULL;
pcj->dwFlags = 0;
pcj->lpState = NULL;
pcj->cbState = 0;
}
// Default type is a video compressor
if (pcj->fccType == 0)
pcj->fccType = ICTYPE_VIDEO;
p = (LPVOID)GlobalAllocPtr(GHND, sizeof(ICCompressorChooseStuff));
if (p == NULL)
return FALSE;
p->fccType = pcj->fccType;
p->fccHandler = pcj->fccHandler;
p->uiFlags = uiFlags;
p->pvIn = pvIn;
p->lQ = pcj->lQ;
p->lKey = pcj->lKey;
p->lDataRate = pcj->lDataRate;
p->lpszTitle = lpszTitle;
p->pavi = (PAVISTREAM)pavi;
p->hdd = NULL;
p->lpState = pcj->lpState;
pcj->lpState = NULL; // so it won't be freed
p->cbState = pcj->cbState;
// !!! Validate this pointer
// !!! AddRef if it is
if (p->pavi) {
if (p->pavi->lpVtbl->Info(p->pavi, &p->info, sizeof(p->info)) !=
AVIERR_OK || p->info.fccType != streamtypeVIDEO)
p->pavi = NULL;
}
f = DialogBoxParam(ghInst, TEXT("ICCDLG"),
hwnd, ICCompressorChooseDlgProc, (LPARAM)(LPVOID)p);
// !!! Treat error like cancel
if (f == -1)
f = FALSE;
//
// if the user picked a compressor then return this info to the caller
//
if (f) {
// If we are called twice in a row, we have good junk in here that
// needs to be freed before we tromp over it.
ICCompressorFree(pcj);
pcj->lQ = p->lQ;
pcj->lKey = p->lKey;
pcj->lDataRate = p->lDataRate;
pcj->hic = p->hic;
pcj->fccHandler = p->fccHandler;
pcj->lpState = p->lpState;
pcj->cbState = p->cbState;
pcj->dwFlags |= ICMF_COMPVARS_VALID;
}
GlobalFreePtr(p);
if (!f)
return FALSE;
if (pcj->hic && pvIn) { // hic is NULL if no compression selected
/* Get the format we're going to compress into. */
dwSize = ICCompressGetFormatSize(pcj->hic, pvIn);
if (!dwSize || ((pcj->lpbiOut =
(LPBITMAPINFO)GlobalAllocPtr(GMEM_MOVEABLE, dwSize)) == NULL)) {
ICClose(pcj->hic); // Close this since we're erroring
pcj->hic = NULL;
return FALSE;
}
ICCompressGetFormat(pcj->hic, pvIn, pcj->lpbiOut);
}
return TRUE;
}
void SizeDialog(HWND hwnd, WORD id) {
RECT rc;
GetWindowRect(GetDlgItem(hwnd, id), &rc);
/* First, get rc in Client co-ords */
ScreenToClient(hwnd, (LPPOINT)&rc + 1);
rc.top = 0; rc.left = 0;
/* Grow by non-client size */
AdjustWindowRect(&rc, GetWindowLong(hwnd, GWL_STYLE),
GetMenu(hwnd) !=NULL);
/* That's the new size for the dialog */
SetWindowPos(hwnd, NULL, 0, 0, rc.right-rc.left,
rc.bottom-rc.top,
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
}
void TermPreview(PICCompressorChooseStuff p)
{
if (p->hdd)
DrawDibClose(p->hdd);
p->hdd = NULL;
}
BOOL InitPreview(HWND hwnd, PICCompressorChooseStuff p) {
p->hdd = DrawDibOpen();
if (!p->hdd)
return FALSE;
return TRUE;
}
#ifdef SAFETOYIELD
//
// Code to yield while we're not calling GetMessage.
// Dispatch all messages. Pressing ESC or closing aborts.
//
BOOL WinYield(HWND hwnd)
{
MSG msg;
BOOL fAbort=FALSE;
while(/* fWait > 0 && */ !fAbort && PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
if (msg.message == WM_KEYDOWN && msg.wParam == VK_ESCAPE)
fAbort = TRUE;
if (msg.message == WM_SYSCOMMAND && (msg.wParam & 0xFFF0) == SC_CLOSE)
fAbort = TRUE;
if (msg.hwnd == hwnd) {
if (msg.message == WM_KEYDOWN ||
msg.message == WM_SYSKEYDOWN ||
msg.message == WM_HSCROLL ||
msg.message == WM_PARENTNOTIFY ||
msg.message == WM_LBUTTONDOWN) {
PostMessage(hwnd, msg.message, msg.wParam, msg.lParam);
return TRUE;
}
}
TranslateMessage(&msg);
DispatchMessage(&msg);
}
return fAbort;
}
#endif
LONG CALLBACK _loadds PreviewStatusProc(LPARAM lParam, UINT message, LONG l)
{
TCHAR ach[100], achT[100];
BOOL f;
PICCompressorChooseStuff p = (PICCompressorChooseStuff) lParam;
if (message != ICSTATUS_STATUS) {
DPF(("Status callback: lParam = %lx, message = %u, l = %lu\n", lParam, message, l));
}
// !!!!
// !!!! Status messages need to be fixed!!!!!!
// !!!!
switch (message) {
case ICSTATUS_START:
break;
case ICSTATUS_STATUS:
LoadString (ghInst, ID_FRAMECOMPRESSING, achT, NUMELMS(achT));
wsprintf(ach, achT, GetScrollPos(GetDlgItem(p->hwnd,
ID_PREVIEWSCROLL), SB_CTL), l);
SetDlgItemText(p->hwnd, ID_PREVIEWTEXT, ach);
break;
case ICSTATUS_END:
break;
case ICSTATUS_YIELD:
break;
}
#ifdef SAFETOYIELD
f = WinYield(p->hwnd);
#else
f = FALSE;
#endif
if (f) {
DPF(("Aborting from within status proc!\n"));
}
return f;
}
void Preview(HWND hwnd, PICCompressorChooseStuff p, BOOL fCompress)
{
RECT rc;
HDC hdc;
int pos;
HANDLE h;
HCURSOR hcur = NULL;
LPBITMAPINFOHEADER lpbi, lpbiU, lpbiC = NULL;
TCHAR ach[120], achT[100];
LONG lsizeD = 0;
LONG lSize;
int x;
// Not previewing right now!
if (!p->hdd || !p->pgf)
return;
pos = GetScrollPos(GetDlgItem(hwnd, ID_PREVIEWSCROLL), SB_CTL);
lpbi = lpbiU = AVIStreamGetFrame(p->pgf, pos);
if (!lpbi)
return;
//
// What would the image look like compressed?
//
if (fCompress && ((INT_PTR)p->hic > 0)) {
LRESULT lRet;
lRet = (LRESULT)ICSetStatusProc(p->hic, 0, (LPARAM)p, PreviewStatusProc);
if (lRet != 0) {
hcur = SetCursor(LoadCursor(NULL, IDC_WAIT));
}
// !!! Gives whole data rate to this stream
// !!! What to do if Rate or Scale is zero?
lSize = (GetDlgItemInt(hwnd, ID_DATARATE, NULL, FALSE) * 1024L) /
((p->info.dwScale && p->info.dwRate) ?
(p->info.dwRate / p->info.dwScale) : 1L);
h = ICImageCompress(p->hic,
0,
(LPBITMAPINFO)lpbi,
(LPBYTE)lpbi + lpbi->biSize + lpbi->biClrUsed * sizeof(RGBQUAD),
NULL,
GetScrollPos(GetDlgItem(hwnd, ID_QUALITY), SB_CTL) * 100,
&lSize);
if (hcur)
SetCursor(hcur);
if (h)
lpbiC = (LPBITMAPINFOHEADER)GlobalLock(h);
// Use the compressed image if we have one.. else use the original frame
if (lpbiC)
lpbi = lpbiC;
}
//
// If we chose NO COMPRESSION, tell them the size of the data as its
// compressed now. Otherwise, use the size it will become when compressed
// or the full frame size.
//
if (fCompress && (p->hic == 0)) {
p->pavi->lpVtbl->Read(p->pavi, pos, 1, NULL, 0, &lsizeD, NULL);
} else {
lsizeD = (lpbiC ? lpbiC->biSizeImage : lpbiU->biSizeImage);
}
hdc = GetDC(GetDlgItem(hwnd, ID_PREVIEWWIN));
GetClientRect(GetDlgItem(hwnd, ID_PREVIEWWIN), &rc);
// Clip regions aren't set up right for windows in a dialog, so make sure
// we'll only paint into the window and not spill around it.
IntersectClipRect(hdc, rc.left, rc.top, rc.right, rc.bottom);
// Now go ahead and draw a miniature frame that preserves the aspect ratio
// centred in our preview window
x = MulDiv((int)lpbi->biWidth, 3, 4);
if (x <= (int)lpbi->biHeight) {
rc.left = (rc.right - MulDiv(rc.right, x, (int)lpbi->biHeight)) / 2;
rc.right -= rc.left;
} else {
x = MulDiv((int)lpbi->biHeight, 4, 3);
rc.top = (rc.bottom - MulDiv(rc.bottom, x, (int)lpbi->biWidth)) / 2;
rc.bottom -= rc.top;
}
DrawDibDraw(p->hdd, hdc, rc.left, rc.top, rc.right - rc.left,
rc.bottom - rc.top, lpbi, NULL, 0, 0, -1, -1, 0);
// Print the sizes and ratio for this frame
LoadString (ghInst, ID_FRAMESIZE, achT, NUMELMS(achT));
wsprintf(ach, achT,
GetScrollPos(GetDlgItem(hwnd, ID_PREVIEWSCROLL), SB_CTL),
lsizeD,
lpbiU->biSizeImage,
lsizeD * 100 / lpbiU->biSizeImage);
SetDlgItemText(hwnd, ID_PREVIEWTEXT, ach);
if (lpbiC)
GlobalFreePtr(lpbiC);
ReleaseDC(GetDlgItem(hwnd, ID_PREVIEWWIN), hdc);
}
///////////////////////////////////////////////////////////////////////////////
//
// ICCompressorChooseDlgProc
//
// dialog box procedure for ICCompressorChoose, a pointer to a
// ICCompressorChooseStuff pointer must be passed to initialize this
// dialog.
//
// NOTE: this dialog box procedure does not use any globals
// so I did not bother to _export it or use MakeProcAddress() if
// you change this code to use globals, etc, be aware of this fact.
//
///////////////////////////////////////////////////////////////////////////////
#ifdef _WIN32
// THIS IS A HACK. We need to store the HIC for each item in a combo
// box. We also need to store it's index. On NT these two items cannot
// be stored in a DWORD. Hence use a static array to contain the HIC
// elements which can then be referenced by the stored index.
// Look at the GetItemData and SetItemData routines.
#define MAX_COMPRESSORS 100
HIC aHic[MAX_COMPRESSORS]; // Hopefully, noone will have more than this
HIC GetHIC(HWND hwndCB, int index)
{
index = (int) ComboBox_GetItemData(hwndCB,index);
if (index>0 && index < MAX_COMPRESSORS) {
return(aHic[index]);
} else {
return((HIC)-1);
}
}
#else
#define GetHIC(hwnd,index) ((HIC)LOWORD(ComboBox_GetItemData((hwnd),(index))))
#endif
INT_PTR VFWAPI ICCompressorChooseDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
int i,n;
int pos;
HWND hwndC;
PICCompressorChooseStuff p;
HIC hic;
BOOL fConfig, fAbout, fQuality, fKey, fDataRate;
BOOL fShowKeyFrame, fShowDataRate, fShowPreview;
int nSelectMe = -1;
TCHAR ach[128], achT[80];
RECT rc;
UINT id;
HDC hdc;
BOOL f = FALSE, fCanDecompress = FALSE;
LONG lsize;
LPBITMAPINFOHEADER lpbi = NULL;
BOOL fStreamIsCompressed = FALSE;
HRESULT hr;
p = (PICCompressorChooseStuff)GetWindowLongPtr(hwnd,DWLP_USER);
switch (msg)
{
case WM_INITDIALOG:
#define but &&
#define and &&
#define is ==
#define isnt !=
if (lParam == 0)
return FALSE;
SetWindowLongPtr(hwnd,DWLP_USER,lParam);
p = (PICCompressorChooseStuff)lParam;
p->hwnd = hwnd;
// Let the user change the title of the dialog
if (p->lpszTitle != NULL)
SetWindowTextA(hwnd, p->lpszTitle);
#ifdef _WIN32
havifile = GetModuleHandleA("avifil32");
#else
havifile = GetModuleHandleA("avifile");
#endif
if (havifile) {
(FARPROC)AVIStreamGetFrameOpen =
GetProcAddress((HINSTANCE)havifile,
(LPCSTR)"AVIStreamGetFrameOpen");
(FARPROC)AVIStreamGetFrame =
GetProcAddress((HINSTANCE)havifile,
(LPCSTR)"AVIStreamGetFrame");
(FARPROC)AVIStreamGetFrameClose =
GetProcAddress((HINSTANCE)havifile,
(LPCSTR)"AVIStreamGetFrameClose");
if (p->pavi)
p->pgf = AVIStreamGetFrameOpen(p->pavi, NULL);
}
// We weren't passed in an input format but we have a PAVI we
// can get a format from
if (p->pvIn is NULL but p->pavi isnt NULL and p->pgf isnt NULL) {
// We need to nuke pvIn later
f = TRUE;
// Find out if the AVI Stream is compressed or not
p->pavi->lpVtbl->ReadFormat(p->pavi, 0, NULL, &lsize);
if (lsize)
lpbi = (LPBITMAPINFOHEADER)GlobalAllocPtr(GMEM_MOVEABLE,
lsize);
if (lpbi) {
hr = p->pavi->lpVtbl->ReadFormat(p->pavi, 0, lpbi, &lsize);
if (hr == AVIERR_OK)
fStreamIsCompressed = lpbi->biCompression != BI_RGB;
GlobalFreePtr(lpbi);
}
// Get the decompressed format of the AVI stream
lpbi = AVIStreamGetFrame(p->pgf, 0);
if (lpbi) {
lsize = lpbi->biSize +
lpbi->biClrUsed * sizeof(PALETTEENTRY);
p->pvIn = (LPBITMAPINFOHEADER)GlobalAllocPtr(GMEM_MOVEABLE,
lsize);
if (p->pvIn)
hmemcpy(p->pvIn, lpbi, lsize);
}
}
//
// now fill the combo box with all compressors
//
hwndC = GetDlgItem(hwnd, ID_COMPRESSOR);
for (i=0; ICInfo(p->fccType, i, &p->icinfo); i++)
{
hic = ICOpen(p->icinfo.fccType, p->icinfo.fccHandler,
ICMODE_COMPRESS);
if (hic)
{
//
// skip this compressor if it can't handle the
// specifed format and we want to skip such compressors
//
if (!(p->uiFlags & ICMF_CHOOSE_ALLCOMPRESSORS) &&
p->pvIn != NULL &&
ICCompressQuery(hic, p->pvIn, NULL) != ICERR_OK)
{
ICClose(hic);
continue;
}
//
// find out the compressor name.
//
ICGetInfo(hic, &p->icinfo, sizeof(p->icinfo));
//
// stuff it into the combo box and remember which one it was
//
#if defined _WIN32 && !defined UNICODE
//assert (NUMELMS(ach) >= NUMELMS(p->icinfo.szDescription));
mmWideToAnsi (ach, p->icinfo.szDescription,
NUMELMS(p->icinfo.szDescription));
n = ComboBox_AddString(hwndC, ach);
#else
n = ComboBox_AddString(hwndC, p->icinfo.szDescription);
#endif
#ifdef _WIN32
// Making a LONG out of a hic and an int just won't cut it
// We have to use some auxiliary storage
if (i >= MAX_COMPRESSORS) {
#ifdef DEBUG
UINT n = fDebug;
fDebug = 1;
DPF(("Overwriting array...i==%d\n",i));
DebugBreak();
fDebug = n;
#endif
}
aHic[i] = hic;
ComboBox_SetItemData(hwndC, n, i);
#else
ComboBox_SetItemData(hwndC, n, MAKELONG(hic, i));
#endif
// This compressor is the one we want to come up default ?
// Set its state
// !!! Combo Box better not be sorted!
// Convert both to upper case for an insensitive compare
AnsiUpperBuff((LPSTR)&p->icinfo.fccHandler, sizeof(FOURCC));
AnsiUpperBuff((LPSTR)&p->fccHandler, sizeof(FOURCC));
if (p->icinfo.fccHandler == p->fccHandler) {
nSelectMe = n;
if (p->lpState)
ICSetState(hic, p->lpState, p->cbState);
}
}
}
//
// Next add a "No Recompression" item unless they passed in an
// uncompressed format
//
if (fStreamIsCompressed || (p->pvIn &&
((LPBITMAPINFOHEADER)p->pvIn)->biCompression != BI_RGB)) {
LoadString (ghInst, ID_NOCOMPSTRING, ach, NUMELMS(ach));
n = ComboBox_AddString(hwndC, ach);
#ifdef _WIN32
aHic[MAX_COMPRESSORS - 1] = 0;
ComboBox_SetItemData(hwndC, n, MAX_COMPRESSORS - 1);
#else
ComboBox_SetItemData(hwndC, n, 0);
#endif
// Select "No Recompression" as the default if that was the one
// last chosen. This will also be the default choice (0).
if (p->fccHandler == 0)
nSelectMe = n;
}
//
// Now add a "Full Frames (Uncompressed)" item unless we can't
// decompress this format and they don't want all choices anyway
//
if (!(p->uiFlags & ICMF_CHOOSE_ALLCOMPRESSORS) && p->pvIn) {
// If it's RGB, of course, just offer the option.
if (((LPBITMAPINFOHEADER)p->pvIn)->biCompression != BI_RGB) {
if ((hic = ICLocate(ICTYPE_VIDEO, 0, p->pvIn, NULL,
ICMODE_DECOMPRESS)) == NULL)
goto SkipFF;
else
ICClose(hic);
}
}
LoadString (ghInst, ID_FULLFRAMESSTRING, ach, NUMELMS(ach));
n = ComboBox_AddString(hwndC, ach);
#ifdef _WIN32
aHic[MAX_COMPRESSORS - 2] = (HIC)-1;
ComboBox_SetItemData(hwndC, n, MAX_COMPRESSORS - 2);
#else
ComboBox_SetItemData(hwndC, n, MAKELONG(-1, 0));
#endif
// Select "Full Frames" if that was the last one chosen
// !!! Combo Box better not be sorted!
if (p->fccHandler == comptypeDIB)
nSelectMe = n;
fCanDecompress = TRUE;
SkipFF:
// If we haven't selected anything yet, choose something at random.
if (nSelectMe == -1)
nSelectMe = 0;
fShowKeyFrame = p->uiFlags & ICMF_CHOOSE_KEYFRAME;
fShowDataRate = p->uiFlags & ICMF_CHOOSE_DATARATE;
// Don't show a preview if we can't draw it!
fShowPreview = (p->uiFlags & ICMF_CHOOSE_PREVIEW) && p->pavi &&
fCanDecompress;
// Hide our secret small place holders
ShowWindow(GetDlgItem(hwnd, ID_CHOOSE_SMALL), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, ID_CHOOSE_NORMAL), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, ID_CHOOSE_BIG), SW_HIDE);
if (!fShowKeyFrame) {
ShowWindow(GetDlgItem(hwnd, ID_KEYFRAME), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, ID_KEYFRAMEBOX), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, ID_KEYFRAMETEXT), SW_HIDE);
}
if (!fShowDataRate) {
ShowWindow(GetDlgItem(hwnd, ID_DATARATE), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, ID_DATARATEBOX), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, ID_DATARATETEXT), SW_HIDE);
}
if (!fShowPreview) {
ShowWindow(GetDlgItem(hwnd, ID_PREVIEW), SW_HIDE);
}
// We start without these
ShowWindow(GetDlgItem(hwnd, ID_PREVIEWWIN), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, ID_PREVIEWSCROLL), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, ID_PREVIEWTEXT), SW_HIDE);
//
// What size dialog do we need?
//
if (!fShowPreview && (!fShowDataRate || !fShowKeyFrame))
SizeDialog(hwnd, ID_CHOOSE_SMALL);
else
SizeDialog(hwnd, ID_CHOOSE_NORMAL);
//
// Swap places for KeyFrameEvery and DataRate
//
if (fShowDataRate && !fShowKeyFrame) {
GetWindowRect(GetDlgItem(hwnd, ID_KEYFRAME), &rc);
ScreenToClient(hwnd, (LPPOINT)&rc);
ScreenToClient(hwnd, (LPPOINT)&rc + 1);
MoveWindow(GetDlgItem(hwnd, ID_DATARATE), rc.left, rc.top,
rc.right - rc.left, rc.bottom - rc.top, FALSE);
GetWindowRect(GetDlgItem(hwnd, ID_KEYFRAMEBOX), &rc);
ScreenToClient(hwnd, (LPPOINT)&rc);
ScreenToClient(hwnd, (LPPOINT)&rc + 1);
MoveWindow(GetDlgItem(hwnd, ID_DATARATEBOX), rc.left, rc.top,
rc.right - rc.left, rc.bottom - rc.top, FALSE);
GetWindowRect(GetDlgItem(hwnd, ID_KEYFRAMETEXT), &rc);
ScreenToClient(hwnd, (LPPOINT)&rc);
ScreenToClient(hwnd, (LPPOINT)&rc + 1);
MoveWindow(GetDlgItem(hwnd, ID_DATARATETEXT), rc.left, rc.top,
rc.right - rc.left, rc.bottom - rc.top, TRUE);
}
//
// Restore the dlg to the settings found in the structure
//
SetScrollRange(GetDlgItem(hwnd, ID_QUALITY), SB_CTL, 0, 100, FALSE);
CheckDlgButton(hwnd, ID_KEYFRAMEBOX, (BOOL)(p->lKey != 0));
EnableWindow(GetDlgItem(hwnd, ID_KEYFRAME), (BOOL)(p->lKey != 0));
CheckDlgButton(hwnd, ID_DATARATEBOX, (BOOL)(p->lDataRate));
EnableWindow(GetDlgItem(hwnd, ID_DATARATE), (BOOL)(p->lDataRate));
if (p->lKey == -1) // we haven't chosen a key frame yet. Later
// we'll choose the compressor's default.
SetDlgItemInt(hwnd, ID_KEYFRAME, 0, FALSE);
else
SetDlgItemInt(hwnd, ID_KEYFRAME, (int)p->lKey, FALSE);
SetDlgItemInt(hwnd, ID_DATARATE, (int)p->lDataRate, FALSE);
ComboBox_SetCurSel(GetDlgItem(hwnd, ID_COMPRESSOR), nSelectMe);
SendMessage(hwnd, WM_COMMAND,
GET_WM_COMMAND_MPS(ID_COMPRESSOR, hwndC, CBN_SELCHANGE));
// We alloced this ourselves and need to free it now
if (f && p->pvIn)
GlobalFreePtr(p->pvIn);
return TRUE;
case WM_PALETTECHANGED:
// It came from us. Ignore it
if ((HWND)wParam == hwnd)
break;
case WM_QUERYNEWPALETTE:
if (!p->hdd)
break;
hdc = GetDC(hwnd);
//
// Realize the palette of the first video stream
// !!! If first stream isn't video, we're DEAD!
//
if (f = DrawDibRealize(p->hdd, hdc, FALSE))
InvalidateRect(hwnd, NULL, FALSE);
ReleaseDC(hwnd, hdc);
return f;
case WM_PAINT:
if (!p->hdd)
break;
// Paint everybody else before the Preview window since that'll
// take awhile, and we don't want an ugly window during it.
DefWindowProc(hwnd, msg, wParam, lParam);
UpdateWindow(hwnd);
Preview(hwnd, p, TRUE);
return 0;
case WM_HSCROLL:
#ifdef _WIN32
id = GetWindowLong(GET_WM_HSCROLL_HWND(wParam, lParam), GWL_ID);
pos = GetScrollPos(GET_WM_HSCROLL_HWND(wParam, lParam), SB_CTL);
#else
id = GetWindowWord((HWND)HIWORD(lParam), GWW_ID);
pos = GetScrollPos((HWND)HIWORD(lParam), SB_CTL);
#endif
switch (GET_WM_HSCROLL_CODE(wParam, lParam))
{
case SB_LINEDOWN: pos += 1; break;
case SB_LINEUP: pos -= 1; break;
case SB_PAGEDOWN: pos += (id == ID_QUALITY) ? 10 :
(int)p->info.dwLength / 10; break;
case SB_PAGEUP: pos -= (id == ID_QUALITY) ? 10 :
(int)p->info.dwLength / 10; break;
case SB_THUMBTRACK:
case SB_THUMBPOSITION: pos = GET_WM_HSCROLL_POS(wParam, lParam); break;
case SB_ENDSCROLL:
Preview(hwnd, p, TRUE); // Draw this compressed frame
return TRUE; // don't fall through and invalidate
default:
return TRUE;
}
if (id == ID_QUALITY) {
if (pos < 0)
pos = 0;
if (pos > (ICQUALITY_HIGH/100))
pos = (ICQUALITY_HIGH/100);
SetDlgItemInt(hwnd, ID_QUALITYTEXT, pos, FALSE);
SetScrollPos(GET_WM_HSCROLL_HWND(wParam, lParam), SB_CTL, pos, TRUE);
} else if (id == ID_PREVIEWSCROLL) {
// !!! round off !!!
if (pos < (int)p->info.dwStart)
pos = (int)p->info.dwStart;
if (pos >= (int)p->info.dwStart + (int)p->info.dwLength)
pos = (int)(p->info.dwStart + p->info.dwLength - 1);
SetScrollPos(GET_WM_HSCROLL_HWND(wParam, lParam), SB_CTL, pos, TRUE);
LoadString (ghInst, ID_FRAME, achT, NUMELMS(achT));
wsprintf(ach, achT, pos);
SetDlgItemText(hwnd, ID_PREVIEWTEXT, ach);
//Drawing while scrolling flashes palettes because they aren't
//compressed.
//Preview(hwnd, p, FALSE);
}
break;
case WM_COMMAND:
hwndC = GetDlgItem(hwnd, ID_COMPRESSOR);
n = ComboBox_GetCurSel(hwndC);
#ifdef _WIN32
hic = (n == -1) ? NULL
: aHic[ComboBox_GetItemData(hwndC,n)];
#else
hic = (n == -1) ? NULL : (HIC)LOWORD(ComboBox_GetItemData(hwndC,n));
#endif
if (!p->fClosing)
p->hic = hic;
switch ((int)GET_WM_COMMAND_ID(wParam, lParam))
{
// When data rate box loses focus, update our preview
case ID_DATARATE:
if (GET_WM_COMMAND_CMD(wParam, lParam) == EN_KILLFOCUS)
Preview(hwnd, p, TRUE);
break;
// Enable the "data rate" edit box iff we've checked it
case ID_DATARATEBOX:
f = IsDlgButtonChecked(hwnd, ID_DATARATEBOX);
EnableWindow(GetDlgItem(hwnd, ID_DATARATE), f);
break;
// Enable the "key frame" edit box iff we've checked it
case ID_KEYFRAMEBOX:
f = IsDlgButtonChecked(hwnd, ID_KEYFRAMEBOX);
EnableWindow(GetDlgItem(hwnd, ID_KEYFRAME), f);
break;
case ID_COMPRESSOR:
if (GET_WM_COMMAND_CMD(wParam, lParam) != CBN_SELCHANGE)
break;
if ((INT_PTR)p->hic > 0) {
ICGetInfo(p->hic, &p->icinfo, sizeof(p->icinfo));
fConfig = (BOOL)ICQueryConfigure(p->hic);
fAbout = ICQueryAbout(p->hic);
fQuality = (p->icinfo.dwFlags & VIDCF_QUALITY) != 0;
fKey = (p->icinfo.dwFlags & VIDCF_TEMPORAL) != 0;
// if they do quality we fake crunch
fDataRate= (p->icinfo.dwFlags &
(VIDCF_QUALITY|VIDCF_CRUNCH)) != 0;
// We haven't chosen a key frame rate yet. Use this
// compressor's default.
if (p->lKey == -1)
SetDlgItemInt(hwnd, ID_KEYFRAME,
(int)ICGetDefaultKeyFrameRate(p->hic), FALSE);
} else {
fConfig = fAbout = fQuality = fKey = fDataRate = FALSE;
}
EnableWindow(GetDlgItem(hwnd, ID_CONFIG), fConfig);
EnableWindow(GetDlgItem(hwnd, ID_ABOUT), fAbout);
EnableWindow(GetDlgItem(hwnd, ID_QUALITY), fQuality);
EnableWindow(GetDlgItem(hwnd, ID_QUALITYLABEL), fQuality);
EnableWindow(GetDlgItem(hwnd, ID_QUALITYTEXT), fQuality);
EnableWindow(GetDlgItem(hwnd, ID_KEYFRAMEBOX), fKey);
EnableWindow(GetDlgItem(hwnd, ID_KEYFRAME),
fKey && IsDlgButtonChecked(hwnd, ID_KEYFRAMEBOX));
EnableWindow(GetDlgItem(hwnd, ID_KEYFRAMETEXT), fKey);
EnableWindow(GetDlgItem(hwnd, ID_DATARATEBOX), fDataRate);
EnableWindow(GetDlgItem(hwnd, ID_DATARATE),
fDataRate && IsDlgButtonChecked(hwnd, ID_DATARATEBOX));
EnableWindow(GetDlgItem(hwnd, ID_DATARATETEXT), fDataRate);
if (fQuality)
{
if (p->lQ == ICQUALITY_DEFAULT && (INT_PTR)p->hic > 0)
{
SetScrollPos(GetDlgItem(hwnd, ID_QUALITY), SB_CTL,
(int)ICGetDefaultQuality(p->hic) / 100, TRUE);
}
else
{
SetScrollPos(GetDlgItem(hwnd, ID_QUALITY), SB_CTL,
(int)p->lQ / 100, TRUE);
}
pos = GetScrollPos(GetDlgItem(hwnd, ID_QUALITY),SB_CTL);
SetDlgItemInt(hwnd, ID_QUALITYTEXT, pos, FALSE);
}
// redraw with new compressor
Preview(hwnd, p, TRUE);
break;
case ID_CONFIG:
if ((INT_PTR)p->hic > 0) {
ICConfigure(p->hic, hwnd);
Preview(hwnd, p, TRUE);
}
break;
case ID_ABOUT:
if ((INT_PTR)p->hic > 0)
ICAbout(p->hic, hwnd);
break;
case ID_PREVIEW:
ShowWindow(GetDlgItem(hwnd, ID_PREVIEW), SW_HIDE);
ShowWindow(GetDlgItem(hwnd, ID_PREVIEWWIN), SW_SHOW);
ShowWindow(GetDlgItem(hwnd, ID_PREVIEWSCROLL), SW_SHOW);
ShowWindow(GetDlgItem(hwnd, ID_PREVIEWTEXT), SW_SHOW);
SizeDialog(hwnd, ID_CHOOSE_BIG);
// !!! truncation
SetScrollRange(GetDlgItem(hwnd, ID_PREVIEWSCROLL), SB_CTL,
(int)p->info.dwStart,
(int)(p->info.dwStart + p->info.dwLength - 1),
FALSE);
SetScrollPos(GetDlgItem(hwnd, ID_PREVIEWSCROLL), SB_CTL,
(int)p->info.dwStart, TRUE);
LoadString (ghInst, ID_FRAME, achT, NUMELMS(achT));
wsprintf(ach, achT, p->info.dwStart);
SetDlgItemText(hwnd, ID_PREVIEWTEXT, ach);
InitPreview(hwnd, p);
break;
case IDOK:
// !!! We need to call ICInfo to get the FOURCC used
// in system.ini. Calling ICGetInfo will return the
// FOURCC the compressor thinks it is, which won't
// work.
// Get the HIWORD before we nuke it.
#ifndef _WIN32
i = HIWORD(ComboBox_GetItemData(hwndC, n));
//
// Don't close the current compressor in our CANCEL loop
//
ComboBox_SetItemData(hwndC, n, 0);
#else
i = (int) ComboBox_GetItemData(hwndC, n);
aHic[i] = 0;
#endif
//
// Return the values of the dlg to the caller
//
p->hic = hic;
p->lQ = 100 *
GetScrollPos(GetDlgItem(hwnd, ID_QUALITY), SB_CTL);
if (IsDlgButtonChecked(hwnd, ID_KEYFRAMEBOX))
p->lKey = GetDlgItemInt(hwnd, ID_KEYFRAME, NULL, FALSE);
else
p->lKey = 0;
if (IsDlgButtonChecked(hwnd, ID_DATARATEBOX))
p->lDataRate = GetDlgItemInt(hwnd, ID_DATARATE, NULL,
FALSE);
else
p->lDataRate = 0;
// We've chosen a valid compressor. Do stuff.
if ((INT_PTR)p->hic > 0) {
// !!! We need to call ICInfo to get the FOURCC used
// in system.ini. Calling ICGetInfo will return the
// FOURCC the compressor thinks it is, which won't
// work.
ICInfo(p->fccType, i, &p->icinfo);
p->fccHandler = p->icinfo.fccHandler; // identify it
// Free the old state
if (p->lpState) {
GlobalFreePtr(p->lpState);
p->lpState = NULL;
}
// Get the new state
p->cbState = ICGetStateSize(p->hic);
if (p->cbState) { // Remember it's config state
p->lpState = GlobalAllocPtr(GMEM_MOVEABLE,
p->cbState);
if (p->lpState) {
ICGetState(p->hic, p->lpState, p->cbState);
}
}
} else if ((INT_PTR)p->hic == -1) { // "Full Frames"
p->fccHandler = comptypeDIB;
p->hic = 0;
} else { // "No Compression"
p->fccHandler = 0L;
p->hic = 0;
}
// fall through
case IDCANCEL:
p->fClosing = TRUE;
if (GET_WM_COMMAND_ID(wParam, lParam) == IDCANCEL)
p->hic = NULL;
n = ComboBox_GetCount(hwndC);
for (i=0; i<n; i++)
{
#ifdef _WIN32
hic = (HIC) aHic[ComboBox_GetItemData(hwndC, i)];
#else
hic = (HIC) LOWORD(ComboBox_GetItemData(hwndC,i));
#endif
if ((INT_PTR)hic > 0) {
ICClose(hic);
}
}
TermPreview(p);
if (p->pgf)
AVIStreamGetFrameClose(p->pgf);
p->pgf = NULL;
EndDialog(hwnd, GET_WM_COMMAND_ID(wParam, lParam) == IDOK);
break;
}
break;
}
return FALSE;
}
/*****************************************************************************
*
* dprintf() is called by the DPF macro if DEBUG is defined at compile time.
*
* The messages will be send to COM1: like any debug message. To
* enable debug output, add the following to WIN.INI :
*
* [debug]
* ICM=1
*
****************************************************************************/
#ifdef DEBUG
#define MODNAME "ICM"
extern char szDebug[]; // in MSVIDEO
static void cdecl dprintf(LPSTR szFormat, ...)
{
char ach[128];
#ifdef _WIN32
va_list va;
if (fDebug == -1)
fDebug = mmGetProfileIntA(szDebug,MODNAME, FALSE);
if (!fDebug)
return;
va_start(va, szFormat);
if (szFormat[0] == '!')
ach[0]=0, szFormat++;
else
wsprintfA(ach, MODNAME ": (tid %x) ", GetCurrentThreadId());
wvsprintfA(ach+lstrlenA(ach),szFormat,va);
va_end(va);
// lstrcat(ach, "\r\r\n");
#else
if (fDebug == -1)
fDebug = GetProfileInt("Debug",MODNAME, FALSE);
if (!fDebug)
return;
if (szFormat[0] == '!')
ach[0]=0, szFormat++;
else
lstrcpy(ach, MODNAME ": ");
wvsprintf(ach+lstrlen(ach),szFormat,(LPSTR)(&szFormat+1));
// lstrcat(ach, "\r\r\n");
#endif
OutputDebugStringA(ach);
}
#endif

Reference in a new issue Copy permalink