Changeset 195

Show
Ignore:
Timestamp:
07/17/07 12:37:48 (1 year ago)
Author:
WeirdCat
Message:

completely new translation (~50% ready, remaining lines marked with /+TODO+/)

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved

  • trunk/win32/vfw.d

    r155 r195  
    33*                                                                       * 
    44*                       Windows API header module                       * 
    5 *                                                                       * 
    6 *                 Translated from MinGW Windows headers                 * 
     5*                 written in the D programming language                 * 
    76*                                                                       * 
    87*                       Placed into public domain                       * 
    98\***********************************************************************/ 
     9 
    1010module win32.vfw; 
    1111pragma(lib, "vfw32.lib"); 
    1212 
    13 private import win32.ole2, win32.mmsystem, win32.windows; 
    14  
    15 //MACRO #define mmioFOURCC(c0,c1,c2,c3) ((DWORD)(BYTE)(c0)|((DWORD)(BYTE)(c1)<<8)|((DWORD)(BYTE)(c2)<<16)|((DWORD)(BYTE)(c3)<<24)) 
    16 //MACRO #define aviTWOCC(ch0,ch1) ((WORD)(BYTE)(ch0)|((WORD)(BYTE)(ch1)<<8)) 
    17  
    18 align(8): 
    19  
    20 const ICERR_OK=0; 
    21 const ICERR_DONTDRAW=1; 
    22 const ICERR_NEWPALETTE=2; 
    23 const ICERR_GOTOKEYFRAME=3; 
    24 const ICERR_STOPDRAWING=4; 
    25 const ICERR_UNSUPPORTED=-1; 
    26 const ICERR_BADFORMAT=-2; 
    27 const ICERR_MEMORY=-3; 
    28 const ICERR_INTERNAL=-4; 
    29 const ICERR_BADFLAGS=-5; 
    30 const ICERR_BADPARAM=-6; 
    31 const ICERR_BADSIZE=-7; 
    32 const ICERR_BADHANDLE=-8; 
    33 const ICERR_CANTUPDATE=-9; 
    34 const ICERR_ABORT=-10; 
    35 const ICERR_ERROR=-100; 
    36 const ICERR_BADBITDEPTH=-200; 
    37 const ICERR_BADIMAGESIZE=-201; 
    38 const ICERR_CUSTOM=-400; 
    39 const ICCOMPRESSFRAMES_PADDING=0x01; 
    40 const ICM_USER=(DRV_USER+0x0000); 
    41 const ICM_RESERVED_LOW=(DRV_USER+0x1000); 
    42 const ICM_RESERVED_HIGH=(DRV_USER+0x2000); 
    43 const ICM_RESERVED=ICM_RESERVED_LOW; 
    44 const ICM_GETSTATE=(ICM_RESERVED+0); 
    45 const ICM_SETSTATE=(ICM_RESERVED+1); 
    46 const ICM_GETINFO=(ICM_RESERVED+2); 
    47 const ICM_CONFIGURE=(ICM_RESERVED+10); 
    48 const ICM_ABOUT=(ICM_RESERVED+11); 
    49 const ICM_GETDEFAULTQUALITY=(ICM_RESERVED+30); 
    50 const ICM_GETQUALITY=(ICM_RESERVED+31); 
    51 const ICM_SETQUALITY=(ICM_RESERVED+32); 
    52 const ICM_SET=(ICM_RESERVED+40); 
    53 const ICM_GET=(ICM_RESERVED+41); 
    54 const ICM_FRAMERATE=mmioFOURCC!('F','r','m','R'); 
    55 const ICM_KEYFRAMERATE=mmioFOURCC!('K','e','y','R'); 
    56 const ICM_COMPRESS_GET_FORMAT=(ICM_USER+4); 
    57 const ICM_COMPRESS_GET_SIZE=(ICM_USER+5); 
    58 const ICM_COMPRESS_QUERY=(ICM_USER+6); 
    59 const ICM_COMPRESS_BEGIN=(ICM_USER+7); 
    60 const ICM_COMPRESS=(ICM_USER+8); 
    61 const ICM_COMPRESS_END=(ICM_USER+9); 
    62 const ICM_DECOMPRESS_GET_FORMAT=(ICM_USER+10); 
    63 const ICM_DECOMPRESS_QUERY=(ICM_USER+11); 
    64 const ICM_DECOMPRESS_BEGIN=(ICM_USER+12); 
    65 const ICM_DECOMPRESS=(ICM_USER+13); 
    66 const ICM_DECOMPRESS_END=(ICM_USER+14); 
    67 const ICM_DECOMPRESS_SET_PALETTE=(ICM_USER+29); 
    68 const ICM_DECOMPRESS_GET_PALETTE=(ICM_USER+30); 
    69 const ICM_DRAW_QUERY=(ICM_USER+31); 
    70 const ICM_DRAW_BEGIN=(ICM_USER+15); 
    71 const ICM_DRAW_GET_PALETTE=(ICM_USER+16); 
    72 const ICM_DRAW_START=(ICM_USER+18); 
    73 const ICM_DRAW_STOP=(ICM_USER+19); 
    74 const ICM_DRAW_END=(ICM_USER+21); 
    75 const ICM_DRAW_GETTIME=(ICM_USER+32); 
    76 const ICM_DRAW=(ICM_USER+33); 
    77 const ICM_DRAW_WINDOW=(ICM_USER+34); 
    78 const ICM_DRAW_SETTIME=(ICM_USER+35); 
    79 const ICM_DRAW_REALIZE=(ICM_USER+36); 
    80 const ICM_DRAW_FLUSH=(ICM_USER+37); 
    81 const ICM_DRAW_RENDERBUFFER=(ICM_USER+38); 
    82 const ICM_DRAW_START_PLAY=(ICM_USER+39); 
    83 const ICM_DRAW_STOP_PLAY=(ICM_USER+40); 
    84 const ICM_DRAW_SUGGESTFORMAT=(ICM_USER+50); 
    85 const ICM_DRAW_CHANGEPALETTE=(ICM_USER+51); 
    86 const ICM_GETBUFFERSWANTED=(ICM_USER+41); 
    87 const ICM_GETDEFAULTKEYFRAMERATE=(ICM_USER+42); 
    88 const ICM_DECOMPRESSEX_BEGIN=(ICM_USER+60); 
    89 const ICM_DECOMPRESSEX_QUERY=(ICM_USER+61); 
    90 const ICM_DECOMPRESSEX=(ICM_USER+62); 
    91 const ICM_DECOMPRESSEX_END=(ICM_USER+63); 
    92 const ICM_COMPRESS_FRAMES_INFO=(ICM_USER+70); 
    93 const ICM_SET_STATUS_PROC=(ICM_USER+72); 
    94 const ICMF_CONFIGURE_QUERY=0x01; 
    95 const ICCOMPRESS_KEYFRAME=0x01; 
    96 const ICSTATUS_START=0; 
    97 const ICSTATUS_STATUS=1; 
    98 const ICSTATUS_END=2; 
    99 const ICSTATUS_ERROR=3; 
    100 const ICSTATUS_YIELD=4; 
    101 const ICMODE_COMPRESS=1; 
    102 const ICMODE_DECOMPRESS=2; 
    103 const ICMODE_FASTDECOMPRESS=3; 
    104 const ICMODE_QUERY=4; 
    105 const ICMODE_FASTCOMPRESS=5; 
    106 const ICMODE_DRAW=8; 
    107 const ICQUALITY_LOW=0; 
    108 const ICQUALITY_HIGH=10000; 
    109 const ICQUALITY_DEFAULT=-1; 
    110 const VIDCF_QUALITY=0x01; 
    111 const VIDCF_CRUNCH=0x02; 
    112 const VIDCF_TEMPORAL=0x04; 
    113 const VIDCF_COMPRESSFRAMES=0x08; 
    114 const VIDCF_DRAW=0x10; 
    115 const VIDCF_FASTTEMPORALC=0x20; 
    116 const VIDCF_FASTTEMPORALD=0x80; 
    117 const VIDCF_QUALITYTIME=0x40; 
    118 const VIDCF_FASTTEMPORAL=(VIDCF_FASTTEMPORALC|VIDCF_FASTTEMPORALD); 
    119 const ICMF_ABOUT_QUERY=0x01; 
    120 const ICDECOMPRESS_HURRYUP=0x80000000; 
    121 const ICDECOMPRESS_UPDATE=0x40000000; 
    122 const ICDECOMPRESS_PREROLL=0x20000000; 
    123 const ICDECOMPRESS_NULLFRAME=0x10000000; 
    124 const ICDECOMPRESS_NOTKEYFRAME=0x8000000; 
    125 const ICDRAW_QUERY=0x01L; 
    126 const ICDRAW_FULLSCREEN=0x02L; 
    127 const ICDRAW_HDC=0x04L; 
    128 const ICDRAW_ANIMATE=0x08L; 
    129 const ICDRAW_CONTINUE=0x10L; 
    130 const ICDRAW_MEMORYDC=0x20L; 
    131 const ICDRAW_UPDATING=0x40L; 
    132 const ICDRAW_RENDER=0x80L; 
    133 const ICDRAW_BUFFER=0x100L; 
    134 const ICINSTALL_UNICODE=0x8000; 
    135 const ICINSTALL_FUNCTION=0x01; 
    136 const ICINSTALL_DRIVER=0x02; 
    137 const ICINSTALL_HDRV=0x04; 
    138 const ICINSTALL_DRIVERW=0x8002; 
    139 const ICDRAW_HURRYUP=0x80000000L; 
    140 const ICDRAW_UPDATE=0x40000000L; 
    141 const ICDRAW_PREROLL=0x20000000L; 
    142 const ICDRAW_NULLFRAME=0x10000000L; 
    143 const ICDRAW_NOTKEYFRAME=0x8000000L; 
    144 const ICMF_COMPVARS_VALID=0x01; 
    145 const ICMF_CHOOSE_KEYFRAME=0x01; 
    146 const ICMF_CHOOSE_DATARATE=0x02; 
    147 const ICMF_CHOOSE_PREVIEW=0x04; 
    148 const ICMF_CHOOSE_ALLCOMPRESSORS=0x08; 
    149 const ICTYPE_VIDEO=mmioFOURCC!('v','i','d','c'); 
    150 const ICTYPE_AUDIO=mmioFOURCC!('a','u','d','c'); 
    151 const formtypeAVI=mmioFOURCC!('A','V','I',' '); 
    152 const listtypeAVIHEADER=mmioFOURCC!('h','d','r','l'); 
    153 const ckidAVIMAINHDR=mmioFOURCC!('a','v','i','h'); 
    154 const listtypeSTREAMHEADER=mmioFOURCC!('s','t','r','l'); 
    155 const ckidSTREAMHEADER=mmioFOURCC!('s','t','r','h'); 
    156 const ckidSTREAMFORMAT=mmioFOURCC!('s','t','r','f'); 
    157 const ckidSTREAMHANDLERDATA=mmioFOURCC!('s','t','r','d'); 
    158 const ckidSTREAMNAME=mmioFOURCC!('s','t','r','n'); 
    159 const listtypeAVIMOVIE=mmioFOURCC!('m','o','v','i'); 
    160 const listtypeAVIRECORD=mmioFOURCC!('r','e','c',' '); 
    161 const ckidAVINEWINDEX=mmioFOURCC!('i', 'd', 'x', '1'); 
    162 const streamtypeANY=0UL; 
    163 const streamtypeVIDEO=mmioFOURCC!('v','i','d','s'); 
    164 const streamtypeAUDIO=mmioFOURCC!('a','u','d','s'); 
    165 const streamtypeMIDI=mmioFOURCC!('m','i','d','s'); 
    166 const streamtypeTEXT=mmioFOURCC!('t','x','t','s'); 
    167 const cktypeDIBbits=aviTWOCC!('d','b'); 
    168 const cktypeDIBcompressed=aviTWOCC!('d','c'); 
    169 const cktypePALchange=aviTWOCC!('p','c'); 
    170 const cktypeWAVEbytes=aviTWOCC!('w','b'); 
    171 const ckidAVIPADDING=mmioFOURCC!('J','U','N','K'); 
    172 //MACRO #define FromHex(n) (((n)>='A')?((n)+10-'A'):((n)-'0')) 
    173  
    174 //MACRO #define StreamFromFOURCC(fcc) ((WORD)((FromHex(LOBYTE(LOWORD(fcc)))<<4)+(FromHex(HIBYTE(LOWORD(fcc)))))) 
    175  
    176 //MACRO #define TWOCCFromFOURCC(fcc) HIWORD(fcc) 
    177  
    178 //MACRO #define ToHex(n) ((BYTE)(((n)>9)?((n)-10+'A'):((n)+'0'))) 
    179  
    180 //MACRO #define MAKEAVICKID(tcc, stream) MAKELONG((ToHex((stream)&0x0f)<<8)|(ToHex(((stream)&0xf0)>>4)),tcc) 
    181  
    182 const AVIF_HASINDEX=0x10; 
    183 const AVIF_MUSTUSEINDEX=0x20; 
    184 const AVIF_ISINTERLEAVED=0x100; 
    185 const AVIF_TRUSTCKTYPE=0x800; 
    186 const AVIF_WASCAPTUREFILE=0x10000; 
    187 const AVIF_COPYRIGHTED=0x20000; 
    188 const AVI_HEADERSIZE=2048; 
    189 const AVISF_DISABLED=0x01; 
    190 const AVISF_VIDEO_PALCHANGES=0x10000; 
    191 const AVIIF_LIST=0x01; 
    192 const AVIIF_TWOCC=0x02; 
    193 const AVIIF_KEYFRAME=0x10; 
    194 const AVIIF_NOTIME=0x100; 
    195 const AVIIF_COMPUSE=0xfff0000; 
    196  
    197 const AVIGETFRAMEF_BESTDISPLAYFMT=1; 
    198 const AVISTREAMINFO_DISABLED=0x01; 
    199 const AVISTREAMINFO_FORMATCHANGES=0x10000; 
    200 const AVIFILEINFO_HASINDEX=0x10; 
    201 const AVIFILEINFO_MUSTUSEINDEX=0x20; 
    202 const AVIFILEINFO_ISINTERLEAVED=0x100; 
    203 const AVIFILEINFO_TRUSTCKTYPE=0x800; 
    204 const AVIFILEINFO_WASCAPTUREFILE=0x10000; 
    205 const AVIFILEINFO_COPYRIGHTED=0x20000; 
    206 const AVIFILECAPS_CANREAD=0x01; 
    207 const AVIFILECAPS_CANWRITE=0x02; 
    208 const AVIFILECAPS_ALLKEYFRAMES=0x10; 
    209 const AVIFILECAPS_NOCOMPRESSION=0x20; 
    210 const AVICOMPRESSF_INTERLEAVE=0x01; 
    211 const AVICOMPRESSF_DATARATE=0x02; 
    212 const AVICOMPRESSF_KEYFRAMES=0x04; 
    213 const AVICOMPRESSF_VALID=0x08; 
    214  
    215 const FIND_DIR=0x0000000fL; 
    216 const FIND_NEXT=0x00000001L; 
    217 const FIND_PREV=0x00000004L; 
    218 const FIND_FROM_START=0x00000008L; 
    219 const FIND_TYPE=0x000000f0L; 
    220 const FIND_KEY=0x00000010L; 
    221 const FIND_ANY=0x00000020L; 
    222 const FIND_FORMAT=0x00000040L; 
    223 const FIND_RET=0x0000f000L; 
    224 const FIND_POS=0x00000000L; 
    225 const FIND_LENGTH=0x00001000L; 
    226 const FIND_OFFSET=0x00002000L; 
    227 const FIND_SIZE=0x00003000L; 
    228 const FIND_INDEX=0x00004000L; 
    229 const AVIERR_OK=0; 
    230 //MACRO #define MAKE_AVIERR(e)  MAKE_SCODE(SEVERITY_ERROR,FACILITY_ITF,0x4000+e) 
    231  
    232 const AVIERR_UNSUPPORTED=MAKE_AVIERR(101); 
    233 const AVIERR_BADFORMAT=MAKE_AVIERR(102); 
    234 const AVIERR_MEMORY=MAKE_AVIERR(103); 
    235 const AVIERR_INTERNAL=MAKE_AVIERR(104); 
    236 const AVIERR_BADFLAGS=MAKE_AVIERR(105); 
    237 const AVIERR_BADPARAM=MAKE_AVIERR(106); 
    238 const AVIERR_BADSIZE=MAKE_AVIERR(107); 
    239 const AVIERR_BADHANDLE=MAKE_AVIERR(108); 
    240 const AVIERR_FILEREAD=MAKE_AVIERR(109); 
    241 const AVIERR_FILEWRITE=MAKE_AVIERR(110); 
    242 const AVIERR_FILEOPEN=MAKE_AVIERR(111); 
    243 const AVIERR_COMPRESSOR=MAKE_AVIERR(112); 
    244 const AVIERR_NOCOMPRESSOR=MAKE_AVIERR(113); 
    245 const AVIERR_READONLY=MAKE_AVIERR(114); 
    246 const AVIERR_NODATA=MAKE_AVIERR(115); 
    247 const AVIERR_BUFFERTOOSMALL=MAKE_AVIERR(116); 
    248 const AVIERR_CANTCOMPRESS=MAKE_AVIERR(117); 
    249 const AVIERR_USERABORT=MAKE_AVIERR(198); 
    250 const AVIERR_ERROR=MAKE_AVIERR(199); 
    251 const MCIWNDOPENF_NEW=0x0001; 
    252 const MCIWNDF_NOAUTOSIZEWINDOW=0x0001; 
    253 const MCIWNDF_NOPLAYBAR=0x0002; 
    254 const MCIWNDF_NOAUTOSIZEMOVIE=0x0004; 
    255 const MCIWNDF_NOMENU=0x0008; 
    256 const MCIWNDF_SHOWNAME=0x0010; 
    257 const MCIWNDF_SHOWPOS=0x0020; 
    258 const MCIWNDF_SHOWMODE=0x0040; 
    259 const MCIWNDF_SHOWALL=0x0070; 
    260 const MCIWNDF_NOTIFYMODE=0x0100; 
    261 const MCIWNDF_NOTIFYPOS=0x0200; 
    262 const MCIWNDF_NOTIFYSIZE=0x0400; 
    263 const MCIWNDF_NOTIFYERROR=0x1000; 
    264 const MCIWNDF_NOTIFYALL=0x1F00; 
    265 const MCIWNDF_NOTIFYANSI=0x0080; 
    266 const MCIWNDF_NOTIFYMEDIAA=0x0880; 
    267 const MCIWNDF_NOTIFYMEDIAW=0x0800; 
    268 const MCIWNDF_RECORD=0x2000; 
    269 const MCIWNDF_NOERRORDLG=0x4000; 
    270 const MCIWNDF_NOOPEN=0x8000; 
    271 const MCIWNDM_GETDEVICEID=(WM_USER + 100); 
    272 const MCIWNDM_GETSTART=(WM_USER + 103); 
    273 const MCIWNDM_GETLENGTH=(WM_USER + 104); 
    274 const MCIWNDM_GETEND=(WM_USER + 105); 
    275 const MCIWNDM_EJECT=(WM_USER + 107); 
    276 const MCIWNDM_SETZOOM=(WM_USER + 108); 
    277 const MCIWNDM_GETZOOM=(WM_USER + 109); 
    278 const MCIWNDM_SETVOLUME=(WM_USER + 110); 
    279 const MCIWNDM_GETVOLUME=(WM_USER + 111); 
    280 const MCIWNDM_SETSPEED=(WM_USER + 112); 
    281 const MCIWNDM_GETSPEED=(WM_USER + 113); 
    282 const MCIWNDM_SETREPEAT=(WM_USER + 114); 
    283 const MCIWNDM_GETREPEAT=(WM_USER + 115); 
    284 const MCIWNDM_REALIZE=(WM_USER + 118); 
    285 const MCIWNDM_VALIDATEMEDIA=(WM_USER + 121); 
    286 const MCIWNDM_PLAYFROM=(WM_USER + 122); 
    287 const MCIWNDM_PLAYTO=(WM_USER + 123); 
    288 const MCIWNDM_GETPALETTE=(WM_USER + 126); 
    289 const MCIWNDM_SETPALETTE=(WM_USER + 127); 
    290 const MCIWNDM_SETTIMERS=(WM_USER + 129); 
    291 const MCIWNDM_SETACTIVETIMER=(WM_USER + 130); 
    292 const MCIWNDM_SETINACTIVETIMER=(WM_USER + 131); 
    293 const MCIWNDM_GETACTIVETIMER=(WM_USER + 132); 
    294 const MCIWNDM_GETINACTIVETIMER=(WM_USER + 133); 
    295 const MCIWNDM_CHANGESTYLES=(WM_USER + 135); 
    296 const MCIWNDM_GETSTYLES=(WM_USER + 136); 
    297 const MCIWNDM_GETALIAS=(WM_USER + 137); 
    298 const MCIWNDM_PLAYREVERSE=(WM_USER + 139); 
    299 const MCIWNDM_GET_SOURCE=(WM_USER + 140); 
    300 const MCIWNDM_PUT_SOURCE=(WM_USER + 141); 
    301 const MCIWNDM_GET_DEST=(WM_USER + 142); 
    302 const MCIWNDM_PUT_DEST=(WM_USER + 143); 
    303 const MCIWNDM_CAN_PLAY=(WM_USER + 144); 
    304 const MCIWNDM_CAN_WINDOW=(WM_USER + 145); 
    305 const MCIWNDM_CAN_RECORD=(WM_USER + 146); 
    306 const MCIWNDM_CAN_SAVE=(WM_USER + 147); 
    307 const MCIWNDM_CAN_EJECT=(WM_USER + 148); 
    308 const MCIWNDM_CAN_CONFIG=(WM_USER + 149); 
    309 const MCIWNDM_PALETTEKICK=(WM_USER + 150); 
    310 const MCIWNDM_OPENINTERFACE=(WM_USER + 151); 
    311 const MCIWNDM_SETOWNER=(WM_USER + 152); 
    312 const MCIWNDM_SENDSTRINGA=(WM_USER + 101); 
    313 const MCIWNDM_GETPOSITIONA=(WM_USER + 102); 
    314 const MCIWNDM_GETMODEA=(WM_USER + 106); 
    315 const MCIWNDM_SETTIMEFORMATA=(WM_USER + 119); 
    316 const MCIWNDM_GETTIMEFORMATA=(WM_USER + 120); 
    317 const MCIWNDM_GETFILENAMEA=(WM_USER + 124); 
    318 const MCIWNDM_GETDEVICEA=(WM_USER + 125); 
    319 const MCIWNDM_GETERRORA=(WM_USER + 128); 
    320 const MCIWNDM_NEWA=(WM_USER + 134); 
    321 const MCIWNDM_RETURNSTRINGA=(WM_USER + 138); 
    322 const MCIWNDM_OPENA=(WM_USER + 153); 
    323 const MCIWNDM_SENDSTRINGW=(WM_USER + 201); 
    324 const MCIWNDM_GETPOSITIONW=(WM_USER + 202); 
    325 const MCIWNDM_GETMODEW=(WM_USER + 206); 
    326 const MCIWNDM_SETTIMEFORMATW=(WM_USER + 219); 
    327 const MCIWNDM_GETTIMEFORMATW=(WM_USER + 220); 
    328 const MCIWNDM_GETFILENAMEW=(WM_USER + 224); 
    329 const MCIWNDM_GETDEVICEW=(WM_USER + 225); 
    330 const MCIWNDM_GETERRORW=(WM_USER + 228); 
    331 const MCIWNDM_NEWW=(WM_USER + 234); 
    332 const MCIWNDM_RETURNSTRINGW=(WM_USER + 238); 
    333 const MCIWNDM_OPENW=(WM_USER + 252); 
    334 const MCIWNDM_NOTIFYMODE=(WM_USER + 200); 
    335 const MCIWNDM_NOTIFYPOS=(WM_USER + 201); 
    336 const MCIWNDM_NOTIFYSIZE=(WM_USER + 202); 
    337 const MCIWNDM_NOTIFYMEDIA=(WM_USER + 203); 
    338 const MCIWNDM_NOTIFYERROR=(WM_USER + 205); 
    339 const MCIWND_START=-1; 
    340 const MCIWND_END=-2; 
    341 const DDF_UPDATE=0x02; 
    342 const DDF_SAME_HDC=0x04; 
    343 const DDF_SAME_DRAW=0x08; 
    344 const DDF_DONTDRAW=0x10; 
    345 const DDF_ANIMATE=0x20; 
    346 const DDF_BUFFER=0x40; 
    347 const DDF_JUSTDRAWIT=0x80; 
    348 const DDF_FULLSCREEN=0x100; 
    349 const DDF_BACKGROUNDPAL=0x200; 
    350 const DDF_NOTKEYFRAME=0x400; 
    351 const DDF_HURRYUP=0x800; 
    352 const DDF_HALFTONE=0x1000; 
    353 const DDF_PREROLL=DDF_DONTDRAW; 
    354 const DDF_SAME_DIB=DDF_SAME_DRAW; 
    355 const DDF_SAME_SIZE=DDF_SAME_DRAW; 
    356 const PD_CAN_DRAW_DIB=0x01; 
    357 const PD_CAN_STRETCHDIB=0x02; 
    358 const PD_STRETCHDIB_1_1_OK=0x04; 
    359 const PD_STRETCHDIB_1_2_OK=0x08; 
    360 const PD_STRETCHDIB_1_N_OK=0x10; 
    361  
    362 alias HANDLE HIC; 
    363 alias HANDLE HDRAWDIB; 
    364 alias WORD TWOCC; 
    365  
    366 extern (Windows): 
    367 alias BOOL function (INT) AVISAVECALLBACK; 
     13private import 
     14    win32.commdlg, 
     15    win32.wingdi, 
     16    win32.mmsystem, 
     17    win32.unknwn, 
     18    win32.w32api, 
     19    win32.windef, 
     20    win32.winuser; 
     21 
     22extern(Windows) { 
     23    DWORD VideoForWindowsVersion(); 
     24    LONG InitVFW(); 
     25    LONG TermVFW(); 
     26} 
     27 
     28DWORD MKFOURCC(char ch0, char ch1, char ch2, char ch3) { 
     29    return (cast(DWORD)ch0) | ((cast(DWORD)ch1) << 8) | ((cast(DWORD)ch2) << 16) | ((cast(DWORD)ch3) << 24); 
     30} 
     31 
     32/** 
     33 * COMPMAN - Installable Compression Manager. 
     34 */ 
     35 
     36const ICVERSION = 0x0104; 
     37 
     38typedef HANDLE HIC; 
     39 
     40const BI_1632 = 0x32333631; 
     41 
     42template aviTWOCC(char c0, char c1) { 
     43    const WORD aviTWOCC = c0 | (c1 << 8); 
     44} 
     45 
     46const ICTYPE_VIDEO  = mmioFOURCC!('v', 'i', 'd', 'c'); 
     47const ICTYPE_AUDIO  = mmioFOURCC!('a', 'u', 'd', 'c'); 
     48 
     49enum { 
     50    ICERR_OK            = 0, 
     51    ICERR_DONTDRAW      = 1, 
     52    ICERR_NEWPALETTE    = 2, 
     53    ICERR_GOTOKEYFRAME  = 3, 
     54    ICERR_STOPDRAWING   = 4, 
     55} 
     56 
     57const ICERR_UNSUPPORTED = -1; 
     58const ICERR_BADFORMAT   = -2; 
     59const ICERR_MEMORY      = -3; 
     60const ICERR_INTERNAL    = -4; 
     61const ICERR_BADFLAGS    = -5; 
     62const ICERR_BADPARAM    = -6; 
     63const ICERR_BADSIZE     = -7; 
     64const ICERR_BADHANDLE   = -8; 
     65const ICERR_CANTUPDATE  = -9; 
     66const ICERR_ABORT       = -10; 
     67const ICERR_ERROR       = -100; 
     68const ICERR_BADBITDEPTH = -200; 
     69const ICERR_BADIMAGESIZE = -201; 
     70 
     71const ICERR_CUSTOM = -400; 
     72 
     73enum { 
     74    ICMODE_COMPRESS         = 1, 
     75    ICMODE_DECOMPRESS, 
     76    ICMODE_FASTDECOMPRESS, 
     77    ICMODE_QUERY, 
     78    ICMODE_FASTCOMPRESS, 
     79    ICMODE_DRAW             = 8, 
     80} 
     81 
     82const ICMODE_INTERNALF_FUNCTION32   = 0x8000; 
     83const ICMODE_INTERNALF_MASK         = 0x8000; 
     84 
     85enum { 
     86    AVIIF_LIST      = 0x00000001, 
     87    AVIIF_TWOCC     = 0x00000002, 
     88    AVIIF_KEYFRAME  = 0x00000010, 
     89} 
     90 
     91const ICQUALITY_LOW     = 0; 
     92const ICQUALITY_HIGH    = 10000; 
     93const ICQUALITY_DEFAULT = -1; 
     94 
     95enum { 
     96    ICM_USER            = DRV_USER + 0x0000, 
     97    ICM_RESERVED_LOW    = DRV_USER + 0x1000, 
     98    ICM_RESERVED_HIGH   = DRV_USER + 0x2000, 
     99    ICM_RESERVED        = ICM_RESERVED_LOW, 
     100} 
     101 
     102// messages 
     103 
     104enum { 
     105    ICM_GETSTATE            = ICM_RESERVED + 0, 
     106    ICM_SETSTATE            = ICM_RESERVED + 1, 
     107    ICM_GETINFO             = ICM_RESERVED + 2, 
     108    ICM_CONFIGURE           = ICM_RESERVED + 10, 
     109    ICM_ABOUT               = ICM_RESERVED + 11, 
     110    ICM_GETERRORTEXT        = ICM_RESERVED + 12, 
     111    ICM_GETFORMATNAME       = ICM_RESERVED + 20, 
     112    ICM_ENUMFORMATS         = ICM_RESERVED + 21, 
     113    ICM_GETDEFAULTQUALITY   = ICM_RESERVED + 30, 
     114    ICM_GETQUALITY          = ICM_RESERVED + 31, 
     115    ICM_SETQUALITY          = ICM_RESERVED + 32, 
     116    ICM_SET                 = ICM_RESERVED + 40, 
     117    ICM_GET                 = ICM_RESERVED + 41, 
     118} 
     119 
     120const ICM_FRAMERATE     = mmioFOURCC!('F','r','m','R'); 
     121const ICM_KEYFRAMERATE  = mmioFOURCC!('K','e','y','R'); 
     122 
     123// ICM specific messages. 
     124 
     125enum { 
     126    ICM_COMPRESS_GET_FORMAT     = ICM_USER + 4, 
     127    ICM_COMPRESS_GET_SIZE       = ICM_USER + 5, 
     128    ICM_COMPRESS_QUERY          = ICM_USER + 6, 
     129    ICM_COMPRESS_BEGIN          = ICM_USER + 7, 
     130    ICM_COMPRESS                = ICM_USER + 8, 
     131    ICM_COMPRESS_END            = ICM_USER + 9, 
     132    ICM_DECOMPRESS_GET_FORMAT   = ICM_USER + 10, 
     133    ICM_DECOMPRESS_QUERY        = ICM_USER + 11, 
     134    ICM_DECOMPRESS_BEGIN        = ICM_USER + 12, 
     135    ICM_DECOMPRESS              = ICM_USER + 13, 
     136    ICM_DECOMPRESS_END          = ICM_USER + 14, 
     137    ICM_DECOMPRESS_SET_PALETTE  = ICM_USER + 29, 
     138    ICM_DECOMPRESS_GET_PALETTE  = ICM_USER + 30, 
     139    ICM_DRAW_QUERY              = ICM_USER + 31, 
     140    ICM_DRAW_BEGIN              = ICM_USER + 15, 
     141    ICM_DRAW_GET_PALETTE        = ICM_USER + 16, 
     142    ICM_DRAW_UPDATE             = ICM_USER + 17, 
     143    ICM_DRAW_START              = ICM_USER + 18, 
     144    ICM_DRAW_STOP               = ICM_USER + 19, 
     145    ICM_DRAW_BITS               = ICM_USER + 20, 
     146    ICM_DRAW_END                = ICM_USER + 21, 
     147    ICM_DRAW_GETTIME            = ICM_USER + 32, 
     148    ICM_DRAW                    = ICM_USER + 33, 
     149    ICM_DRAW_WINDOW             = ICM_USER + 34, 
     150    ICM_DRAW_SETTIME            = ICM_USER + 35, 
     151    ICM_DRAW_REALIZE            = ICM_USER + 36, 
     152    ICM_DRAW_FLUSH              = ICM_USER + 37, 
     153    ICM_DRAW_RENDERBUFFER       = ICM_USER + 38, 
     154    ICM_DRAW_START_PLAY         = ICM_USER + 39, 
     155    ICM_DRAW_STOP_PLAY          = ICM_USER + 40, 
     156    ICM_DRAW_SUGGESTFORMAT      = ICM_USER + 50, 
     157    ICM_DRAW_CHANGEPALETTE      = ICM_USER + 51, 
     158    ICM_DRAW_IDLE               = ICM_USER + 52, 
     159    ICM_GETBUFFERSWANTED        = ICM_USER + 41, 
     160    ICM_GETDEFAULTKEYFRAMERATE  = ICM_USER + 42, 
     161    ICM_DECOMPRESSEX_BEGIN      = ICM_USER + 60, 
     162    ICM_DECOMPRESSEX_QUERY      = ICM_USER + 61, 
     163    ICM_DECOMPRESSEX            = ICM_USER + 62, 
     164    ICM_DECOMPRESSEX_END        = ICM_USER + 63, 
     165    ICM_COMPRESS_FRAMES_INFO    = ICM_USER + 70, 
     166    ICM_COMPRESS_FRAMES         = ICM_USER + 71, 
     167    ICM_SET_STATUS_PROC         = ICM_USER + 72, 
     168} 
     169 
    368170struct ICOPEN { 
    369     DWORD dwSize; 
    370     DWORD fccType; 
    371     DWORD fccHandler; 
    372     DWORD dwVersion; 
    373     DWORD dwFlags; 
    374     LRESULT dwError; 
    375     LPVOID pV1Reserved; 
    376     LPVOID pV2Reserved; 
    377     DWORD dnDevNode; 
    378 } 
    379 alias ICOPEN* LPICOPEN; 
     171    DWORD   dwSize; 
     172    DWORD   fccType; 
     173    DWORD   fccHandler; 
     174    DWORD   dwVersion; 
     175    DWORD   dwFlags; 
     176    LRESULT dwError; 
     177    LPVOID  pV1Reserved; 
     178    LPVOID  pV2Reserved; 
     179    DWORD   dnDevNode; 
     180} 
     181 
     182struct ICINFO { 
     183    DWORD   dwSize; 
     184    DWORD   fccType; 
     185    DWORD   fccHandler; 
     186    DWORD   dwFlags; 
     187    DWORD   dwVersion; 
     188    DWORD   dwVersionICM; 
     189    WCHAR   szName[16]; 
     190    WCHAR   szDescription[128]; 
     191    WCHAR   szDriver[128]; 
     192} 
     193 
     194enum { 
     195    VIDCF_QUALITY           = 0x0001, 
     196    VIDCF_CRUNCH            = 0x0002, 
     197    VIDCF_TEMPORAL          = 0x0004, 
     198    VIDCF_COMPRESSFRAMES    = 0x0008, 
     199    VIDCF_DRAW              = 0x0010, 
     200    VIDCF_FASTTEMPORALC     = 0x0020, 
     201    VIDCF_FASTTEMPORALD     = 0x0080, 
     202} 
     203 
     204const ICCOMPRESS_KEYFRAME = 0x00000001L; 
    380205 
    381206struct ICCOMPRESS { 
    382     DWORD dwFlags; 
    383     LPBITMAPINFOHEADER lpbiOutput; 
    384     LPVOID lpOutput; 
    385     LPBITMAPINFOHEADER lpbiInput; 
    386     LPVOID lpInput; 
    387     LPDWORD lpckid; 
    388     LPDWORD lpdwFlags; 
    389     LONG lFrameNum; 
    390     DWORD dwFrameSize; 
    391     DWORD dwQuality; 
    392     LPBITMAPINFOHEADER lpbiPrev; 
    393     LPVOID lpPrev; 
    394 } 
     207    DWORD               dwFlags; 
     208    LPBITMAPINFOHEADER  lpbiOutput; 
     209    LPVOID              lpOutput; 
     210    LPBITMAPINFOHEADER  lpbiInput; 
     211    LPVOID              lpInput; 
     212    LPDWORD             lpckid; 
     213    LPDWORD             lpdwFlags; 
     214    LONG                lFrameNum; 
     215    DWORD               dwFrameSize; 
     216    DWORD               dwQuality; 
     217    LPBITMAPINFOHEADER  lpbiPrev; 
     218    LPVOID              lpPrev; 
     219} 
     220 
     221const ICCOMPRESSFRAMES_PADDING = 0x00000001; 
    395222 
    396223struct ICCOMPRESSFRAMES { 
    397     DWORD dwFlags; 
    398     LPBITMAPINFOHEADER lpbiOutput; 
    399     LPARAM lOutput; 
    400     LPBITMAPINFOHEADER lpbiInput; 
    401     LPARAM lInput; 
    402     LONG lStartFrame; 
    403     LONG lFrameCount; 
    404     LONG lQuality; 
    405     LONG lDataRate; 
    406     LONG lKeyRate; 
    407     DWORD dwRate; 
    408     DWORD dwScale; 
    409     DWORD dwOverheadPerFrame; 
    410     DWORD dwReserved2; 
    411     LONG function (LPARAM,LONG,LPVOID,LONG) GetData; 
    412     LONG function (LPARAM,LONG,LPVOID,LONG) PutData; 
     224    DWORD               dwFlags; 
     225    LPBITMAPINFOHEADER  lpbiOutput; 
     226    LPARAM              lOutput; 
     227    LPBITMAPINFOHEADER  lpbiInput; 
     228    LPARAM              lInput; 
     229    LONG                lStartFrame; 
     230    LONG                lFrameCount; 
     231    LONG                lQuality; 
     232    LONG                lDataRate; 
     233    LONG                lKeyRate; 
     234    DWORD               dwRate; 
     235    DWORD               dwScale;    DWORD       dwOverheadPerFrame; 
     236    DWORD               dwReserved2; 
     237 
     238    LONG function(LPARAM lInput, LONG lFrame, LPVOID lpBits, LONG len) GetData; 
     239    LONG function(LPARAM lOutput, LONG lFrame, LPVOID lpBits, LONG len) PutData; 
     240} 
     241 
     242enum { 
     243    ICSTATUS_START  = 0, 
     244    ICSTATUS_STATUS = 1, 
     245    ICSTATUS_END    = 2, 
     246    ICSTATUS_ERROR  = 3, 
     247    ICSTATUS_YIELD  = 4, 
    413248} 
    414249 
    415250struct ICSETSTATUSPROC { 
    416     DWORD dwFlags; 
    417     LPARAM lParam; 
    418     LONG function(LPARAM,UINT,LONG) Status; 
    419 } 
    420  
    421 struct ICINFO { 
    422     DWORD dwSize; 
    423     DWORD fccType; 
    424     DWORD fccHandler; 
    425     DWORD dwFlags; 
    426     DWORD dwVersion; 
    427     DWORD dwVersionICM; 
    428     WCHAR szName[16]; 
    429     WCHAR szDescription[128]; 
    430     WCHAR szDriver[128]; 
     251    DWORD   dwFlags; 
     252    LPARAM  lParam; 
     253    LONG function(LPARAM lParam, UINT message, LONG l) Status; 
     254} 
     255 
     256enum { 
     257    ICDECOMPRESS_NOTKEYFRAME    = 0x08000000, 
     258    ICDECOMPRESS_NULLFRAME      = 0x10000000, 
     259    ICDECOMPRESS_PREROLL        = 0x20000000, 
     260    ICDECOMPRESS_UPDATE         = 0x40000000, 
     261    ICDECOMPRESS_HURRYUP        = 0x80000000, 
    431262} 
    432263 
    433264struct ICDECOMPRESS { 
    434     DWORD dwFlags; 
    435     LPBITMAPINFOHEADER lpbiInput; 
    436     LPVOID lpInput; 
    437     LPBITMAPINFOHEADER lpbiOutput; 
    438     LPVOID lpOutput; 
    439     DWORD ckid; 
     265    DWORD              dwFlags; 
     266    LPBITMAPINFOHEADER lpbiInput; 
     267    LPVOID             lpInput; 
     268    LPBITMAPINFOHEADER lpbiOutput; 
     269    LPVOID             lpOutput; 
     270    DWORD              ckid; 
    440271} 
    441272 
    442273struct ICDECOMPRESSEX { 
    443     DWORD dwFlags; 
    444     LPBITMAPINFOHEADER lpbiSrc; 
    445     LPVOID lpSrc; 
    446     LPBITMAPINFOHEADER lpbiDst; 
    447     LPVOID lpDst; 
    448     INT xDst; 
    449     INT yDst; 
    450     INT dxDst; 
    451     INT dyDst; 
    452     INT xSrc; 
    453     INT ySrc; 
    454     INT dxSrc; 
    455     INT dySrc; 
     274    DWORD               dwFlags; 
     275    LPBITMAPINFOHEADER  lpbiSrc; 
     276    LPVOID              lpSrc; 
     277    LPBITMAPINFOHEADER  lpbiDst; 
     278    LPVOID              lpDst; 
     279    int                 xDst; 
     280    int                 yDst; 
     281    int                 dxDst; 
     282    int                 dyDst; 
     283    int                 xSrc; 
     284    int                 ySrc; 
     285    int                 dxSrc; 
     286    int                 dySrc; 
     287} 
     288 
     289enum { 
     290    ICDRAW_QUERY        = 0x00000001, 
     291    ICDRAW_FULLSCREEN   = 0x00000002, 
     292    ICDRAW_HDC          = 0x00000004, 
     293    ICDRAW_ANIMATE      = 0x00000008, 
     294    ICDRAW_CONTINUE     = 0x00000010, 
     295    ICDRAW_MEMORYDC     = 0x00000020, 
     296    ICDRAW_UPDATING     = 0x00000040, 
     297    ICDRAW_RENDER       = 0x00000080, 
     298    ICDRAW_BUFFER       = 0x00000100, 
     299} 
     300 
     301struct ICDRAWBEGIN { 
     302    DWORD               dwFlags; 
     303    HPALETTE            hpal; 
     304    HWND                hwnd; 
     305    HDC                 hdc; 
     306    int                 xDst; 
     307    int                 yDst; 
     308    int                 dxDst; 
     309    int                 dyDst; 
     310    LPBITMAPINFOHEADER  lpbi; 
     311    int                 xSrc; 
     312    int                 ySrc; 
     313    int                 dxSrc; 
     314    int                 dySrc; 
     315    DWORD               dwRate; 
     316    DWORD               dwScale; 
     317} 
     318 
     319enum { 
     320    ICDRAW_HURRYUP      = 0x80000000, 
     321    ICDRAW_UPDATE       = 0x40000000, 
     322    ICDRAW_PREROLL      = 0x20000000, 
     323    ICDRAW_NULLFRAME    = 0x10000000, 
     324    ICDRAW_NOTKEYFRAME  = 0x08000000, 
     325} 
     326 
     327struct ICDRAW { 
     328    DWORD           dwFlags; 
     329    LPVOID          lpFormat; 
     330    LPVOID          lpData; 
     331    DWORD           cbData; 
     332    LONG            lTime; 
    456333} 
    457334 
    458335struct ICDRAWSUGGEST { 
    459     DWORD dwFlags; 
    460     LPBITMAPINFOHEADER lpbiIn; 
    461     LPBITMAPINFOHEADER lpbiSuggest; 
    462     INT dxSrc; 
    463     INT dySrc; 
    464     INT dxDst; 
    465     INT dyDst; 
    466     HIC hicDecompressor; 
     336    LPBITMAPINFOHEADER  lpbiIn; 
     337    LPBITMAPINFOHEADER  lpbiSuggest; 
     338    int                 dxSrc; 
     339    int                 dySrc; 
     340    int                 dxDst; 
     341    int                 dyDst; 
     342    HIC                 hicDecompressor; 
    467343} 
    468344 
    469345struct ICPALETTE { 
    470     DWORD dwFlags; 
    471     INT iStart; 
    472     INT iLen; 
    473     LPPALETTEENTRY lppe; 
    474 } 
    475  
    476 struct ICDRAWBEGIN { 
    477     DWORD dwFlags; 
    478     HPALETTE hpal; 
    479     HWND hwnd; 
    480     HDC hdc; 
    481     INT xDst; 
    482     INT yDst; 
    483     INT dxDst; 
    484     INT dyDst; 
    485     LPBITMAPINFOHEADER lpbi; 
    486     INT xSrc; 
    487     INT ySrc; 
    488     INT dxSrc; 
    489     INT dySrc; 
    490     DWORD dwRate; 
    491     DWORD dwScale; 
    492 } 
    493  
    494 struct ICDRAW { 
    495     DWORD dwFlags; 
    496     LPVOID lpFormat; 
    497     LPVOID lpData; 
    498     DWORD cbData; 
    499     LONG lTime; 
    500 } 
    501  
    502 struct COMPVARS { 
    503     LONG cbSize; 
    504     DWORD dwFlags; 
    505     HIC hic; 
    506     DWORD fccType; 
    507     DWORD fccHandler; 
    508     LPBITMAPINFO lpbiIn; 
    509     LPBITMAPINFO lpbiOut; 
    510     LPVOID lpBitsOut; 
    511     LPVOID lpBitsPrev; 
    512     LONG lFrame; 
    513     LONG lKey; 
    514     LONG lDataRate; 
    515     LONG lQ; 
    516     LONG lKeyCount; 
    517     LPVOID lpState; 
    518     LONG cbState; 
    519 } 
    520 alias COMPVARS* PCOMPVARS; 
    521  
    522 struct MainAVIHeader 
     346    DWORD           dwFlags; 
     347    int             iStart; 
     348    int             iLen; 
     349    LPPALETTEENTRY  lppe; 
     350} 
     351 
     352 
     353/** 
     354 * ICM function declarations 
     355 */ 
     356 
     357BOOL ICInfo(DWORD fccType, DWORD fccHandler, ICINFO *lpicinfo); 
     358BOOL ICInstall(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR szDesc, UINT wFlags); 
     359BOOL ICRemove(DWORD fccType, DWORD fccHandler, UINT wFlags); 
     360LRESULT ICGetInfo(HIC hic, ICINFO *picinfo, DWORD cb); 
     361HIC ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode); 
     362HIC ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler); 
     363LRESULT ICClose(HIC hic); 
     364LRESULT ICSendMessage(HIC hic, UINT msg, DWORD_PTR dw1, DWORD_PTR dw2); 
     365 
     366enum { 
     367    ICINSTALL_FUNCTION  = 0x0001, 
     368    ICINSTALL_DRIVER    = 0x0002, 
     369    ICINSTALL_HDRV      = 0x0004, 
     370    ICINSTALL_UNICODE   = 0x8000, 
     371    ICINSTALL_DRIVERW   = 0x8002, 
     372} 
     373 
     374// query macros 
     375 
     376const ICMF_CONFIGURE_QUERY  = 0x00000001; 
     377const ICMF_ABOUT_QUERY      = 0x00000001; 
     378 
     379DWORD ICQueryAbout(HIC hic) { 
     380    return ICSendMessage(hic, ICM_ABOUT, -1, ICMF_ABOUT_QUERY) == ICERR_OK; 
     381} 
     382 
     383DWORD ICAbout(HIC hic, HWND hwnd) { 
     384    return ICSendMessage(hic, ICM_ABOUT, cast(UINT)hwnd, 0); 
     385} 
     386 
     387DWORD ICQueryConfigure(HIC hic) { 
     388    return (ICSendMessage(hic, ICM_CONFIGURE, -1, ICMF_CONFIGURE_QUERY) == ICERR_OK); 
     389} 
     390 
     391DWORD ICConfigure(HIC hic, HWND hwnd) { 
     392    return ICSendMessage(hic, ICM_CONFIGURE, cast(UINT)hwnd, 0); 
     393} 
     394 
     395DWORD ICGetState(HIC hic, LPVOID pv, DWORD_PTR cb) { 
     396    return ICSendMessage(hic, ICM_GETSTATE, cast(DWORD)pv, cast(DWORD)cb); 
     397} 
     398 
     399DWORD ICSetState(HIC hic, LPVOID pv, DWORD_PTR cb) { 
     400    return ICSendMessage(hic, ICM_SETSTATE, cast(DWORD)pv, cast(DWORD)cb); 
     401} 
     402 
     403DWORD ICGetStateSize(HIC hic) { 
     404    return ICGetState(hic, null, 0); 
     405} 
     406 
     407/+ TODO: 
     408static DWORD dwICValue; 
     409 
     410#define ICGetDefaultQuality(hic)    (ICSendMessage(hic, ICM_GETDEFAULTQUALITY, (DWORD_PTR)(LPVOID)&dwICValue, sizeof(DWORD)), dwICValue) 
     411 
     412#define ICGetDefaultKeyFrameRate(hic)    (ICSendMessage(hic, ICM_GETDEFAULTKEYFRAMERATE, (DWORD_PTR)(LPVOID)&dwICValue, sizeof(DWORD)), dwICValue) 
     413+/ 
     414 
     415DWORD ICDrawWindow(HIC hic, LPVOID prc) { 
     416    return ICSendMessage(hic, ICM_DRAW_WINDOW, cast(DWORD)prc, RECT.sizeof); 
     417} 
     418 
     419DWORD ICCompress(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiOutput, LPVOID lpData, LPBITMAPINFOHEADER lpbiInput, LPVOID lpBits, LPDWORD lpckid, LPDWORD lpdwFlags, LONG lFrameNum, DWORD dwFrameSize, DWORD dwQuality, LPBITMAPINFOHEADER lpbiPrev, LPVOID lpPrev); 
     420 
     421/+ TODO: 
     422#define ICCompressBegin(hic, lpbiInput, lpbiOutput)    ICSendMessage(hic, ICM_COMPRESS_BEGIN, (DWORD_PTR)(LPVOID)(lpbiInput), (DWORD_PTR)(LPVOID)(lpbiOutput)) 
     423#define ICCompressQuery(hic, lpbiInput, lpbiOutput)    ICSendMessage(hic, ICM_COMPRESS_QUERY, (DWORD_PTR)(LPVOID)(lpbiInput), (DWORD_PTR)(LPVOID)(lpbiOutput)) 
     424#define ICCompressGetFormat(hic, lpbiInput, lpbiOutput)    ICSendMessage(hic, ICM_COMPRESS_GET_FORMAT, (DWORD_PTR)(LPVOID)(lpbiInput), (DWORD_PTR)(LPVOID)(lpbiOutput)) 
     425#define ICCompressGetFormatSize(hic, lpbi)    (DWORD) ICCompressGetFormat(hic, lpbi, NULL) 
     426#define ICCompressGetSize(hic, lpbiInput, lpbiOutput)    (DWORD) ICSendMessage(hic, ICM_COMPRESS_GET_SIZE, (DWORD_PTR)(LPVOID)(lpbiInput), (DWORD_PTR)(LPVOID)(lpbiOutput)) 
     427#define ICCompressEnd(hic)    ICSendMessage(hic, ICM_COMPRESS_END, 0, 0) 
     428#define ICDECOMPRESS_HURRYUP    0x80000000L 
     429DWORD 
     430ICDecompress( 
     431    IN  HIC                 hic, 
     432    IN  DWORD               dwFlags, 
     433    IN  LPBITMAPINFOHEADER  lpbiFormat, 
     434    IN  LPVOID              lpData, 
     435    IN  LPBITMAPINFOHEADER  lpbi, 
     436    OUT LPVOID              lpBits 
     437    ); 
     438 
     439#define ICDecompressBegin(hic, lpbiInput, lpbiOutput)    ICSendMessage(hic, ICM_DECOMPRESS_BEGIN, (DWORD_PTR)(LPVOID)(lpbiInput), (DWORD_PTR)(LPVOID)(lpbiOutput)) 
     440#define ICDecompressQuery(hic, lpbiInput, lpbiOutput)    ICSendMessage(hic, ICM_DECOMPRESS_QUERY, (DWORD_PTR)(LPVOID)(lpbiInput), (DWORD_PTR)(LPVOID)(lpbiOutput)) 
     441#define ICDecompressGetFormat(hic, lpbiInput, lpbiOutput)    ((LONG) ICSendMessage(hic, ICM_DECOMPRESS_GET_FORMAT, (DWORD_PTR)(LPVOID)(lpbiInput), (DWORD_PTR)(LPVOID)(lpbiOutput))) 
     442 
     443#define ICDecompressGetFormatSize(hic, lpbi)    ICDecompressGetFormat(hic, lpbi, NULL) 
     444#define ICDecompressGetPalette(hic, lpbiInput, lpbiOutput)    ICSendMessage(hic, ICM_DECOMPRESS_GET_PALETTE, (DWORD_PTR)(LPVOID)(lpbiInput), (DWORD_PTR)(LPVOID)(lpbiOutput)) 
     445 
     446#define ICDecompressSetPalette(hic, lpbiPalette)    ICSendMessage(hic, ICM_DECOMPRESS_SET_PALETTE, (DWORD_PTR)(LPVOID)(lpbiPalette), 0) 
     447 
     448#define ICDecompressEnd(hic)    ICSendMessage(hic, ICM_DECOMPRESS_END, 0, 0) 
     449 
     450static __inline LRESULT VFWAPI_INLINE 
     451ICDecompressEx( 
     452            HIC hic, 
     453            DWORD dwFlags, 
     454            LPBITMAPINFOHEADER lpbiSrc, 
     455            LPVOID lpSrc, 
     456            int xSrc, 
     457            int ySrc, 
     458            int dxSrc, 
     459            int dySrc, 
     460            LPBITMAPINFOHEADER lpbiDst, 
     461            LPVOID lpDst, 
     462            int xDst, 
     463            int yDst, 
     464            int dxDst, 
     465            int dyDst) 
    523466{ 
    524     DWORD dwMicroSecPerFrame; 
    525     DWORD dwMaxBytesPerSec; 
    526     DWORD dwPaddingGranularity; 
    527     DWORD dwFlags; 
    528     DWORD dwTotalFrames; 
    529     DWORD dwInitialFrames; 
    530     DWORD dwStreams; 
    531     DWORD dwSuggestedBufferSize; 
    532     DWORD dwWidth; 
    533     DWORD dwHeight; 
    534     DWORD dwReserved[4]; 
    535 } 
    536  
    537 struct AVIStreamHeader { 
    538     FOURCC fccType; 
    539     FOURCC fccHandler; 
    540     DWORD dwFlags; 
    541     WORD wPriority; 
    542     WORD wLanguage; 
    543     DWORD dwInitialFrames; 
    544     DWORD dwScale; 
    545     DWORD dwRate; 
    546     DWORD dwStart; 
    547     DWORD dwLength; 
    548     DWORD dwSuggestedBufferSize; 
    549     DWORD dwQuality; 
    550     DWORD dwSampleSize; 
    551     RECT rcFrame; 
    552 } 
    553  
    554 struct AVIINDEXENTRY{ 
    555     DWORD ckid; 
    556     DWORD dwFlags; 
    557     DWORD dwChunkOffset; 
    558     DWORD dwChunkLength; 
    559 } 
    560  
    561 struct AVIPALCHANGE{ 
    562     BYTE bFirstEntry; 
    563     BYTE bNumEntries; 
    564     WORD wFlags; 
    565     PALETTEENTRY peNew[1]; 
    566 } 
    567  
    568 struct AVISTREAMINFOA{ 
    569     DWORD fccType; 
    570     DWORD fccHandler; 
    571     DWORD dwFlags; 
    572     DWORD dwCaps; 
    573     WORD wPriority; 
    574     WORD wLanguage; 
    575     DWORD dwScale; 
    576     DWORD dwRate; 
    577     DWORD dwStart; 
    578     DWORD dwLength; 
    579     DWORD dwInitialFrames; 
    580     DWORD dwSuggestedBufferSize; 
    581     DWORD dwQuality; 
    582     DWORD dwSampleSize; 
    583     RECT rcFrame; 
    584     DWORD dwEditCount; 
    585     DWORD dwFormatChangeCount; 
    586     CHAR szName[64]; 
    587 } 
    588 alias AVISTREAMINFOA* LPAVISTREAMINFOA, PAVISTREAMINFOA; 
    589  
    590 struct AVISTREAMINFOW{ 
    591     DWORD fccType; 
    592     DWORD fccHandler; 
    593     DWORD dwFlags; 
    594     DWORD dwCaps; 
    595     WORD wPriority; 
    596     WORD wLanguage; 
    597     DWORD dwScale; 
    598     DWORD dwRate; 
    599     DWORD dwStart; 
    600     DWORD dwLength; 
    601     DWORD dwInitialFrames; 
    602     DWORD dwSuggestedBufferSize; 
    603     DWORD dwQuality; 
    604     DWORD dwSampleSize; 
    605     RECT rcFrame; 
    606     DWORD dwEditCount; 
    607     DWORD dwFormatChangeCount; 
    608     WCHAR szName[64]; 
    609 } 
    610 alias AVISTREAMINFOW* LPAVISTREAMINFOW, PAVISTREAMINFOW; 
    611  
    612 struct AVIFILEINFOW{ 
    613     DWORD dwMaxBytesPerSec; 
    614     DWORD dwFlags; 
    615     DWORD dwCaps; 
    616     DWORD dwStreams; 
    617     DWORD dwSuggestedBufferSize; 
    618     DWORD dwWidth; 
    619     DWORD dwHeight; 
    620     DWORD dwScale; 
    621     DWORD dwRate; 
    622     DWORD dwLength; 
    623     DWORD dwEditCount; 
    624     WCHAR szFileType[64]; 
    625 } 
    626 alias AVIFILEINFOW* LPAVIFILEINFOW, PAVIFILEINFOW; 
    627  
    628 struct AVIFILEINFOA{ 
    629     DWORD dwMaxBytesPerSec; 
    630     DWORD dwFlags; 
    631     DWORD dwCaps; 
    632     DWORD dwStreams; 
    633     DWORD dwSuggestedBufferSize; 
    634     DWORD dwWidth; 
    635     DWORD dwHeight; 
    636     DWORD dwScale; 
    637     DWORD dwRate; 
    638     DWORD dwLength; 
    639     DWORD dwEditCount; 
    640     CHAR szFileType[64]; 
    641 } 
    642 alias AVIFILEINFOA* LPAVIFILEINFOA, PAVIFILEINFOA; 
    643  
    644 struct AVICOMPRESSOPTIONS{ 
    645     DWORD fccType; 
    646     DWORD fccHandler; 
    647     DWORD dwKeyFrameEvery; 
    648     DWORD dwQuality; 
    649     DWORD dwBytesPerSecond; 
    650     DWORD dwFlags; 
    651     LPVOID lpFormat; 
    652     DWORD cbFormat; 
    653     LPVOID lpParms; 
    654     DWORD cbParms; 
    655     DWORD dwInterleaveEvery; 
    656 } 
    657 alias AVICOMPRESSOPTIONS* LPAVICOMPRESSOPTIONS, PAVICOMPRESSOPTIONS; 
    658  
    659 //[???] #if !defined (__OBJC__) 
    660 //MACRO #define DEFINE_AVIGUID(name,l,w1,w2) DEFINE_GUID(name,l,w1,w2,0xC0,0,0,0,0,0,0,0x46) 
    661  
    662 DEFINE_AVIGUID(IID_IAVIFile,0x00020020,0,0); 
    663 DEFINE_AVIGUID(IID_IAVIStream,0x00020021,0,0); 
    664 DEFINE_AVIGUID(IID_IAVIStreaming,0x00020022,0,0); 
    665 DEFINE_AVIGUID(IID_IGetFrame,0x00020023,0,0); 
    666 DEFINE_AVIGUID(IID_IAVIEditStream,0x00020024,0,0); 
    667 DEFINE_AVIGUID(CLSID_AVIFile,0x00020000,0,0); 
    668  
    669 interface IAVIStream : public IUnknown 
     467    ICDECOMPRESSEX ic; 
     468 
     469    ic.dwFlags = dwFlags; 
     470    ic.lpbiSrc = lpbiSrc; 
     471    ic.lpSrc = lpSrc; 
     472    ic.xSrc = xSrc; 
     473    ic.ySrc = ySrc; 
     474    ic.dxSrc = dxSrc; 
     475    ic.dySrc = dySrc; 
     476    ic.lpbiDst = lpbiDst; 
     477    ic.lpDst = lpDst; 
     478    ic.xDst = xDst; 
     479    ic.yDst = yDst; 
     480    ic.dxDst = dxDst; 
     481    ic.dyDst = dyDst; 
     482 
     483    return ICSendMessage(hic, ICM_DECOMPRESSEX, (DWORD_PTR)&ic, sizeof(ic)); 
     484} 
     485 
     486static __inline LRESULT VFWAPI_INLINE 
     487ICDecompressExBegin( 
     488            HIC hic, 
     489            DWORD dwFlags, 
     490            LPBITMAPINFOHEADER lpbiSrc, 
     491            LPVOID lpSrc, 
     492            int xSrc, 
     493            int ySrc, 
     494            int dxSrc, 
     495            int dySrc, 
     496            LPBITMAPINFOHEADER lpbiDst, 
     497            LPVOID lpDst, 
     498            int xDst, 
     499            int yDst, 
     500            int dxDst, 
     501            int dyDst) 
    670502{ 
    671     HRESULT QueryInterface(REFIID,PVOID*); 
    672     ULONG AddRef(); 
    673     ULONG Release(); 
    674     HRESULT Create(LPARAM,LPARAM); 
    675     HRESULT Info(AVISTREAMINFOW*,LONG); 
    676     LONG FindSample(LONG,LONG); 
    677     HRESULT ReadFormat(LONG,LPVOID,LONG*); 
    678     HRESULT SetFormat(LONG,LPVOID,LONG); 
    679     HRESULT Read(LONG,LONG,LPVOID,LONG,LONG*,LONG*); 
    680     HRESULT Write(LONG,LONG,LPVOID,LONG,DWORD,LONG*,LONG*); 
    681     HRESULT Delete(LONG,LONG); 
    682     HRESULT ReadData(DWORD,LPVOID,LONG*); 
    683     HRESULT WriteData(DWORD,LPVOID,LONG); 
    684     HRESULT SetInfo(AVISTREAMINFOW*,LONG); 
    685 } 
    686 alias IAVIStream *PAVISTREAM; 
    687  
    688 interface IAVIStreaming : public IUnknown 
     503    ICDECOMPRESSEX ic; 
     504 
     505    ic.dwFlags = dwFlags; 
     506    ic.lpbiSrc = lpbiSrc; 
     507    ic.lpSrc = lpSrc; 
     508    ic.xSrc = xSrc; 
     509    ic.ySrc = ySrc; 
     510    ic.dxSrc = dxSrc; 
     511    ic.dySrc = dySrc; 
     512    ic.lpbiDst = lpbiDst; 
     513    ic.lpDst = lpDst; 
     514    ic.xDst = xDst; 
     515    ic.yDst = yDst; 
     516    ic.dxDst = dxDst; 
     517    ic.dyDst = dyDst; 
     518 
     519    return ICSendMessage(hic, ICM_DECOMPRESSEX_BEGIN, (DWORD_PTR)&ic, sizeof(ic)); 
     520} 
     521 
     522static __inline LRESULT VFWAPI_INLINE 
     523ICDecompressExQuery( 
     524            HIC hic, 
     525            DWORD dwFlags, 
     526            LPBITMAPINFOHEADER lpbiSrc, 
     527            LPVOID lpSrc, 
     528            int xSrc, 
     529            int ySrc, 
     530            int dxSrc, 
     531            int dySrc, 
     532            LPBITMAPINFOHEADER lpbiDst, 
     533            LPVOID lpDst, 
     534            int xDst, 
     535            int yDst, 
     536            int dxDst, 
     537            int dyDst) 
    689538{ 
    690     HRESULT QueryInterface(REFIID,PVOID*); 
    691     ULONG AddRef(); 
    692     ULONG Release(); 
    693     HRESULT Begin(LONG,LONG,LONG); 
    694     HRESULT End(); 
    695 } 
    696 alias IAVIStreaming *PAVISTREAMING; 
    697  
    698 interface IAVIEditStream : public IUnknown 
     539    ICDECOMPRESSEX ic; 
     540 
     541    ic.dwFlags = dwFlags; 
     542    ic.lpbiSrc = lpbiSrc; 
     543    ic.lpSrc = lpSrc; 
     544    ic.xSrc = xSrc; 
     545    ic.ySrc = ySrc; 
     546    ic.dxSrc = dxSrc; 
     547    ic.dyS