1 /** 2 Windows API header module 3 4 License: $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) 5 Source: $(DRUNTIMESRC core/sys/windows/_vfw.d) 6 */ 7 module nulib.system.win32.vfw; 8 import nulib.system.win32.commdlg; 9 import nulib.system.win32.wingdi; 10 import nulib.system.win32.mmsystem; 11 import nulib.system.win32.w32api; 12 import nulib.system.win32.windef; 13 import nulib.system.win32.winuser; 14 import nulib.system.com; 15 pragma(lib, "vfw32"); 16 17 version (ANSI) {} else version = Unicode; 18 19 extern(Windows) { 20 DWORD VideoForWindowsVersion(); 21 LONG InitVFW(); 22 LONG TermVFW(); 23 } 24 25 DWORD MKFOURCC(char ch0, char ch1, char ch2, char ch3) { 26 return (cast(DWORD)ch0) | ((cast(DWORD)ch1) << 8) | ((cast(DWORD)ch2) << 16) | ((cast(DWORD)ch3) << 24); 27 } 28 29 /** 30 * COMPMAN - Installable Compression Manager. 31 */ 32 33 enum ICVERSION = 0x0104; 34 35 alias HIC = HANDLE; 36 37 enum BI_1632 = 0x32333631; 38 39 template aviTWOCC(char c0, char c1) { 40 enum WORD aviTWOCC = c0 | (c1 << 8); 41 } 42 43 enum ICTYPE_VIDEO = mmioFOURCC!('v', 'i', 'd', 'c'); 44 enum ICTYPE_AUDIO = mmioFOURCC!('a', 'u', 'd', 'c'); 45 46 enum { 47 ICERR_OK = 0, 48 ICERR_DONTDRAW = 1, 49 ICERR_NEWPALETTE = 2, 50 ICERR_GOTOKEYFRAME = 3, 51 ICERR_STOPDRAWING = 4, 52 } 53 54 enum ICERR_UNSUPPORTED = -1; 55 enum ICERR_BADFORMAT = -2; 56 enum ICERR_MEMORY = -3; 57 enum ICERR_INTERNAL = -4; 58 enum ICERR_BADFLAGS = -5; 59 enum ICERR_BADPARAM = -6; 60 enum ICERR_BADSIZE = -7; 61 enum ICERR_BADHANDLE = -8; 62 enum ICERR_CANTUPDATE = -9; 63 enum ICERR_ABORT = -10; 64 enum ICERR_ERROR = -100; 65 enum ICERR_BADBITDEPTH = -200; 66 enum ICERR_BADIMAGESIZE = -201; 67 68 enum ICERR_CUSTOM = -400; 69 70 enum { 71 ICMODE_COMPRESS = 1, 72 ICMODE_DECOMPRESS, 73 ICMODE_FASTDECOMPRESS, 74 ICMODE_QUERY, 75 ICMODE_FASTCOMPRESS, 76 ICMODE_DRAW = 8, 77 } 78 79 enum ICMODE_INTERNALF_FUNCTION32 = 0x8000; 80 enum ICMODE_INTERNALF_MASK = 0x8000; 81 82 enum { 83 AVIIF_LIST = 0x00000001, 84 AVIIF_TWOCC = 0x00000002, 85 AVIIF_KEYFRAME = 0x00000010, 86 } 87 88 enum ICQUALITY_LOW = 0; 89 enum ICQUALITY_HIGH = 10000; 90 enum ICQUALITY_DEFAULT = -1; 91 92 enum { 93 ICM_USER = DRV_USER + 0x0000, 94 ICM_RESERVED_LOW = DRV_USER + 0x1000, 95 ICM_RESERVED_HIGH = DRV_USER + 0x2000, 96 ICM_RESERVED = ICM_RESERVED_LOW, 97 } 98 99 // messages 100 101 enum { 102 ICM_GETSTATE = ICM_RESERVED + 0, 103 ICM_SETSTATE = ICM_RESERVED + 1, 104 ICM_GETINFO = ICM_RESERVED + 2, 105 ICM_CONFIGURE = ICM_RESERVED + 10, 106 ICM_ABOUT = ICM_RESERVED + 11, 107 ICM_GETERRORTEXT = ICM_RESERVED + 12, 108 ICM_GETFORMATNAME = ICM_RESERVED + 20, 109 ICM_ENUMFORMATS = ICM_RESERVED + 21, 110 ICM_GETDEFAULTQUALITY = ICM_RESERVED + 30, 111 ICM_GETQUALITY = ICM_RESERVED + 31, 112 ICM_SETQUALITY = ICM_RESERVED + 32, 113 ICM_SET = ICM_RESERVED + 40, 114 ICM_GET = ICM_RESERVED + 41, 115 } 116 117 enum ICM_FRAMERATE = mmioFOURCC!('F','r','m','R'); 118 enum ICM_KEYFRAMERATE = mmioFOURCC!('K','e','y','R'); 119 120 // ICM specific messages. 121 122 enum { 123 ICM_COMPRESS_GET_FORMAT = ICM_USER + 4, 124 ICM_COMPRESS_GET_SIZE = ICM_USER + 5, 125 ICM_COMPRESS_QUERY = ICM_USER + 6, 126 ICM_COMPRESS_BEGIN = ICM_USER + 7, 127 ICM_COMPRESS = ICM_USER + 8, 128 ICM_COMPRESS_END = ICM_USER + 9, 129 ICM_DECOMPRESS_GET_FORMAT = ICM_USER + 10, 130 ICM_DECOMPRESS_QUERY = ICM_USER + 11, 131 ICM_DECOMPRESS_BEGIN = ICM_USER + 12, 132 ICM_DECOMPRESS = ICM_USER + 13, 133 ICM_DECOMPRESS_END = ICM_USER + 14, 134 ICM_DECOMPRESS_SET_PALETTE = ICM_USER + 29, 135 ICM_DECOMPRESS_GET_PALETTE = ICM_USER + 30, 136 ICM_DRAW_QUERY = ICM_USER + 31, 137 ICM_DRAW_BEGIN = ICM_USER + 15, 138 ICM_DRAW_GET_PALETTE = ICM_USER + 16, 139 ICM_DRAW_UPDATE = ICM_USER + 17, 140 ICM_DRAW_START = ICM_USER + 18, 141 ICM_DRAW_STOP = ICM_USER + 19, 142 ICM_DRAW_BITS = ICM_USER + 20, 143 ICM_DRAW_END = ICM_USER + 21, 144 ICM_DRAW_GETTIME = ICM_USER + 32, 145 ICM_DRAW = ICM_USER + 33, 146 ICM_DRAW_WINDOW = ICM_USER + 34, 147 ICM_DRAW_SETTIME = ICM_USER + 35, 148 ICM_DRAW_REALIZE = ICM_USER + 36, 149 ICM_DRAW_FLUSH = ICM_USER + 37, 150 ICM_DRAW_RENDERBUFFER = ICM_USER + 38, 151 ICM_DRAW_START_PLAY = ICM_USER + 39, 152 ICM_DRAW_STOP_PLAY = ICM_USER + 40, 153 ICM_DRAW_SUGGESTFORMAT = ICM_USER + 50, 154 ICM_DRAW_CHANGEPALETTE = ICM_USER + 51, 155 ICM_DRAW_IDLE = ICM_USER + 52, 156 ICM_GETBUFFERSWANTED = ICM_USER + 41, 157 ICM_GETDEFAULTKEYFRAMERATE = ICM_USER + 42, 158 ICM_DECOMPRESSEX_BEGIN = ICM_USER + 60, 159 ICM_DECOMPRESSEX_QUERY = ICM_USER + 61, 160 ICM_DECOMPRESSEX = ICM_USER + 62, 161 ICM_DECOMPRESSEX_END = ICM_USER + 63, 162 ICM_COMPRESS_FRAMES_INFO = ICM_USER + 70, 163 ICM_COMPRESS_FRAMES = ICM_USER + 71, 164 ICM_SET_STATUS_PROC = ICM_USER + 72, 165 } 166 167 struct ICOPEN { 168 DWORD dwSize; 169 DWORD fccType; 170 DWORD fccHandler; 171 DWORD dwVersion; 172 DWORD dwFlags; 173 LRESULT dwError; 174 LPVOID pV1Reserved; 175 LPVOID pV2Reserved; 176 DWORD dnDevNode; 177 } 178 179 struct ICINFO { 180 DWORD dwSize; 181 DWORD fccType; 182 DWORD fccHandler; 183 DWORD dwFlags; 184 DWORD dwVersion; 185 DWORD dwVersionICM; 186 WCHAR[16] szName = 0; 187 WCHAR[128] szDescription = 0; 188 WCHAR[128] szDriver = 0; 189 } 190 191 enum { 192 VIDCF_QUALITY = 0x0001, 193 VIDCF_CRUNCH = 0x0002, 194 VIDCF_TEMPORAL = 0x0004, 195 VIDCF_COMPRESSFRAMES = 0x0008, 196 VIDCF_DRAW = 0x0010, 197 VIDCF_FASTTEMPORALC = 0x0020, 198 VIDCF_FASTTEMPORALD = 0x0080, 199 } 200 201 enum ICCOMPRESS_KEYFRAME = 0x00000001L; 202 203 struct ICCOMPRESS { 204 DWORD dwFlags; 205 LPBITMAPINFOHEADER lpbiOutput; 206 LPVOID lpOutput; 207 LPBITMAPINFOHEADER lpbiInput; 208 LPVOID lpInput; 209 LPDWORD lpckid; 210 LPDWORD lpdwFlags; 211 LONG lFrameNum; 212 DWORD dwFrameSize; 213 DWORD dwQuality; 214 LPBITMAPINFOHEADER lpbiPrev; 215 LPVOID lpPrev; 216 } 217 218 enum ICCOMPRESSFRAMES_PADDING = 0x00000001; 219 220 struct ICCOMPRESSFRAMES { 221 DWORD dwFlags; 222 LPBITMAPINFOHEADER lpbiOutput; 223 LPARAM lOutput; 224 LPBITMAPINFOHEADER lpbiInput; 225 LPARAM lInput; 226 LONG lStartFrame; 227 LONG lFrameCount; 228 LONG lQuality; 229 LONG lDataRate; 230 LONG lKeyRate; 231 DWORD dwRate; 232 DWORD dwScale; DWORD dwOverheadPerFrame; 233 DWORD dwReserved2; 234 extern (Windows): 235 LONG function(LPARAM lInput, LONG lFrame, LPVOID lpBits, LONG len) GetData; 236 LONG function(LPARAM lOutput, LONG lFrame, LPVOID lpBits, LONG len) PutData; 237 } 238 239 enum { 240 ICSTATUS_START = 0, 241 ICSTATUS_STATUS = 1, 242 ICSTATUS_END = 2, 243 ICSTATUS_ERROR = 3, 244 ICSTATUS_YIELD = 4, 245 } 246 247 struct ICSETSTATUSPROC { 248 DWORD dwFlags; 249 LPARAM lParam; 250 extern (Windows) 251 LONG function(LPARAM lParam, UINT message, LONG l) Status; 252 } 253 254 enum { 255 ICDECOMPRESS_NOTKEYFRAME = 0x08000000, 256 ICDECOMPRESS_NULLFRAME = 0x10000000, 257 ICDECOMPRESS_PREROLL = 0x20000000, 258 ICDECOMPRESS_UPDATE = 0x40000000, 259 ICDECOMPRESS_HURRYUP = 0x80000000, 260 } 261 262 struct ICDECOMPRESS { 263 DWORD dwFlags; 264 LPBITMAPINFOHEADER lpbiInput; 265 LPVOID lpInput; 266 LPBITMAPINFOHEADER lpbiOutput; 267 LPVOID lpOutput; 268 DWORD ckid; 269 } 270 271 struct ICDECOMPRESSEX { 272 DWORD dwFlags; 273 LPBITMAPINFOHEADER lpbiSrc; 274 LPVOID lpSrc; 275 LPBITMAPINFOHEADER lpbiDst; 276 LPVOID lpDst; 277 int xDst; 278 int yDst; 279 int dxDst; 280 int dyDst; 281 int xSrc; 282 int ySrc; 283 int dxSrc; 284 int dySrc; 285 } 286 287 enum { 288 ICDRAW_QUERY = 0x00000001, 289 ICDRAW_FULLSCREEN = 0x00000002, 290 ICDRAW_HDC = 0x00000004, 291 ICDRAW_ANIMATE = 0x00000008, 292 ICDRAW_CONTINUE = 0x00000010, 293 ICDRAW_MEMORYDC = 0x00000020, 294 ICDRAW_UPDATING = 0x00000040, 295 ICDRAW_RENDER = 0x00000080, 296 ICDRAW_BUFFER = 0x00000100, 297 } 298 299 struct ICDRAWBEGIN { 300 DWORD dwFlags; 301 HPALETTE hpal; 302 HWND hwnd; 303 HDC hdc; 304 int xDst; 305 int yDst; 306 int dxDst; 307 int dyDst; 308 LPBITMAPINFOHEADER lpbi; 309 int xSrc; 310 int ySrc; 311 int dxSrc; 312 int dySrc; 313 DWORD dwRate; 314 DWORD dwScale; 315 } 316 317 enum { 318 ICDRAW_NOTKEYFRAME = 0x08000000, 319 ICDRAW_NULLFRAME = 0x10000000, 320 ICDRAW_PREROLL = 0x20000000, 321 ICDRAW_UPDATE = 0x40000000, 322 ICDRAW_HURRYUP = 0x80000000, 323 } 324 325 struct ICDRAW { 326 DWORD dwFlags; 327 LPVOID lpFormat; 328 LPVOID lpData; 329 DWORD cbData; 330 LONG lTime; 331 } 332 333 struct ICDRAWSUGGEST { 334 LPBITMAPINFOHEADER lpbiIn; 335 LPBITMAPINFOHEADER lpbiSuggest; 336 int dxSrc; 337 int dySrc; 338 int dxDst; 339 int dyDst; 340 HIC hicDecompressor; 341 } 342 343 struct ICPALETTE { 344 DWORD dwFlags; 345 int iStart; 346 int iLen; 347 LPPALETTEENTRY lppe; 348 } 349 350 351 /** 352 * ICM function declarations 353 */ 354 355 extern (Windows) { 356 BOOL ICInfo(DWORD fccType, DWORD fccHandler, ICINFO *lpicinfo); 357 BOOL ICInstall(DWORD fccType, DWORD fccHandler, LPARAM lParam, LPSTR szDesc, UINT wFlags); 358 BOOL ICRemove(DWORD fccType, DWORD fccHandler, UINT wFlags); 359 LRESULT ICGetInfo(HIC hic, ICINFO *picinfo, DWORD cb); 360 HIC ICOpen(DWORD fccType, DWORD fccHandler, UINT wMode); 361 HIC ICOpenFunction(DWORD fccType, DWORD fccHandler, UINT wMode, FARPROC lpfnHandler); 362 LRESULT ICClose(HIC hic); 363 LRESULT ICSendMessage(HIC hic, UINT msg, DWORD_PTR dw1, DWORD_PTR dw2); 364 } 365 366 enum { 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 376 enum ICMF_CONFIGURE_QUERY = 0x00000001; 377 enum ICMF_ABOUT_QUERY = 0x00000001; 378 379 DWORD ICQueryAbout(HIC hic) { 380 return ICSendMessage(hic, ICM_ABOUT, -1, ICMF_ABOUT_QUERY) == ICERR_OK; 381 } 382 383 DWORD ICAbout(HIC hic, HWND hwnd) { 384 return cast(DWORD) ICSendMessage(hic, ICM_ABOUT, cast(DWORD_PTR) cast(UINT_PTR) hwnd, 0); 385 } 386 387 DWORD ICQueryConfigure(HIC hic) { 388 return (ICSendMessage(hic, ICM_CONFIGURE, -1, ICMF_CONFIGURE_QUERY) == ICERR_OK); 389 } 390 391 DWORD ICConfigure(HIC hic, HWND hwnd) { 392 return cast(DWORD) ICSendMessage(hic, ICM_CONFIGURE, cast(DWORD_PTR) cast(UINT_PTR) hwnd, 0); 393 } 394 395 DWORD ICGetState(HIC hic, LPVOID pv, DWORD_PTR cb) { 396 return cast(DWORD) ICSendMessage(hic, ICM_GETSTATE, cast(DWORD_PTR) pv, cb); 397 } 398 399 DWORD ICSetState(HIC hic, LPVOID pv, DWORD_PTR cb) { 400 return cast(DWORD) ICSendMessage(hic, ICM_SETSTATE, cast(DWORD_PTR) pv, cb); 401 } 402 403 DWORD ICGetStateSize(HIC hic) { 404 return ICGetState(hic, null, 0); 405 } 406 407 DWORD dwICValue; 408 409 DWORD ICGetDefaultQuality(HIC hic) { 410 ICSendMessage(hic, ICM_GETDEFAULTQUALITY, cast(DWORD_PTR)&dwICValue, DWORD.sizeof); 411 return dwICValue; 412 } 413 414 DWORD ICGetDefaultKeyFrameRate(HIC hic) { 415 ICSendMessage(hic, ICM_GETDEFAULTKEYFRAMERATE, cast(DWORD_PTR)&dwICValue, DWORD.sizeof); 416 return dwICValue; 417 } 418 419 DWORD ICDrawWindow(HIC hic, LPVOID prc) { 420 return cast(DWORD) ICSendMessage(hic, ICM_DRAW_WINDOW, cast(DWORD_PTR) prc, RECT.sizeof); 421 } 422 423 extern (Windows) { 424 DWORD ICCompress(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiOutput, LPVOID lpData, 425 LPBITMAPINFOHEADER lpbiInput, LPVOID lpBits, LPDWORD lpckid, LPDWORD lpdwFlags, 426 LONG lFrameNum, DWORD dwFrameSize, DWORD dwQuality, LPBITMAPINFOHEADER lpbiPrev, LPVOID lpPrev); 427 } 428 429 LRESULT ICCompressBegin(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) { 430 return ICSendMessage(hic, ICM_COMPRESS_BEGIN, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput); 431 } 432 LRESULT ICCompressQuery(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) { 433 return ICSendMessage(hic, ICM_COMPRESS_QUERY, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput); 434 } 435 LRESULT ICCompressGetFormat(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) { 436 return ICSendMessage(hic, ICM_COMPRESS_GET_FORMAT, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput); 437 } 438 DWORD ICCompressGetFormatSize(HIC hic, LPVOID lpbi) { 439 return cast(DWORD)ICCompressGetFormat(hic, lpbi, null); 440 } 441 DWORD ICCompressGetSize(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) { 442 return cast(DWORD)ICSendMessage(hic, ICM_COMPRESS_GET_SIZE, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput); 443 } 444 LRESULT ICCompressEnd(HIC hic) { 445 return ICSendMessage(hic, ICM_COMPRESS_END, 0, 0); 446 } 447 448 extern (Windows) { 449 DWORD ICDecompress(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiFormat, LPVOID lpData, LPBITMAPINFOHEADER lpbi, LPVOID lpBits); 450 } 451 452 LRESULT ICDecompressBegin(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) { 453 return ICSendMessage(hic, ICM_DECOMPRESS_BEGIN, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput); 454 } 455 LRESULT ICDecompressQuery(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) { 456 return ICSendMessage(hic, ICM_DECOMPRESS_QUERY, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput); 457 } 458 LONG ICDecompressGetFormat(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) { 459 return cast(LONG)ICSendMessage(hic, ICM_DECOMPRESS_GET_FORMAT, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput); 460 } 461 LONG ICDecompressGetFormatSize(HIC hic, LPVOID lpbi) { 462 return ICDecompressGetFormat(hic, lpbi, null); 463 } 464 LRESULT ICDecompressGetPalette(HIC hic, LPVOID lpbiInput, LPVOID lpbiOutput) { 465 return ICSendMessage(hic, ICM_DECOMPRESS_GET_PALETTE, cast(DWORD_PTR)lpbiInput, cast(DWORD_PTR)lpbiOutput); 466 } 467 LRESULT ICDecompressSetPalette(HIC hic, LPVOID lpbiPalette) { 468 return ICSendMessage(hic, ICM_DECOMPRESS_SET_PALETTE, cast(DWORD_PTR)lpbiPalette, 0); 469 } 470 LRESULT ICDecompressEnd(HIC hic) { 471 return ICSendMessage(hic, ICM_DECOMPRESS_END, 0, 0); 472 } 473 474 LRESULT ICDecompressEx(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiSrc, 475 LPVOID lpSrc, int xSrc, int ySrc, int dxSrc, int dySrc, LPBITMAPINFOHEADER lpbiDst, 476 LPVOID lpDst, int xDst, int yDst, int dxDst, int dyDst) { 477 ICDECOMPRESSEX ic; 478 479 ic.dwFlags = dwFlags; 480 ic.lpbiSrc = lpbiSrc; 481 ic.lpSrc = lpSrc; 482 ic.xSrc = xSrc; 483 ic.ySrc = ySrc; 484 ic.dxSrc = dxSrc; 485 ic.dySrc = dySrc; 486 ic.lpbiDst = lpbiDst; 487 ic.lpDst = lpDst; 488 ic.xDst = xDst; 489 ic.yDst = yDst; 490 ic.dxDst = dxDst; 491 ic.dyDst = dyDst; 492 493 return ICSendMessage(hic, ICM_DECOMPRESSEX, cast(DWORD_PTR)&ic, ic.sizeof); 494 } 495 496 LRESULT ICDecompressExBegin(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiSrc, 497 LPVOID lpSrc, int xSrc, int ySrc, int dxSrc, int dySrc, LPBITMAPINFOHEADER lpbiDst, 498 LPVOID lpDst, int xDst, int yDst, int dxDst, int dyDst) { 499 ICDECOMPRESSEX ic; 500 501 ic.dwFlags = dwFlags; 502 ic.lpbiSrc = lpbiSrc; 503 ic.lpSrc = lpSrc; 504 ic.xSrc = xSrc; 505 ic.ySrc = ySrc; 506 ic.dxSrc = dxSrc; 507 ic.dySrc = dySrc; 508 ic.lpbiDst = lpbiDst; 509 ic.lpDst = lpDst; 510 ic.xDst = xDst; 511 ic.yDst = yDst; 512 ic.dxDst = dxDst; 513 ic.dyDst = dyDst; 514 515 return ICSendMessage(hic, ICM_DECOMPRESSEX_BEGIN, cast(DWORD_PTR)&ic, ic.sizeof); 516 } 517 518 LRESULT ICDecompressExQuery(HIC hic, DWORD dwFlags, LPBITMAPINFOHEADER lpbiSrc, 519 LPVOID lpSrc, int xSrc, int ySrc, int dxSrc, int dySrc, LPBITMAPINFOHEADER lpbiDst, 520 LPVOID lpDst, int xDst, int yDst, int dxDst, int dyDst) { 521 ICDECOMPRESSEX ic; 522 523 ic.dwFlags = dwFlags; 524 ic.lpbiSrc = lpbiSrc; 525 ic.lpSrc = lpSrc; 526 ic.xSrc = xSrc; 527 ic.ySrc = ySrc; 528 ic.dxSrc = dxSrc; 529 ic.dySrc = dySrc; 530 ic.lpbiDst = lpbiDst; 531 ic.lpDst = lpDst; 532 ic.xDst = xDst; 533 ic.yDst = yDst; 534 ic.dxDst = dxDst; 535 ic.dyDst = dyDst; 536 537 return ICSendMessage(hic, ICM_DECOMPRESSEX_QUERY, cast(DWORD_PTR)&ic, ic.sizeof); 538 } 539 540 LRESULT ICDecompressExEnd(HIC hic) { 541 return ICSendMessage(hic, ICM_DECOMPRESSEX_END, 0, 0); 542 } 543 544 extern (Windows) { 545 DWORD ICDrawBegin(HIC hic, DWORD dwFlags, HPALETTE hpal, HWND hwnd, HDC hdc, 546 int xDst, int yDst, int dxDst, int dyDst, LPBITMAPINFOHEADER lpbi, 547 int xSrc, int ySrc, int dxSrc, int dySrc, DWORD dwRate, DWORD dwScale); 548 } 549 550 extern (Windows) { 551 DWORD ICDraw(HIC hic, DWORD dwFlags, LPVOID lpFormat, LPVOID lpData, DWORD cbData, LONG lTime); 552 } 553 554 LRESULT ICDrawSuggestFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, 555 int dxSrc, int dySrc, int dxDst, int dyDst, HIC hicDecomp) { 556 ICDRAWSUGGEST ic; 557 558 ic.lpbiIn = lpbiIn; 559 ic.lpbiSuggest = lpbiOut; 560 ic.dxSrc = dxSrc; 561 ic.dySrc = dySrc; 562 ic.dxDst = dxDst; 563 ic.dyDst = dyDst; 564 ic.hicDecompressor = hicDecomp; 565 566 return ICSendMessage(hic, ICM_DRAW_SUGGESTFORMAT, cast(DWORD_PTR)&ic, ic.sizeof); 567 } 568 569 LRESULT ICDrawQuery(HIC hic, LPVOID lpbiInput) { 570 return ICSendMessage(hic, ICM_DRAW_QUERY, cast(DWORD_PTR)lpbiInput, 0L); 571 } 572 LRESULT ICDrawChangePalette(HIC hic, LPVOID lpbiInput) { 573 return ICSendMessage(hic, ICM_DRAW_CHANGEPALETTE, cast(DWORD_PTR)lpbiInput, 0L); 574 } 575 LRESULT ICGetBuffersWanted(HIC hic, LPVOID lpdwBuffers) { 576 return ICSendMessage(hic, ICM_GETBUFFERSWANTED, cast(DWORD_PTR)lpdwBuffers, 0); 577 } 578 LRESULT ICDrawEnd(HIC hic) { 579 return ICSendMessage(hic, ICM_DRAW_END, 0, 0); 580 } 581 LRESULT ICDrawStart(HIC hic) { 582 return ICSendMessage(hic, ICM_DRAW_START, 0, 0); 583 } 584 LRESULT ICDrawStartPlay(HIC hic, DWORD lFrom, DWORD lTo) { 585 return ICSendMessage(hic, ICM_DRAW_START_PLAY, cast(DWORD_PTR)lFrom, cast(DWORD_PTR)lTo); 586 } 587 LRESULT ICDrawStop(HIC hic) { 588 return ICSendMessage(hic, ICM_DRAW_STOP, 0, 0); 589 } 590 LRESULT ICDrawStopPlay(HIC hic) { 591 return ICSendMessage(hic, ICM_DRAW_STOP_PLAY, 0, 0); 592 } 593 LRESULT ICDrawGetTime(HIC hic, LPVOID lplTime) { 594 return ICSendMessage(hic, ICM_DRAW_GETTIME, cast(DWORD_PTR)lplTime, 0); 595 } 596 LRESULT ICDrawSetTime(HIC hic, DWORD lTime) { 597 return ICSendMessage(hic, ICM_DRAW_SETTIME, cast(DWORD_PTR)lTime, 0); 598 } 599 LRESULT ICDrawRealize(HIC hic, HDC hdc, BOOL fBackground) { 600 return ICSendMessage(hic, ICM_DRAW_REALIZE, cast(DWORD_PTR)hdc, cast(DWORD_PTR)fBackground); 601 } 602 LRESULT ICDrawFlush(HIC hic) { 603 return ICSendMessage(hic, ICM_DRAW_FLUSH, 0, 0); 604 } 605 LRESULT ICDrawRenderBuffer(HIC hic) { 606 return ICSendMessage(hic, ICM_DRAW_RENDERBUFFER, 0, 0); 607 } 608 609 extern (Windows) 610 LRESULT ICSetStatusProc(HIC hic, DWORD dwFlags, LRESULT lParam, LONG function(LPARAM, UINT, LONG) fpfnStatus) { 611 ICSETSTATUSPROC ic; 612 613 ic.dwFlags = dwFlags; 614 ic.lParam = lParam; 615 ic.Status = fpfnStatus; 616 617 return ICSendMessage(hic, ICM_SET_STATUS_PROC, cast(DWORD_PTR)&ic, ic.sizeof); 618 } 619 620 HIC ICDecompressOpen(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut) { 621 return ICLocate(fccType, fccHandler, lpbiIn, lpbiOut, ICMODE_DECOMPRESS); 622 } 623 624 HIC ICDrawOpen(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn) { 625 return ICLocate(fccType, fccHandler, lpbiIn, null, ICMODE_DRAW); 626 } 627 628 extern (Windows) { 629 HIC ICLocate(DWORD fccType, DWORD fccHandler, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, WORD wFlags); 630 HIC ICGetDisplayFormat(HIC hic, LPBITMAPINFOHEADER lpbiIn, LPBITMAPINFOHEADER lpbiOut, int BitDepth, int dx, int dy); 631 HANDLE ICImageCompress(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn, LPVOID lpBits, LPBITMAPINFO lpbiOut, LONG lQuality, LONG* plSize); 632 HANDLE ICImageDecompress(HIC hic, UINT uiFlags, LPBITMAPINFO lpbiIn, LPVOID lpBits, LPBITMAPINFO lpbiOut); 633 } 634 635 struct COMPVARS { 636 LONG cbSize = this.sizeof; 637 DWORD dwFlags; 638 HIC hic; 639 DWORD fccType; 640 DWORD fccHandler; 641 LPBITMAPINFO lpbiIn; 642 LPBITMAPINFO lpbiOut; 643 LPVOID lpBitsOut; 644 LPVOID lpBitsPrev; 645 LONG lFrame; 646 LONG lKey; 647 LONG lDataRate; 648 LONG lQ; 649 LONG lKeyCount; 650 LPVOID lpState; 651 LONG cbState; 652 } 653 alias PCOMPVARS = COMPVARS*; 654 655 enum ICMF_COMPVARS_VALID = 0x00000001; 656 657 extern (Windows) { 658 BOOL ICCompressorChoose(HWND hwnd, UINT uiFlags, LPVOID pvIn, LPVOID lpData, PCOMPVARS pc, LPSTR lpszTitle); 659 } 660 661 enum { 662 ICMF_CHOOSE_KEYFRAME = 0x0001, 663 ICMF_CHOOSE_DATARATE = 0x0002, 664 ICMF_CHOOSE_PREVIEW = 0x0004, 665 ICMF_CHOOSE_ALLCOMPRESSORS = 0x0008, 666 } 667 668 extern (Windows) { 669 BOOL ICSeqCompressFrameStart(PCOMPVARS pc, LPBITMAPINFO lpbiIn); 670 void ICSeqCompressFrameEnd(PCOMPVARS pc); 671 LPVOID ICSeqCompressFrame(PCOMPVARS pc, UINT uiFlags, LPVOID lpBits, BOOL* pfKey, LONG* plSize); 672 void ICCompressorFree(PCOMPVARS pc); 673 } 674 675 alias HDRAWDIB = HANDLE; 676 677 enum { 678 DDF_0001 = 0x0001, 679 DDF_UPDATE = 0x0002, 680 DDF_SAME_HDC = 0x0004, 681 DDF_SAME_DRAW = 0x0008, 682 DDF_DONTDRAW = 0x0010, 683 DDF_ANIMATE = 0x0020, 684 DDF_BUFFER = 0x0040, 685 DDF_JUSTDRAWIT = 0x0080, 686 DDF_FULLSCREEN = 0x0100, 687 DDF_BACKGROUNDPAL = 0x0200, 688 DDF_NOTKEYFRAME = 0x0400, 689 DDF_HURRYUP = 0x0800, 690 DDF_HALFTONE = 0x1000, 691 DDF_2000 = 0x2000, 692 DDF_PREROLL = DDF_DONTDRAW, 693 DDF_SAME_DIB = DDF_SAME_DRAW, 694 DDF_SAME_SIZE = DDF_SAME_DRAW, 695 } 696 697 extern (Windows) { 698 BOOL DrawDibInit(); 699 HDRAWDIB DrawDibOpen(); 700 BOOL DrawDibClose(HDRAWDIB hdd); 701 LPVOID DrawDibGetBuffer(HDRAWDIB hdd, LPBITMAPINFOHEADER lpbi, DWORD dwSize, DWORD dwFlags); 702 UINT DrawDibError(HDRAWDIB hdd); 703 HPALETTE DrawDibGetPalette(HDRAWDIB hdd); 704 BOOL DrawDibSetPalette(HDRAWDIB hdd, HPALETTE hpal); 705 BOOL DrawDibChangePalette(HDRAWDIB hdd, int iStart, int iLen, LPPALETTEENTRY lppe); 706 UINT DrawDibRealize(HDRAWDIB hdd, HDC hdc, BOOL fBackground); 707 BOOL DrawDibStart(HDRAWDIB hdd, DWORD rate); 708 BOOL DrawDibStop(HDRAWDIB hdd); 709 BOOL DrawDibBegin(HDRAWDIB hdd, HDC hdc, int dxDst, int dyDst, LPBITMAPINFOHEADER lpbi, int dxSrc, int dySrc, UINT wFlags); 710 BOOL DrawDibDraw(HDRAWDIB hdd, HDC hdc, int xDst, int yDst, int dxDst, int dyDst, LPBITMAPINFOHEADER lpbi, 711 LPVOID lpBits, int xSrc, int ySrc, int dxSrc, int dySrc, UINT wFlags); 712 } 713 714 BOOL DrawDibUpdate(HDRAWDIB hdd, HDC hdc, int x, int y) { 715 return DrawDibDraw(hdd, hdc, x, y, 0, 0, null, null, 0, 0, 0, 0, DDF_UPDATE); 716 } 717 718 extern (Windows) { 719 BOOL DrawDibEnd(HDRAWDIB hdd); 720 } 721 722 struct DRAWDIBTIME { 723 LONG timeCount; 724 LONG timeDraw; 725 LONG timeDecompress; 726 LONG timeDither; 727 LONG timeStretch; 728 LONG timeBlt; 729 LONG timeSetDIBits; 730 } 731 alias LPDRAWDIBTIME = DRAWDIBTIME*; 732 733 extern (Windows) { 734 BOOL DrawDibTime(HDRAWDIB hdd, LPDRAWDIBTIME lpddtime); 735 } 736 737 enum { 738 PD_CAN_DRAW_DIB = 0x0001, 739 PD_CAN_STRETCHDIB = 0x0002, 740 PD_STRETCHDIB_1_1_OK = 0x0004, 741 PD_STRETCHDIB_1_2_OK = 0x0008, 742 PD_STRETCHDIB_1_N_OK = 0x0010, 743 } 744 745 extern (Windows) { 746 LRESULT DrawDibProfileDisplay(LPBITMAPINFOHEADER lpbi); 747 void StretchDIB(LPBITMAPINFOHEADER biDst, LPVOID lpDst, int DstX, int DstY, 748 int DstXE, int DstYE, LPBITMAPINFOHEADER biSrc, LPVOID lpSrc, 749 int SrcX, int SrcY, int SrcXE, int SrcYE); 750 } 751 752 alias FOURCC = DWORD; 753 754 alias TWOCC = WORD; 755 756 enum formtypeAVI = mmioFOURCC!('A', 'V', 'I', ' '); 757 enum listtypeAVIHEADER = mmioFOURCC!('h', 'd', 'r', 'l'); 758 enum ckidAVIMAINHDR = mmioFOURCC!('a', 'v', 'i', 'h'); 759 enum listtypeSTREAMHEADER = mmioFOURCC!('s', 't', 'r', 'l'); 760 enum ckidSTREAMHEADER = mmioFOURCC!('s', 't', 'r', 'h'); 761 enum ckidSTREAMFORMAT = mmioFOURCC!('s', 't', 'r', 'f'); 762 enum ckidSTREAMHANDLERDATA = mmioFOURCC!('s', 't', 'r', 'd'); 763 enum ckidSTREAMNAME = mmioFOURCC!('s', 't', 'r', 'n'); 764 enum listtypeAVIMOVIE = mmioFOURCC!('m', 'o', 'v', 'i'); 765 enum listtypeAVIRECORD = mmioFOURCC!('r', 'e', 'c', ' '); 766 enum ckidAVINEWINDEX = mmioFOURCC!('i', 'd', 'x', '1'); 767 enum streamtypeVIDEO = mmioFOURCC!('v', 'i', 'd', 's'); 768 enum streamtypeAUDIO = mmioFOURCC!('a', 'u', 'd', 's'); 769 enum streamtypeMIDI = mmioFOURCC!('m', 'i', 'd', 's'); 770 enum streamtypeTEXT = mmioFOURCC!('t', 'x', 't', 's'); 771 772 enum cktypeDIBbits = aviTWOCC!('d', 'b'); 773 enum cktypeDIBcompressed = aviTWOCC!('d', 'c'); 774 enum cktypePALchange = aviTWOCC!('p', 'c'); 775 enum cktypeWAVEbytes = aviTWOCC!('w', 'b'); 776 777 enum ckidAVIPADDING = mmioFOURCC!('J', 'U', 'N', 'K'); 778 779 DWORD FromHex(char n) { 780 return (n >= 'A') ? n + 10 - 'A' : n - '0'; 781 } 782 783 WORD StreamFromFOURCC(DWORD fcc) { 784 return cast(WORD)((FromHex(LOBYTE(LOWORD(fcc))) << 4) + (FromHex(HIBYTE(LOWORD(fcc))))); 785 } 786 787 WORD TWOCCFromFOURCC(DWORD fcc) { 788 return HIWORD(fcc); 789 } 790 791 BYTE ToHex(DWORD n) { 792 return cast(BYTE)((n > 9) ? n - 10 + 'A' : n + '0'); 793 } 794 795 DWORD MAKEAVICKID(WORD tcc, WORD stream) { 796 return MAKELONG(cast(WORD)((ToHex(stream & 0x0f) << 8) | (ToHex((stream & 0xf0) >> 4))), tcc); 797 } 798 799 enum { 800 AVIF_HASINDEX = 0x00000010, 801 AVIF_MUSTUSEINDEX = 0x00000020, 802 AVIF_ISINTERLEAVED = 0x00000100, 803 AVIF_WASCAPTUREFILE = 0x00010000, 804 AVIF_COPYRIGHTED = 0x00020000, 805 } 806 807 enum AVI_HEADERSIZE = 2048; 808 809 struct MainAVIHeader { 810 DWORD dwMicroSecPerFrame; 811 DWORD dwMaxBytesPerSec; 812 DWORD dwPaddingGranularity; 813 DWORD dwFlags; 814 DWORD dwTotalFrames; 815 DWORD dwInitialFrames; 816 DWORD dwStreams; 817 DWORD dwSuggestedBufferSize; 818 DWORD dwWidth; 819 DWORD dwHeight; 820 DWORD[4] dwReserved; 821 } 822 823 enum AVISF_DISABLED = 0x00000001; 824 825 enum AVISF_VIDEO_PALCHANGES = 0x00010000; 826 827 struct AVIStreamHeader { 828 FOURCC fccType; 829 FOURCC fccHandler; 830 DWORD dwFlags; 831 WORD wPriority; 832 WORD wLanguage; 833 DWORD dwInitialFrames; 834 DWORD dwScale; 835 DWORD dwRate; 836 DWORD dwStart; 837 DWORD dwLength; 838 DWORD dwSuggestedBufferSize; 839 DWORD dwQuality; 840 DWORD dwSampleSize; 841 RECT rcFrame; 842 } 843 844 enum { 845 AVIIF_FIRSTPART = 0x00000020L, 846 AVIIF_LASTPART = 0x00000040L, 847 AVIIF_MIDPART = (AVIIF_LASTPART|AVIIF_FIRSTPART), 848 AVIIF_NOTIME = 0x00000100L, 849 AVIIF_COMPUSE = 0x0FFF0000L, 850 } 851 852 struct AVIINDEXENTRY { 853 DWORD ckid; 854 DWORD dwFlags; 855 DWORD dwChunkOffset; 856 DWORD dwChunkLength; 857 } 858 859 struct AVIPALCHANGE { 860 BYTE bFirstEntry; 861 BYTE bNumEntries; 862 WORD wFlags; 863 PALETTEENTRY[1] _peNew; 864 PALETTEENTRY* peNew() return { return _peNew.ptr; } 865 } 866 867 enum AVIGETFRAMEF_BESTDISPLAYFMT = 1; 868 869 struct AVISTREAMINFOW { 870 DWORD fccType; 871 DWORD fccHandler; 872 DWORD dwFlags; 873 DWORD dwCaps; 874 WORD wPriority; 875 WORD wLanguage; 876 DWORD dwScale; 877 DWORD dwRate; 878 DWORD dwStart; 879 DWORD dwLength; 880 DWORD dwInitialFrames; 881 DWORD dwSuggestedBufferSize; 882 DWORD dwQuality; 883 DWORD dwSampleSize; 884 RECT rcFrame; 885 DWORD dwEditCount; 886 DWORD dwFormatChangeCount; 887 WCHAR[64] szName = 0; 888 } 889 alias LPAVISTREAMINFOW = AVISTREAMINFOW*; 890 891 struct AVISTREAMINFOA { 892 DWORD fccType; 893 DWORD fccHandler; 894 DWORD dwFlags; 895 DWORD dwCaps; 896 WORD wPriority; 897 WORD wLanguage; 898 DWORD dwScale; 899 DWORD dwRate; 900 DWORD dwStart; 901 DWORD dwLength; 902 DWORD dwInitialFrames; 903 DWORD dwSuggestedBufferSize; 904 DWORD dwQuality; 905 DWORD dwSampleSize; 906 RECT rcFrame; 907 DWORD dwEditCount; 908 DWORD dwFormatChangeCount; 909 char[64] szName = 0; 910 } 911 alias LPAVISTREAMINFOA = AVISTREAMINFOA*; 912 913 version (Unicode) { 914 alias AVISTREAMINFOW AVISTREAMINFO; 915 alias LPAVISTREAMINFOW LPAVISTREAMINFO; 916 } else { // Unicode 917 alias AVISTREAMINFOA AVISTREAMINFO; 918 alias LPAVISTREAMINFOA LPAVISTREAMINFO; 919 } 920 921 enum AVISTREAMINFO_DISABLED = 0x00000001; 922 enum AVISTREAMINFO_FORMATCHANGES = 0x00010000; 923 924 struct AVIFILEINFOW { 925 DWORD dwMaxBytesPerSec; 926 DWORD dwFlags; 927 DWORD dwCaps; 928 DWORD dwStreams; 929 DWORD dwSuggestedBufferSize; 930 DWORD dwWidth; 931 DWORD dwHeight; 932 DWORD dwScale; 933 DWORD dwRate; 934 DWORD dwLength; 935 DWORD dwEditCount; 936 WCHAR[64] szFileType = 0; 937 } 938 alias LPAVIFILEINFOW = AVIFILEINFOW*; 939 940 struct AVIFILEINFOA { 941 DWORD dwMaxBytesPerSec; 942 DWORD dwFlags; 943 DWORD dwCaps; 944 DWORD dwStreams; 945 DWORD dwSuggestedBufferSize; 946 DWORD dwWidth; 947 DWORD dwHeight; 948 DWORD dwScale; 949 DWORD dwRate; 950 DWORD dwLength; 951 DWORD dwEditCount; 952 char[64] szFileType = 0; 953 } 954 alias LPAVIFILEINFOA = AVIFILEINFOA*; 955 956 version (Unicode) { 957 alias AVIFILEINFOW AVIFILEINFO; 958 alias LPAVIFILEINFOW LPAVIFILEINFO; 959 } else { // Unicode 960 alias AVIFILEINFOA AVIFILEINFO; 961 alias LPAVIFILEINFOA LPAVIFILEINFO; 962 } 963 964 enum { 965 AVIFILEINFO_HASINDEX = 0x00000010, 966 AVIFILEINFO_MUSTUSEINDEX = 0x00000020, 967 AVIFILEINFO_ISINTERLEAVED = 0x00000100, 968 AVIFILEINFO_WASCAPTUREFILE = 0x00010000, 969 AVIFILEINFO_COPYRIGHTED = 0x00020000, 970 } 971 972 enum { 973 AVIFILECAPS_CANREAD = 0x00000001, 974 AVIFILECAPS_CANWRITE = 0x00000002, 975 AVIFILECAPS_ALLKEYFRAMES = 0x00000010, 976 AVIFILECAPS_NOCOMPRESSION = 0x00000020, 977 } 978 979 extern (Windows) { 980 alias BOOL function(int) AVISAVECALLBACK; 981 } 982 983 struct AVICOMPRESSOPTIONS { 984 DWORD fccType; 985 DWORD fccHandler; 986 DWORD dwKeyFrameEvery; 987 DWORD dwQuality; 988 DWORD dwBytesPerSecond; 989 DWORD dwFlags; 990 LPVOID lpFormat; 991 DWORD cbFormat; 992 LPVOID lpParms; 993 DWORD cbParms; 994 DWORD dwInterleaveEvery; 995 } 996 alias LPAVICOMPRESSOPTIONS = AVICOMPRESSOPTIONS*; 997 998 enum { 999 AVICOMPRESSF_INTERLEAVE = 0x00000001, 1000 AVICOMPRESSF_DATARATE = 0x00000002, 1001 AVICOMPRESSF_KEYFRAMES = 0x00000004, 1002 AVICOMPRESSF_VALID = 0x00000008, 1003 } 1004 1005 /+ TODO: 1006 DECLARE_INTERFACE_(IAVIStream, IUnknown) 1007 { 1008 STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; 1009 STDMETHOD_(ULONG,AddRef) (THIS) PURE; 1010 STDMETHOD_(ULONG,Release) (THIS) PURE; 1011 1012 STDMETHOD(Create) (THIS_ LPARAM lParam1, LPARAM lParam2) PURE ; 1013 STDMETHOD(Info) (THIS_ AVISTREAMINFOW FAR * psi, LONG lSize) PURE ; 1014 STDMETHOD_(LONG, FindSample)(THIS_ LONG lPos, LONG lFlags) PURE ; 1015 STDMETHOD(ReadFormat) (THIS_ LONG lPos, 1016 LPVOID lpFormat, LONG FAR *lpcbFormat) PURE ; 1017 STDMETHOD(SetFormat) (THIS_ LONG lPos, 1018 LPVOID lpFormat, LONG cbFormat) PURE ; 1019 STDMETHOD(Read) (THIS_ LONG lStart, LONG lSamples, 1020 LPVOID lpBuffer, LONG cbBuffer, 1021 LONG FAR * plBytes, LONG FAR * plSamples) PURE ; 1022 STDMETHOD(Write) (THIS_ LONG lStart, LONG lSamples, 1023 LPVOID lpBuffer, LONG cbBuffer, 1024 DWORD dwFlags, 1025 LONG FAR *plSampWritten, 1026 LONG FAR *plBytesWritten) PURE ; 1027 STDMETHOD(Delete) (THIS_ LONG lStart, LONG lSamples) PURE; 1028 STDMETHOD(ReadData) (THIS_ DWORD fcc, LPVOID lp, LONG FAR *lpcb) PURE ; 1029 STDMETHOD(WriteData) (THIS_ DWORD fcc, LPVOID lp, LONG cb) PURE ; 1030 #ifdef _WIN32 1031 STDMETHOD(SetInfo) (THIS_ AVISTREAMINFOW FAR * lpInfo, 1032 LONG cbInfo) PURE; 1033 #else 1034 STDMETHOD(Reserved1) (THIS) PURE; 1035 STDMETHOD(Reserved2) (THIS) PURE; 1036 STDMETHOD(Reserved3) (THIS) PURE; 1037 STDMETHOD(Reserved4) (THIS) PURE; 1038 STDMETHOD(Reserved5) (THIS) PURE; 1039 #endif 1040 }; 1041 1042 alias IAVIStream FAR* PAVISTREAM; 1043 1044 #undef INTERFACE 1045 #define INTERFACE IAVIStreaming 1046 1047 DECLARE_INTERFACE_(IAVIStreaming, IUnknown) 1048 { 1049 STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; 1050 STDMETHOD_(ULONG,AddRef) (THIS) PURE; 1051 STDMETHOD_(ULONG,Release) (THIS) PURE; 1052 1053 STDMETHOD(Begin) (THIS_ 1054 LONG lStart, 1055 LONG lEnd, 1056 LONG lRate) PURE; 1057 STDMETHOD(End) (THIS) PURE; 1058 }; 1059 1060 alias IAVIStreaming FAR* PAVISTREAMING; 1061 1062 1063 #undef INTERFACE 1064 #define INTERFACE IAVIEditStream 1065 1066 DECLARE_INTERFACE_(IAVIEditStream, IUnknown) 1067 { 1068 STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; 1069 STDMETHOD_(ULONG,AddRef) (THIS) PURE; 1070 STDMETHOD_(ULONG,Release) (THIS) PURE; 1071 1072 STDMETHOD(Cut) (THIS_ LONG FAR *plStart, 1073 LONG FAR *plLength, 1074 PAVISTREAM FAR * ppResult) PURE; 1075 STDMETHOD(Copy) (THIS_ LONG FAR *plStart, 1076 LONG FAR *plLength, 1077 PAVISTREAM FAR * ppResult) PURE; 1078 STDMETHOD(Paste) (THIS_ LONG FAR *plPos, 1079 LONG FAR *plLength, 1080 PAVISTREAM pstream, 1081 LONG lStart, 1082 LONG lEnd) PURE; 1083 STDMETHOD(Clone) (THIS_ PAVISTREAM FAR *ppResult) PURE; 1084 STDMETHOD(SetInfo) (THIS_ AVISTREAMINFOW FAR * lpInfo, 1085 LONG cbInfo) PURE; 1086 }; 1087 1088 alias IAVIEditStream FAR* PAVIEDITSTREAM; 1089 1090 #undef INTERFACE 1091 #define INTERFACE IAVIPersistFile 1092 1093 DECLARE_INTERFACE_(IAVIPersistFile, IPersistFile) 1094 { 1095 STDMETHOD(Reserved1)(THIS) PURE; 1096 }; 1097 1098 alias IAVIPersistFile FAR* PAVIPERSISTFILE; 1099 1100 #undef INTERFACE 1101 #define INTERFACE IAVIFile 1102 #define PAVIFILE IAVIFile FAR* 1103 1104 DECLARE_INTERFACE_(IAVIFile, IUnknown) 1105 { 1106 STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; 1107 STDMETHOD_(ULONG,AddRef) (THIS) PURE; 1108 STDMETHOD_(ULONG,Release) (THIS) PURE; 1109 1110 STDMETHOD(Info) (THIS_ 1111 AVIFILEINFOW FAR * pfi, 1112 LONG lSize) PURE; 1113 STDMETHOD(GetStream) (THIS_ 1114 PAVISTREAM FAR * ppStream, 1115 DWORD fccType, 1116 LONG lParam) PURE; 1117 STDMETHOD(CreateStream) (THIS_ 1118 PAVISTREAM FAR * ppStream, 1119 AVISTREAMINFOW FAR * psi) PURE; 1120 STDMETHOD(WriteData) (THIS_ 1121 DWORD ckid, 1122 LPVOID lpData, 1123 LONG cbData) PURE; 1124 STDMETHOD(ReadData) (THIS_ 1125 DWORD ckid, 1126 LPVOID lpData, 1127 LONG FAR *lpcbData) PURE; 1128 STDMETHOD(EndRecord) (THIS) PURE; 1129 STDMETHOD(DeleteStream) (THIS_ 1130 DWORD fccType, 1131 LONG lParam) PURE; 1132 }; 1133 1134 #undef PAVIFILE 1135 alias IAVIFile FAR* PAVIFILE; 1136 1137 #undef INTERFACE 1138 #define INTERFACE IGetFrame 1139 #define PGETFRAME IGetFrame FAR* 1140 1141 DECLARE_INTERFACE_(IGetFrame, IUnknown) 1142 { 1143 STDMETHOD(QueryInterface) (THIS_ REFIID riid, LPVOID FAR* ppvObj) PURE; 1144 STDMETHOD_(ULONG,AddRef) (THIS) PURE; 1145 STDMETHOD_(ULONG,Release) (THIS) PURE; 1146 1147 STDMETHOD_(LPVOID,GetFrame) (THIS_ LONG lPos) PURE; 1148 1149 STDMETHOD(Begin) (THIS_ LONG lStart, LONG lEnd, LONG lRate) PURE; 1150 STDMETHOD(End) (THIS) PURE; 1151 1152 STDMETHOD(SetFormat) (THIS_ LPBITMAPINFOHEADER lpbi, LPVOID lpBits, int x, int y, int dx, int dy) PURE; 1153 }; 1154 1155 #undef PGETFRAME 1156 alias IGetFrame FAR* PGETFRAME; 1157 1158 #define DEFINE_AVIGUID(name, l, w1, w2) DEFINE_GUID(name, l, w1, w2, 0xC0,0,0,0,0,0,0,0x46) 1159 1160 DEFINE_AVIGUID(IID_IAVIFile, 0x00020020, 0, 0); 1161 DEFINE_AVIGUID(IID_IAVIStream, 0x00020021, 0, 0); 1162 DEFINE_AVIGUID(IID_IAVIStreaming, 0x00020022, 0, 0); 1163 DEFINE_AVIGUID(IID_IGetFrame, 0x00020023, 0, 0); 1164 DEFINE_AVIGUID(IID_IAVIEditStream, 0x00020024, 0, 0); 1165 DEFINE_AVIGUID(IID_IAVIPersistFile, 0x00020025, 0, 0); 1166 #ifndef UNICODE 1167 DEFINE_AVIGUID(CLSID_AVISimpleUnMarshal, 0x00020009, 0, 0); 1168 #endif 1169 1170 DEFINE_AVIGUID(CLSID_AVIFile, 0x00020000, 0, 0); 1171 1172 #define AVIFILEHANDLER_CANREAD 0x0001 1173 #define AVIFILEHANDLER_CANWRITE 0x0002 1174 #define AVIFILEHANDLER_CANACCEPTNONRGB 0x0004 1175 1176 STDAPI_(void) AVIFileInit(void); 1177 STDAPI_(void) AVIFileExit(void); 1178 1179 STDAPI_(ULONG) AVIFileAddRef (PAVIFILE pfile); 1180 STDAPI_(ULONG) AVIFileRelease (PAVIFILE pfile); 1181 1182 #ifdef _WIN32 1183 STDAPI AVIFileOpenA (PAVIFILE FAR * ppfile, LPCSTR szFile, 1184 UINT uMode, LPCLSID lpHandler); 1185 STDAPI AVIFileOpenW (PAVIFILE FAR * ppfile, LPCWSTR szFile, 1186 UINT uMode, LPCLSID lpHandler); 1187 #ifdef UNICODE 1188 #define AVIFileOpen AVIFileOpenW 1189 #else 1190 #define AVIFileOpen AVIFileOpenA 1191 #endif 1192 #else 1193 STDAPI AVIFileOpen (PAVIFILE FAR * ppfile, LPCSTR szFile, 1194 UINT uMode, LPCLSID lpHandler); 1195 #define AVIFileOpenW AVIFileOpen 1196 #endif 1197 1198 #ifdef _WIN32 1199 STDAPI AVIFileInfoW (PAVIFILE pfile, LPAVIFILEINFOW pfi, LONG lSize); 1200 STDAPI AVIFileInfoA (PAVIFILE pfile, LPAVIFILEINFOA pfi, LONG lSize); 1201 #ifdef UNICODE 1202 #define AVIFileInfo AVIFileInfoW 1203 #else 1204 #define AVIFileInfo AVIFileInfoA 1205 #endif 1206 #else 1207 STDAPI AVIFileInfo (PAVIFILE pfile, LPAVIFILEINFO pfi, LONG lSize); 1208 #define AVIFileInfoW AVIFileInfo 1209 #endif 1210 1211 1212 STDAPI AVIFileGetStream (PAVIFILE pfile, PAVISTREAM FAR * ppavi, DWORD fccType, LONG lParam); 1213 1214 1215 #ifdef _WIN32 1216 STDAPI AVIFileCreateStreamW (PAVIFILE pfile, PAVISTREAM FAR *ppavi, AVISTREAMINFOW FAR * psi); 1217 STDAPI AVIFileCreateStreamA (PAVIFILE pfile, PAVISTREAM FAR *ppavi, AVISTREAMINFOA FAR * psi); 1218 #ifdef UNICODE 1219 #define AVIFileCreateStream AVIFileCreateStreamW 1220 #else 1221 #define AVIFileCreateStream AVIFileCreateStreamA 1222 #endif 1223 #else 1224 STDAPI AVIFileCreateStream(PAVIFILE pfile, PAVISTREAM FAR *ppavi, AVISTREAMINFO FAR * psi); 1225 #define AVIFileCreateStreamW AVIFileCreateStream 1226 #endif 1227 1228 STDAPI AVIFileWriteData (PAVIFILE pfile, 1229 DWORD ckid, 1230 LPVOID lpData, 1231 LONG cbData); 1232 STDAPI AVIFileReadData (PAVIFILE pfile, 1233 DWORD ckid, 1234 LPVOID lpData, 1235 LONG FAR *lpcbData); 1236 STDAPI AVIFileEndRecord (PAVIFILE pfile); 1237 1238 STDAPI_(ULONG) AVIStreamAddRef (PAVISTREAM pavi); 1239 STDAPI_(ULONG) AVIStreamRelease (PAVISTREAM pavi); 1240 1241 STDAPI AVIStreamInfoW (PAVISTREAM pavi, LPAVISTREAMINFOW psi, LONG lSize); 1242 STDAPI AVIStreamInfoA (PAVISTREAM pavi, LPAVISTREAMINFOA psi, LONG lSize); 1243 #ifdef UNICODE 1244 #define AVIStreamInfo AVIStreamInfoW 1245 #else 1246 #define AVIStreamInfo AVIStreamInfoA 1247 #endif 1248 1249 STDAPI_(LONG) AVIStreamFindSample(PAVISTREAM pavi, LONG lPos, LONG lFlags); 1250 STDAPI AVIStreamReadFormat (PAVISTREAM pavi, LONG lPos,LPVOID lpFormat,LONG FAR *lpcbFormat); 1251 STDAPI AVIStreamSetFormat (PAVISTREAM pavi, LONG lPos,LPVOID lpFormat,LONG cbFormat); 1252 STDAPI AVIStreamReadData (PAVISTREAM pavi, DWORD fcc, LPVOID lp, LONG FAR *lpcb); 1253 STDAPI AVIStreamWriteData (PAVISTREAM pavi, DWORD fcc, LPVOID lp, LONG cb); 1254 1255 STDAPI AVIStreamRead (PAVISTREAM pavi, 1256 LONG lStart, 1257 LONG lSamples, 1258 LPVOID lpBuffer, 1259 LONG cbBuffer, 1260 LONG FAR * plBytes, 1261 LONG FAR * plSamples); 1262 #define AVISTREAMREAD_CONVENIENT (-1L) 1263 1264 STDAPI AVIStreamWrite (PAVISTREAM pavi, 1265 LONG lStart, LONG lSamples, 1266 LPVOID lpBuffer, LONG cbBuffer, DWORD dwFlags, 1267 LONG FAR *plSampWritten, 1268 LONG FAR *plBytesWritten); 1269 1270 STDAPI_(LONG) AVIStreamStart (PAVISTREAM pavi); 1271 STDAPI_(LONG) AVIStreamLength (PAVISTREAM pavi); 1272 STDAPI_(LONG) AVIStreamTimeToSample (PAVISTREAM pavi, LONG lTime); 1273 STDAPI_(LONG) AVIStreamSampleToTime (PAVISTREAM pavi, LONG lSample); 1274 1275 1276 STDAPI AVIStreamBeginStreaming(PAVISTREAM pavi, LONG lStart, LONG lEnd, LONG lRate); 1277 STDAPI AVIStreamEndStreaming(PAVISTREAM pavi); 1278 1279 STDAPI_(PGETFRAME) AVIStreamGetFrameOpen(PAVISTREAM pavi, 1280 LPBITMAPINFOHEADER lpbiWanted); 1281 STDAPI_(LPVOID) AVIStreamGetFrame(PGETFRAME pg, LONG lPos); 1282 STDAPI AVIStreamGetFrameClose(PGETFRAME pg); 1283 1284 STDAPI AVIStreamOpenFromFileA(PAVISTREAM FAR *ppavi, LPCSTR szFile, 1285 DWORD fccType, LONG lParam, 1286 UINT mode, CLSID FAR *pclsidHandler); 1287 STDAPI AVIStreamOpenFromFileW(PAVISTREAM FAR *ppavi, LPCWSTR szFile, 1288 DWORD fccType, LONG lParam, 1289 UINT mode, CLSID FAR *pclsidHandler); 1290 #ifdef UNICODE 1291 #define AVIStreamOpenFromFile AVIStreamOpenFromFileW 1292 #else 1293 #define AVIStreamOpenFromFile AVIStreamOpenFromFileA 1294 #endif 1295 1296 STDAPI AVIStreamCreate(PAVISTREAM FAR *ppavi, LONG lParam1, LONG lParam2, 1297 CLSID FAR *pclsidHandler); 1298 1299 1300 1301 #define FIND_DIR 0x0000000FL 1302 #define FIND_NEXT 0x00000001L 1303 #define FIND_PREV 0x00000004L 1304 #define FIND_FROM_START 0x00000008L 1305 1306 #define FIND_TYPE 0x000000F0L 1307 #define FIND_KEY 0x00000010L 1308 #define FIND_ANY 0x00000020L 1309 #define FIND_FORMAT 0x00000040L 1310 1311 #define FIND_RET 0x0000F000L 1312 #define FIND_POS 0x00000000L 1313 #define FIND_LENGTH 0x00001000L 1314 #define FIND_OFFSET 0x00002000L 1315 #define FIND_SIZE 0x00003000L 1316 #define FIND_INDEX 0x00004000L 1317 1318 #define AVIStreamFindKeyFrame AVIStreamFindSample 1319 #define FindKeyFrame FindSample 1320 1321 #define AVIStreamClose AVIStreamRelease 1322 #define AVIFileClose AVIFileRelease 1323 #define AVIStreamInit AVIFileInit 1324 #define AVIStreamExit AVIFileExit 1325 1326 #define SEARCH_NEAREST FIND_PREV 1327 #define SEARCH_BACKWARD FIND_PREV 1328 #define SEARCH_FORWARD FIND_NEXT 1329 #define SEARCH_KEY FIND_KEY 1330 #define SEARCH_ANY FIND_ANY 1331 1332 #define AVIStreamSampleToSample(pavi1, pavi2, l) AVIStreamTimeToSample(pavi1,AVIStreamSampleToTime(pavi2, l)) 1333 1334 #define AVIStreamNextSample(pavi, l) AVIStreamFindSample(pavi,l+1,FIND_NEXT|FIND_ANY) 1335 1336 #define AVIStreamPrevSample(pavi, l) AVIStreamFindSample(pavi,l-1,FIND_PREV|FIND_ANY) 1337 1338 #define AVIStreamNearestSample(pavi, l) AVIStreamFindSample(pavi,l,FIND_PREV|FIND_ANY) 1339 1340 #define AVIStreamNextKeyFrame(pavi,l) AVIStreamFindSample(pavi,l+1,FIND_NEXT|FIND_KEY) 1341 1342 #define AVIStreamPrevKeyFrame(pavi, l) AVIStreamFindSample(pavi,l-1,FIND_PREV|FIND_KEY) 1343 1344 #define AVIStreamNearestKeyFrame(pavi, l) AVIStreamFindSample(pavi,l,FIND_PREV|FIND_KEY) 1345 1346 #define AVIStreamIsKeyFrame(pavi, l) (AVIStreamNearestKeyFrame(pavi,l) == l) 1347 1348 #define AVIStreamPrevSampleTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamPrevSample(pavi,AVIStreamTimeToSample(pavi,t))) 1349 1350 #define AVIStreamNextSampleTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamNextSample(pavi,AVIStreamTimeToSample(pavi,t))) 1351 1352 #define AVIStreamNearestSampleTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamNearestSample(pavi,AVIStreamTimeToSample(pavi,t))) 1353 1354 #define AVIStreamNextKeyFrameTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamNextKeyFrame(pavi,AVIStreamTimeToSample(pavi, t))) 1355 1356 #define AVIStreamPrevKeyFrameTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamPrevKeyFrame(pavi,AVIStreamTimeToSample(pavi, t))) 1357 1358 #define AVIStreamNearestKeyFrameTime(pavi, t) AVIStreamSampleToTime(pavi, AVIStreamNearestKeyFrame(pavi,AVIStreamTimeToSample(pavi, t))) 1359 1360 #define AVIStreamStartTime(pavi) AVIStreamSampleToTime(pavi, AVIStreamStart(pavi)) 1361 1362 #define AVIStreamLengthTime(pavi) AVIStreamSampleToTime(pavi, AVIStreamLength(pavi)) 1363 1364 #define AVIStreamEnd(pavi) (AVIStreamStart(pavi) + AVIStreamLength(pavi)) 1365 1366 #define AVIStreamEndTime(pavi) AVIStreamSampleToTime(pavi, AVIStreamEnd(pavi)) 1367 1368 #define AVIStreamSampleSize(pavi, lPos, plSize) AVIStreamRead(pavi,lPos,1,NULL,0,plSize,NULL) 1369 1370 #define AVIStreamFormatSize(pavi, lPos, plSize) AVIStreamReadFormat(pavi,lPos,NULL,plSize) 1371 1372 #define AVIStreamDataSize(pavi, fcc, plSize) AVIStreamReadData(pavi,fcc,NULL,plSize) 1373 1374 #ifndef comptypeDIB 1375 #define comptypeDIB mmioFOURCC('D', 'I', 'B', ' ') 1376 #endif 1377 1378 STDAPI AVIMakeCompressedStream( 1379 PAVISTREAM FAR * ppsCompressed, 1380 PAVISTREAM ppsSource, 1381 AVICOMPRESSOPTIONS FAR * lpOptions, 1382 CLSID FAR *pclsidHandler); 1383 1384 EXTERN_C HRESULT CDECL AVISaveA (LPCSTR szFile, 1385 CLSID FAR *pclsidHandler, 1386 AVISAVECALLBACK lpfnCallback, 1387 int nStreams, 1388 PAVISTREAM pfile, 1389 LPAVICOMPRESSOPTIONS lpOptions, 1390 ...); 1391 1392 STDAPI AVISaveVA(LPCSTR szFile, 1393 CLSID FAR *pclsidHandler, 1394 AVISAVECALLBACK lpfnCallback, 1395 int nStreams, 1396 PAVISTREAM FAR * ppavi, 1397 LPAVICOMPRESSOPTIONS FAR *plpOptions); 1398 EXTERN_C HRESULT CDECL AVISaveW (LPCWSTR szFile, 1399 CLSID FAR *pclsidHandler, 1400 AVISAVECALLBACK lpfnCallback, 1401 int nStreams, 1402 PAVISTREAM pfile, 1403 LPAVICOMPRESSOPTIONS lpOptions, 1404 ...); 1405 1406 STDAPI AVISaveVW(LPCWSTR szFile, 1407 CLSID FAR *pclsidHandler, 1408 AVISAVECALLBACK lpfnCallback, 1409 int nStreams, 1410 PAVISTREAM FAR * ppavi, 1411 LPAVICOMPRESSOPTIONS FAR *plpOptions); 1412 #ifdef UNICODE 1413 #define AVISave AVISaveW 1414 #define AVISaveV AVISaveVW 1415 #else 1416 #define AVISave AVISaveA 1417 #define AVISaveV AVISaveVA 1418 #endif 1419 1420 1421 1422 STDAPI_(INT_PTR) AVISaveOptions(HWND hwnd, 1423 UINT uiFlags, 1424 int nStreams, 1425 PAVISTREAM FAR *ppavi, 1426 LPAVICOMPRESSOPTIONS FAR *plpOptions); 1427 1428 STDAPI AVISaveOptionsFree(int nStreams, 1429 LPAVICOMPRESSOPTIONS FAR *plpOptions); 1430 1431 STDAPI AVIBuildFilterW(LPWSTR lpszFilter, LONG cbFilter, BOOL fSaving); 1432 STDAPI AVIBuildFilterA(LPSTR lpszFilter, LONG cbFilter, BOOL fSaving); 1433 #ifdef UNICODE 1434 #define AVIBuildFilter AVIBuildFilterW 1435 #else 1436 #define AVIBuildFilter AVIBuildFilterA 1437 #endif 1438 STDAPI AVIMakeFileFromStreams(PAVIFILE FAR * ppfile, 1439 int nStreams, 1440 PAVISTREAM FAR * papStreams); 1441 1442 STDAPI AVIMakeStreamFromClipboard(UINT cfFormat, HANDLE hGlobal, PAVISTREAM FAR *ppstream); 1443 1444 STDAPI AVIPutFileOnClipboard(PAVIFILE pf); 1445 1446 STDAPI AVIGetFromClipboard(PAVIFILE FAR * lppf); 1447 1448 STDAPI AVIClearClipboard(void); 1449 1450 STDAPI CreateEditableStream( 1451 PAVISTREAM FAR * ppsEditable, 1452 PAVISTREAM psSource); 1453 1454 STDAPI EditStreamCut(PAVISTREAM pavi, LONG FAR *plStart, LONG FAR *plLength, PAVISTREAM FAR * ppResult); 1455 1456 STDAPI EditStreamCopy(PAVISTREAM pavi, LONG FAR *plStart, LONG FAR *plLength, PAVISTREAM FAR * ppResult); 1457 1458 STDAPI EditStreamPaste(PAVISTREAM pavi, LONG FAR *plPos, LONG FAR *plLength, PAVISTREAM pstream, LONG lStart, LONG lEnd); 1459 1460 STDAPI EditStreamClone(PAVISTREAM pavi, PAVISTREAM FAR *ppResult); 1461 1462 1463 STDAPI EditStreamSetNameA(PAVISTREAM pavi, LPCSTR lpszName); 1464 STDAPI EditStreamSetNameW(PAVISTREAM pavi, LPCWSTR lpszName); 1465 STDAPI EditStreamSetInfoW(PAVISTREAM pavi, LPAVISTREAMINFOW lpInfo, LONG cbInfo); 1466 STDAPI EditStreamSetInfoA(PAVISTREAM pavi, LPAVISTREAMINFOA lpInfo, LONG cbInfo); 1467 #ifdef UNICODE 1468 #define EditStreamSetInfo EditStreamSetInfoW 1469 #define EditStreamSetName EditStreamSetNameW 1470 #else 1471 #define EditStreamSetInfo EditStreamSetInfoA 1472 #define EditStreamSetName EditStreamSetNameA 1473 #endif 1474 +/ 1475 enum AVIERR_OK = 0L; 1476 1477 SCODE MAKE_AVIERR(DWORD error) { 1478 return MAKE_SCODE(SEVERITY_ERROR, FACILITY_ITF, 0x4000 + error); 1479 } 1480 1481 enum AVIERR_UNSUPPORTED = MAKE_AVIERR(101); 1482 enum AVIERR_BADFORMAT = MAKE_AVIERR(102); 1483 enum AVIERR_MEMORY = MAKE_AVIERR(103); 1484 enum AVIERR_INTERNAL = MAKE_AVIERR(104); 1485 enum AVIERR_BADFLAGS = MAKE_AVIERR(105); 1486 enum AVIERR_BADPARAM = MAKE_AVIERR(106); 1487 enum AVIERR_BADSIZE = MAKE_AVIERR(107); 1488 enum AVIERR_BADHANDLE = MAKE_AVIERR(108); 1489 enum AVIERR_FILEREAD = MAKE_AVIERR(109); 1490 enum AVIERR_FILEWRITE = MAKE_AVIERR(110); 1491 enum AVIERR_FILEOPEN = MAKE_AVIERR(111); 1492 enum AVIERR_COMPRESSOR = MAKE_AVIERR(112); 1493 enum AVIERR_NOCOMPRESSOR = MAKE_AVIERR(113); 1494 enum AVIERR_READONLY = MAKE_AVIERR(114); 1495 enum AVIERR_NODATA = MAKE_AVIERR(115); 1496 enum AVIERR_BUFFERTOOSMALL = MAKE_AVIERR(116); 1497 enum AVIERR_CANTCOMPRESS = MAKE_AVIERR(117); 1498 enum AVIERR_USERABORT = MAKE_AVIERR(198); 1499 enum AVIERR_ERROR = MAKE_AVIERR(199); 1500 1501 const TCHAR[] MCIWND_WINDOW_CLASS = "MCIWndClass"; 1502 1503 extern (Windows) { 1504 HWND MCIWndCreateA(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCSTR szFile); 1505 HWND MCIWndCreateW(HWND hwndParent, HINSTANCE hInstance, DWORD dwStyle, LPCWSTR szFile); 1506 } 1507 1508 version (Unicode) { 1509 alias MCIWndCreate = MCIWndCreateW; 1510 } else { // Unicode 1511 alias MCIWndCreate = MCIWndCreateA; 1512 } 1513 1514 extern(Windows) { 1515 BOOL MCIWndRegisterClass(); 1516 } 1517 1518 enum { 1519 MCIWNDOPENF_NEW = 0x0001, 1520 MCIWNDF_NOAUTOSIZEWINDOW = 0x0001, 1521 MCIWNDF_NOPLAYBAR = 0x0002, 1522 MCIWNDF_NOAUTOSIZEMOVIE = 0x0004, 1523 MCIWNDF_NOMENU = 0x0008, 1524 MCIWNDF_SHOWNAME = 0x0010, 1525 MCIWNDF_SHOWPOS = 0x0020, 1526 MCIWNDF_SHOWMODE = 0x0040, 1527 MCIWNDF_SHOWALL = 0x0070, 1528 MCIWNDF_NOTIFYMODE = 0x0100, 1529 MCIWNDF_NOTIFYPOS = 0x0200, 1530 MCIWNDF_NOTIFYSIZE = 0x0400, 1531 MCIWNDF_NOTIFYERROR = 0x1000, 1532 MCIWNDF_NOTIFYALL = 0x1F00, 1533 MCIWNDF_NOTIFYANSI = 0x0080, 1534 MCIWNDF_NOTIFYMEDIAA = 0x0880, 1535 MCIWNDF_NOTIFYMEDIAW = 0x0800, 1536 } 1537 1538 version (Unicode) { 1539 alias MCIWNDF_NOTIFYMEDIAW MCIWNDF_NOTIFYMEDIA; 1540 } else { // Unicode 1541 alias MCIWNDF_NOTIFYMEDIAA MCIWNDF_NOTIFYMEDIA; 1542 } 1543 1544 enum { 1545 MCIWNDF_RECORD = 0x2000, 1546 MCIWNDF_NOERRORDLG = 0x4000, 1547 MCIWNDF_NOOPEN = 0x8000, 1548 } 1549 1550 // can macros 1551 1552 BOOL MCIWndCanPlay(HWND hwnd) 1553 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_PLAY, 0, 0); } 1554 BOOL MCIWndCanRecord(HWND hwnd) 1555 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_RECORD, 0, 0); } 1556 BOOL MCIWndCanSave(HWND hwnd) 1557 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_SAVE, 0, 0); } 1558 BOOL MCIWndCanWindow(HWND hwnd) 1559 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_WINDOW, 0, 0); } 1560 BOOL MCIWndCanEject(HWND hwnd) 1561 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_EJECT, 0, 0); } 1562 BOOL MCIWndCanConfig(HWND hwnd) 1563 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_CAN_CONFIG, 0, 0); } 1564 BOOL MCIWndPaletteKick(HWND hwnd) 1565 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_PALETTEKICK, 0, 0); } 1566 LONG MCIWndSave(HWND hwnd, LPVOID szFile) 1567 { return cast(LONG)SendMessage(hwnd, MCI_SAVE, 0, cast(LPARAM)szFile); } 1568 LONG MCIWndSaveDialog(HWND hwnd) 1569 { return MCIWndSave(hwnd, cast(LPVOID)-1); } 1570 LONG MCIWndNew(HWND hwnd, LPVOID lp) 1571 { return cast(LONG)SendMessage(hwnd, MCIWNDM_NEW, 0, cast(LPARAM)lp); } 1572 LONG MCIWndRecord(HWND hwnd) 1573 { return cast(LONG)SendMessage(hwnd, MCI_RECORD, 0, 0); } 1574 LONG MCIWndOpen(HWND hwnd, LPVOID sz, UINT f) 1575 { return cast(LONG)SendMessage(hwnd, MCIWNDM_OPEN, cast(WPARAM)f, cast(LPARAM)sz); } 1576 LONG MCIWndOpenDialog(HWND hwnd) 1577 { return MCIWndOpen(hwnd, cast(LPVOID)-1, 0); } 1578 LONG MCIWndClose(HWND hwnd) 1579 { return cast(LONG)SendMessage(hwnd, MCI_CLOSE, 0, 0); } 1580 LONG MCIWndPlay(HWND hwnd) 1581 { return cast(LONG)SendMessage(hwnd, MCI_PLAY, 0, 0); } 1582 LONG MCIWndStop(HWND hwnd) 1583 { return cast(LONG)SendMessage(hwnd, MCI_STOP, 0, 0); } 1584 LONG MCIWndPause(HWND hwnd) 1585 { return cast(LONG)SendMessage(hwnd, MCI_PAUSE, 0, 0); } 1586 LONG MCIWndResume(HWND hwnd) 1587 { return cast(LONG)SendMessage(hwnd, MCI_RESUME, 0, 0); } 1588 LONG MCIWndSeek(HWND hwnd, LONG lPos) 1589 { return cast(LONG)SendMessage(hwnd, MCI_SEEK, 0, cast(LPARAM)lPos); } 1590 LONG MCIWndHome(HWND hwnd) 1591 { return MCIWndSeek(hwnd, MCIWND_START); } 1592 LONG MCIWndEnd(HWND hwnd) 1593 { return MCIWndSeek(hwnd, MCIWND_END); } 1594 LONG MCIWndEject(HWND hwnd) 1595 { return cast(LONG)SendMessage(hwnd, MCIWNDM_EJECT, 0, 0); } 1596 LONG MCIWndGetSource(HWND hwnd, LPRECT prc) 1597 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GET_SOURCE, 0, cast(LPARAM)prc); } 1598 LONG MCIWndPutSource(HWND hwnd, LPRECT prc) 1599 { return cast(LONG)SendMessage(hwnd, MCIWNDM_PUT_SOURCE, 0, cast(LPARAM)prc); } 1600 LONG MCIWndGetDest(HWND hwnd, LPRECT prc) 1601 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GET_DEST, 0, cast(LPARAM)prc); } 1602 LONG MCIWndPutDest(HWND hwnd, LPRECT prc) 1603 { return cast(LONG)SendMessage(hwnd, MCIWNDM_PUT_DEST, 0, cast(LPARAM)prc); } 1604 LONG MCIWndPlayReverse(HWND hwnd) 1605 { return cast(LONG)SendMessage(hwnd, MCIWNDM_PLAYREVERSE, 0, 0); } 1606 LONG MCIWndPlayFrom(HWND hwnd, LONG lPos) 1607 { return cast(LONG)SendMessage(hwnd, MCIWNDM_PLAYFROM, 0, cast(LPARAM)lPos); } 1608 LONG MCIWndPlayTo(HWND hwnd, LONG lPos) 1609 { return cast(LONG)SendMessage(hwnd, MCIWNDM_PLAYTO, 0, cast(LPARAM)lPos); } 1610 LONG MCIWndPlayFromTo(HWND hwnd, LONG lStart, LONG lEnd) 1611 { MCIWndSeek(hwnd, lStart); return MCIWndPlayTo(hwnd, lEnd); } 1612 UINT MCIWndGetDeviceID(HWND hwnd) 1613 { return cast(UINT)SendMessage(hwnd, MCIWNDM_GETDEVICEID, 0, 0); } 1614 UINT MCIWndGetAlias(HWND hwnd) 1615 { return cast(UINT)SendMessage(hwnd, MCIWNDM_GETALIAS, 0, 0); } 1616 LONG MCIWndGetMode(HWND hwnd, LPTSTR lp, UINT len) 1617 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETMODE, cast(WPARAM)len, cast(LPARAM)lp); } 1618 LONG MCIWndGetPosition(HWND hwnd) 1619 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETPOSITION, 0, 0); } 1620 LONG MCIWndGetPositionString(HWND hwnd, LPTSTR lp, UINT len) 1621 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETPOSITION, cast(WPARAM)len, cast(LPARAM)lp); } 1622 LONG MCIWndGetStart(HWND hwnd) 1623 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETSTART, 0, 0); } 1624 LONG MCIWndGetLength(HWND hwnd) 1625 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETLENGTH, 0, 0); } 1626 LONG MCIWndGetEnd(HWND hwnd) 1627 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETEND, 0, 0); } 1628 LONG MCIWndStep(HWND hwnd, LONG n) 1629 { return cast(LONG)SendMessage(hwnd, MCI_STEP, 0, cast(LPARAM)n); } 1630 void MCIWndDestroy(HWND hwnd) 1631 { SendMessage(hwnd, WM_CLOSE, 0, 0); } 1632 void MCIWndSetZoom(HWND hwnd, UINT iZoom) 1633 { SendMessage(hwnd, MCIWNDM_SETZOOM, 0, cast(LPARAM)iZoom); } 1634 UINT MCIWndGetZoom(HWND hwnd) 1635 { return cast(UINT)SendMessage(hwnd, MCIWNDM_GETZOOM, 0, 0); } 1636 LONG MCIWndSetVolume(HWND hwnd, UINT iVol) 1637 { return cast(LONG)SendMessage(hwnd, MCIWNDM_SETVOLUME, 0, cast(LPARAM)iVol); } 1638 LONG MCIWndGetVolume(HWND hwnd) 1639 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETVOLUME, 0, 0); } 1640 LONG MCIWndSetSpeed(HWND hwnd, UINT iSpeed) 1641 { return cast(LONG)SendMessage(hwnd, MCIWNDM_SETSPEED, 0, cast(LPARAM)iSpeed); } 1642 LONG MCIWndGetSpeed(HWND hwnd) 1643 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETSPEED, 0, 0); } 1644 LONG MCIWndSetTimeFormat(HWND hwnd, LPTSTR lp) 1645 { return cast(LONG)SendMessage(hwnd, MCIWNDM_SETTIMEFORMAT, 0, cast(LPARAM)lp); } 1646 LONG MCIWndUseFrames(HWND hwnd) 1647 { return MCIWndSetTimeFormat(hwnd, (cast(TCHAR[])"frames").ptr); } 1648 LONG MCIWndUseTime(HWND hwnd) 1649 { return MCIWndSetTimeFormat(hwnd, (cast(TCHAR[])"ms").ptr); } 1650 LONG MCIWndGetTimeFormat(HWND hwnd, LPTSTR lp, UINT len) 1651 { return cast(LONG)SendMessage(hwnd, MCIWNDM_GETTIMEFORMAT, cast(WPARAM)len, cast(LPARAM)lp); } 1652 void MCIWndValidateMedia(HWND hwnd) 1653 { SendMessage(hwnd, MCIWNDM_VALIDATEMEDIA, 0, 0); } 1654 void MCIWndSetRepeat(HWND hwnd, BOOL f) 1655 { SendMessage(hwnd, MCIWNDM_SETREPEAT, 0, cast(LPARAM)f); } 1656 BOOL MCIWndGetRepeat(HWND hwnd) 1657 { return cast(BOOL)SendMessage(hwnd, MCIWNDM_GETREPEAT, 0, 0); } 1658 void MCIWndSetActiveTimer(HWND hwnd, UINT active) 1659 { SendMessage(hwnd, MCIWNDM_SETACTIVETIMER, cast(WPARAM)active, 0); } 1660 void MCIWndSetInactiveTimer(HWND hwnd, UINT inactive) 1661 { SendMessage(hwnd, MCIWNDM_SETINACTIVETIMER, cast(WPARAM)inactive, 0); } 1662 void MCIWndSetTimers(HWND hwnd, UINT active, UINT inactive) 1663 { SendMessage(hwnd, MCIWNDM_SETTIMERS, cast(WPARAM)active, cast(LPARAM)inactive); } 1664 UINT MCIWndGetActiveTimer(HWND hwnd) 1665 { return cast(UINT)SendMessage(hwnd, MCIWNDM_GETACTIVETIMER, 0, 0); } 1666 UINT MCIWndGetInactiveTimer(HWND hwnd) 1667 { return cast(UINT)SendMessage(hwnd, MCIWNDM_GETINACTIVETIMER, 0, 0); } 1668 LONG MCIWndRealize(HWND hwnd, BOOL fBkgnd) 1669 { return cast(LONG) SendMessage(hwnd, MCIWNDM_REALIZE, cast(WPARAM)fBkgnd, 0); } 1670 LONG MCIWndSendString(HWND hwnd, LPTSTR sz) 1671 { return cast(LONG) SendMessage(hwnd, MCIWNDM_SENDSTRING, 0, cast(LPARAM)sz); } 1672 LONG MCIWndReturnString(HWND hwnd, LPVOID lp, UINT len) 1673 { return cast(LONG) SendMessage(hwnd, MCIWNDM_RETURNSTRING, cast(WPARAM)len, cast(LPARAM)lp); } 1674 LONG MCIWndGetError(HWND hwnd, LPVOID lp, UINT len) 1675 { return cast(LONG) SendMessage(hwnd, MCIWNDM_GETERROR, cast(WPARAM)len, cast(LPARAM)lp); } 1676 HPALETTE MCIWndGetPalette(HWND hwnd) 1677 { return cast(HPALETTE)SendMessage(hwnd, MCIWNDM_GETPALETTE, 0, 0); } 1678 LONG MCIWndSetPalette(HWND hwnd, HPALETTE hpal) 1679 { return cast(LONG) SendMessage(hwnd, MCIWNDM_SETPALETTE, cast(WPARAM)hpal, 0); } 1680 LONG MCIWndGetFileName(HWND hwnd, LPVOID lp, UINT len) 1681 { return cast(LONG) SendMessage(hwnd, MCIWNDM_GETFILENAME, cast(WPARAM)len, cast(LPARAM)lp); } 1682 LONG MCIWndGetDevice(HWND hwnd, LPVOID lp, UINT len) 1683 { return cast(LONG) SendMessage(hwnd, MCIWNDM_GETDEVICE, cast(WPARAM)len, cast(LPARAM)lp); } 1684 UINT MCIWndGetStyles(HWND hwnd) 1685 { return cast(UINT) SendMessage(hwnd, MCIWNDM_GETSTYLES, 0, 0); } 1686 LONG MCIWndChangeStyles(HWND hwnd, UINT mask, LONG value) 1687 { return cast(LONG) SendMessage(hwnd, MCIWNDM_CHANGESTYLES, cast(WPARAM)mask, cast(LPARAM)value); } 1688 LONG MCIWndOpenInterface(HWND hwnd, LPUNKNOWN pUnk) 1689 { return cast(LONG) SendMessage(hwnd, MCIWNDM_OPENINTERFACE, 0, cast(LPARAM)cast(void*)pUnk); } 1690 LONG MCIWndSetOwner(HWND hwnd, HWND hwndP) 1691 { return cast(LONG) SendMessage(hwnd, MCIWNDM_SETOWNER, cast(WPARAM)hwndP, 0); } 1692 1693 enum { 1694 MCIWNDM_GETDEVICEID = WM_USER + 100, 1695 MCIWNDM_SENDSTRINGA = WM_USER + 101, 1696 MCIWNDM_GETPOSITIONA = WM_USER + 102, 1697 MCIWNDM_GETSTART = WM_USER + 103, 1698 MCIWNDM_GETLENGTH = WM_USER + 104, 1699 MCIWNDM_GETEND = WM_USER + 105, 1700 MCIWNDM_GETMODEA = WM_USER + 106, 1701 MCIWNDM_EJECT = WM_USER + 107, 1702 MCIWNDM_SETZOOM = WM_USER + 108, 1703 MCIWNDM_GETZOOM = WM_USER + 109, 1704 MCIWNDM_SETVOLUME = WM_USER + 110, 1705 MCIWNDM_GETVOLUME = WM_USER + 111, 1706 MCIWNDM_SETSPEED = WM_USER + 112, 1707 MCIWNDM_GETSPEED = WM_USER + 113, 1708 MCIWNDM_SETREPEAT = WM_USER + 114, 1709 MCIWNDM_GETREPEAT = WM_USER + 115, 1710 MCIWNDM_REALIZE = WM_USER + 118, 1711 MCIWNDM_SETTIMEFORMATA = WM_USER + 119, 1712 MCIWNDM_GETTIMEFORMATA = WM_USER + 120, 1713 MCIWNDM_VALIDATEMEDIA = WM_USER + 121, 1714 MCIWNDM_PLAYFROM = WM_USER + 122, 1715 MCIWNDM_PLAYTO = WM_USER + 123, 1716 MCIWNDM_GETFILENAMEA = WM_USER + 124, 1717 MCIWNDM_GETDEVICEA = WM_USER + 125, 1718 MCIWNDM_GETPALETTE = WM_USER + 126, 1719 MCIWNDM_SETPALETTE = WM_USER + 127, 1720 MCIWNDM_GETERRORA = WM_USER + 128, 1721 MCIWNDM_SETTIMERS = WM_USER + 129, 1722 MCIWNDM_SETACTIVETIMER = WM_USER + 130, 1723 MCIWNDM_SETINACTIVETIMER = WM_USER + 131, 1724 MCIWNDM_GETACTIVETIMER = WM_USER + 132, 1725 MCIWNDM_GETINACTIVETIMER = WM_USER + 133, 1726 MCIWNDM_NEWA = WM_USER + 134, 1727 MCIWNDM_CHANGESTYLES = WM_USER + 135, 1728 MCIWNDM_GETSTYLES = WM_USER + 136, 1729 MCIWNDM_GETALIAS = WM_USER + 137, 1730 MCIWNDM_RETURNSTRINGA = WM_USER + 138, 1731 MCIWNDM_PLAYREVERSE = WM_USER + 139, 1732 MCIWNDM_GET_SOURCE = WM_USER + 140, 1733 MCIWNDM_PUT_SOURCE = WM_USER + 141, 1734 MCIWNDM_GET_DEST = WM_USER + 142, 1735 MCIWNDM_PUT_DEST = WM_USER + 143, 1736 MCIWNDM_CAN_PLAY = WM_USER + 144, 1737 MCIWNDM_CAN_WINDOW = WM_USER + 145, 1738 MCIWNDM_CAN_RECORD = WM_USER + 146, 1739 MCIWNDM_CAN_SAVE = WM_USER + 147, 1740 MCIWNDM_CAN_EJECT = WM_USER + 148, 1741 MCIWNDM_CAN_CONFIG = WM_USER + 149, 1742 MCIWNDM_PALETTEKICK = WM_USER + 150, 1743 MCIWNDM_OPENINTERFACE = WM_USER + 151, 1744 MCIWNDM_SETOWNER = WM_USER + 152, 1745 MCIWNDM_OPENA = WM_USER + 153, 1746 MCIWNDM_SENDSTRINGW = WM_USER + 201, 1747 MCIWNDM_GETPOSITIONW = WM_USER + 202, 1748 MCIWNDM_GETMODEW = WM_USER + 206, 1749 MCIWNDM_SETTIMEFORMATW = WM_USER + 219, 1750 MCIWNDM_GETTIMEFORMATW = WM_USER + 220, 1751 MCIWNDM_GETFILENAMEW = WM_USER + 224, 1752 MCIWNDM_GETDEVICEW = WM_USER + 225, 1753 MCIWNDM_GETERRORW = WM_USER + 228, 1754 MCIWNDM_NEWW = WM_USER + 234, 1755 MCIWNDM_RETURNSTRINGW = WM_USER + 238, 1756 MCIWNDM_OPENW = WM_USER + 252, 1757 } 1758 1759 version (Unicode) { 1760 alias MCIWNDM_SENDSTRINGW MCIWNDM_SENDSTRING; 1761 alias MCIWNDM_GETPOSITIONW MCIWNDM_GETPOSITION; 1762 alias MCIWNDM_GETMODEW MCIWNDM_GETMODE; 1763 alias MCIWNDM_SETTIMEFORMATW MCIWNDM_SETTIMEFORMAT; 1764 alias MCIWNDM_GETTIMEFORMATW MCIWNDM_GETTIMEFORMAT; 1765 alias MCIWNDM_GETFILENAMEW MCIWNDM_GETFILENAME; 1766 alias MCIWNDM_GETDEVICEW MCIWNDM_GETDEVICE; 1767 alias MCIWNDM_GETERRORW MCIWNDM_GETERROR; 1768 alias MCIWNDM_NEWW MCIWNDM_NEW; 1769 alias MCIWNDM_RETURNSTRINGW MCIWNDM_RETURNSTRING; 1770 alias MCIWNDM_OPENW MCIWNDM_OPEN; 1771 } else { // Unicode 1772 alias MCIWNDM_SENDSTRINGA MCIWNDM_SENDSTRING; 1773 alias MCIWNDM_GETPOSITIONA MCIWNDM_GETPOSITION; 1774 alias MCIWNDM_GETMODEA MCIWNDM_GETMODE; 1775 alias MCIWNDM_SETTIMEFORMATA MCIWNDM_SETTIMEFORMAT; 1776 alias MCIWNDM_GETTIMEFORMATA MCIWNDM_GETTIMEFORMAT; 1777 alias MCIWNDM_GETFILENAMEA MCIWNDM_GETFILENAME; 1778 alias MCIWNDM_GETDEVICEA MCIWNDM_GETDEVICE; 1779 alias MCIWNDM_GETERRORA MCIWNDM_GETERROR; 1780 alias MCIWNDM_NEWA MCIWNDM_NEW; 1781 alias MCIWNDM_RETURNSTRINGA MCIWNDM_RETURNSTRING; 1782 alias MCIWNDM_OPENA MCIWNDM_OPEN; 1783 } 1784 1785 enum { 1786 MCIWNDM_NOTIFYMODE = WM_USER + 200, 1787 MCIWNDM_NOTIFYPOS = WM_USER + 201, 1788 MCIWNDM_NOTIFYSIZE = WM_USER + 202, 1789 MCIWNDM_NOTIFYMEDIA = WM_USER + 203, 1790 MCIWNDM_NOTIFYERROR = WM_USER + 205, 1791 } 1792 1793 enum MCIWND_START = -1; 1794 enum MCIWND_END = -2; 1795 1796 enum { 1797 MCI_CLOSE = 0x0804, 1798 MCI_PLAY = 0x0806, 1799 MCI_SEEK = 0x0807, 1800 MCI_STOP = 0x0808, 1801 MCI_PAUSE = 0x0809, 1802 MCI_STEP = 0x080E, 1803 MCI_RECORD = 0x080F, 1804 MCI_SAVE = 0x0813, 1805 MCI_CUT = 0x0851, 1806 MCI_COPY = 0x0852, 1807 MCI_PASTE = 0x0853, 1808 MCI_RESUME = 0x0855, 1809 MCI_DELETE = 0x0856, 1810 } 1811 1812 enum { 1813 MCI_MODE_NOT_READY = 524, 1814 MCI_MODE_STOP, 1815 MCI_MODE_PLAY, 1816 MCI_MODE_RECORD, 1817 MCI_MODE_SEEK, 1818 MCI_MODE_PAUSE, 1819 MCI_MODE_OPEN, 1820 } 1821 1822 alias HVIDEO = HANDLE; 1823 alias LPHVIDEO = HVIDEO*; 1824 1825 // Error Return Values 1826 1827 enum { 1828 DV_ERR_OK = 0, 1829 DV_ERR_BASE = 1, 1830 DV_ERR_NONSPECIFIC = DV_ERR_BASE, 1831 DV_ERR_BADFORMAT = DV_ERR_BASE + 1, 1832 DV_ERR_STILLPLAYING = DV_ERR_BASE + 2, 1833 DV_ERR_UNPREPARED = DV_ERR_BASE + 3, 1834 DV_ERR_SYNC = DV_ERR_BASE + 4, 1835 DV_ERR_TOOMANYCHANNELS = DV_ERR_BASE + 5, 1836 DV_ERR_NOTDETECTED = DV_ERR_BASE + 6, 1837 DV_ERR_BADINSTALL = DV_ERR_BASE + 7, 1838 DV_ERR_CREATEPALETTE = DV_ERR_BASE + 8, 1839 DV_ERR_SIZEFIELD = DV_ERR_BASE + 9, 1840 DV_ERR_PARAM1 = DV_ERR_BASE + 10, 1841 DV_ERR_PARAM2 = DV_ERR_BASE + 11, 1842 DV_ERR_CONFIG1 = DV_ERR_BASE + 12, 1843 DV_ERR_CONFIG2 = DV_ERR_BASE + 13, 1844 DV_ERR_FLAGS = DV_ERR_BASE + 14, 1845 DV_ERR_13 = DV_ERR_BASE + 15, 1846 DV_ERR_NOTSUPPORTED = DV_ERR_BASE + 16, 1847 DV_ERR_NOMEM = DV_ERR_BASE + 17, 1848 DV_ERR_ALLOCATED = DV_ERR_BASE + 18, 1849 DV_ERR_BADDEVICEID = DV_ERR_BASE + 19, 1850 DV_ERR_INVALHANDLE = DV_ERR_BASE + 20, 1851 DV_ERR_BADERRNUM = DV_ERR_BASE + 21, 1852 DV_ERR_NO_BUFFERS = DV_ERR_BASE + 22, 1853 DV_ERR_MEM_CONFLICT = DV_ERR_BASE + 23, 1854 DV_ERR_IO_CONFLICT = DV_ERR_BASE + 24, 1855 DV_ERR_DMA_CONFLICT = DV_ERR_BASE + 25, 1856 DV_ERR_INT_CONFLICT = DV_ERR_BASE + 26, 1857 DV_ERR_PROTECT_ONLY = DV_ERR_BASE + 27, 1858 DV_ERR_LASTERROR = DV_ERR_BASE + 27, 1859 DV_ERR_USER_MSG = DV_ERR_BASE + 1000, 1860 } 1861 1862 // Callback Messages 1863 1864 enum { 1865 MM_DRVM_OPEN = 0x3D0, 1866 MM_DRVM_CLOSE, 1867 MM_DRVM_DATA, 1868 MM_DRVM_ERROR, 1869 } 1870 1871 enum { 1872 DV_VM_OPEN = MM_DRVM_OPEN, 1873 DV_VM_CLOSE = MM_DRVM_CLOSE, 1874 DV_VM_DATA = MM_DRVM_DATA, 1875 DV_VM_ERROR = MM_DRVM_ERROR, 1876 } 1877 1878 /** 1879 * Structures 1880 */ 1881 1882 struct VIDEOHDR { 1883 LPBYTE lpData; 1884 DWORD dwBufferLength; 1885 DWORD dwBytesUsed; 1886 DWORD dwTimeCaptured; 1887 DWORD_PTR dwUser; 1888 DWORD dwFlags; 1889 DWORD_PTR[4]dwReserved; 1890 } 1891 alias VIDEOHDR* PVIDEOHDR, LPVIDEOHDR; 1892 1893 enum { 1894 VHDR_DONE = 0x00000001, 1895 VHDR_PREPARED = 0x00000002, 1896 VHDR_INQUEUE = 0x00000004, 1897 VHDR_KEYFRAME = 0x00000008, 1898 VHDR_VALID = 0x0000000F, 1899 } 1900 1901 struct CHANNEL_CAPS { 1902 DWORD dwFlags; 1903 DWORD dwSrcRectXMod; 1904 DWORD dwSrcRectYMod; 1905 DWORD dwSrcRectWidthMod; 1906 DWORD dwSrcRectHeightMod; 1907 DWORD dwDstRectXMod; 1908 DWORD dwDstRectYMod; 1909 DWORD dwDstRectWidthMod; 1910 DWORD dwDstRectHeightMod; 1911 } 1912 alias CHANNEL_CAPS* PCHANNEL_CAPS, LPCHANNEL_CAPS; 1913 1914 enum { 1915 VCAPS_OVERLAY = 0x00000001, 1916 VCAPS_SRC_CAN_CLIP = 0x00000002, 1917 VCAPS_DST_CAN_CLIP = 0x00000004, 1918 VCAPS_CAN_SCALE = 0x00000008, 1919 } 1920 1921 /** 1922 * API Flags 1923 */ 1924 1925 enum { 1926 VIDEO_EXTERNALIN = 0x0001, 1927 VIDEO_EXTERNALOUT = 0x0002, 1928 VIDEO_IN = 0x0004, 1929 VIDEO_OUT = 0x0008, 1930 VIDEO_DLG_QUERY = 0x0010, 1931 } 1932 1933 enum { 1934 VIDEO_CONFIGURE_QUERYSIZE = 0x0001, 1935 VIDEO_CONFIGURE_CURRENT = 0x0010, 1936 VIDEO_CONFIGURE_NOMINAL = 0x0020, 1937 VIDEO_CONFIGURE_MIN = 0x0040, 1938 VIDEO_CONFIGURE_MAX = 0x0080, 1939 VIDEO_CONFIGURE_SET = 0x1000, 1940 VIDEO_CONFIGURE_GET = 0x2000, 1941 VIDEO_CONFIGURE_QUERY = 0x8000, 1942 } 1943 1944 /** 1945 * CONFIGURE MESSAGES 1946 */ 1947 1948 enum { 1949 DVM_USER = 0x4000, 1950 DVM_CONFIGURE_START = 0x1000, 1951 DVM_CONFIGURE_END = 0x1FFF, 1952 DVM_PALETTE = DVM_CONFIGURE_START + 1, 1953 DVM_FORMAT = DVM_CONFIGURE_START + 2, 1954 DVM_PALETTERGB555 = DVM_CONFIGURE_START + 3, 1955 DVM_SRC_RECT = DVM_CONFIGURE_START + 4, 1956 DVM_DST_RECT = DVM_CONFIGURE_START + 5, 1957 } 1958 1959 /** 1960 * AVICap window class 1961 */ 1962 1963 LRESULT AVICapSM(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) { 1964 if (IsWindow(hWnd)) { 1965 return SendMessage(hWnd, msg, wParam, lParam); 1966 } 1967 return 0; 1968 } 1969 1970 enum { 1971 WM_CAP_START = WM_USER, 1972 WM_CAP_UNICODE_START = WM_USER + 100, 1973 1974 WM_CAP_GET_CAPSTREAMPTR = WM_CAP_START + 1, 1975 WM_CAP_SET_CALLBACK_ERRORA = WM_CAP_START + 2, 1976 WM_CAP_SET_CALLBACK_STATUSA = WM_CAP_START + 3, 1977 1978 WM_CAP_SET_CALLBACK_ERRORW = WM_CAP_UNICODE_START + 2, 1979 WM_CAP_SET_CALLBACK_STATUSW = WM_CAP_UNICODE_START + 3, 1980 } 1981 1982 version (Unicode) { 1983 alias WM_CAP_SET_CALLBACK_ERRORW WM_CAP_SET_CALLBACK_ERROR; 1984 alias WM_CAP_SET_CALLBACK_STATUSW WM_CAP_SET_CALLBACK_STATUS; 1985 } else { // Unicode 1986 alias WM_CAP_SET_CALLBACK_ERRORA WM_CAP_SET_CALLBACK_ERROR; 1987 alias WM_CAP_SET_CALLBACK_STATUSA WM_CAP_SET_CALLBACK_STATUS; 1988 } 1989 1990 enum { 1991 WM_CAP_SET_CALLBACK_YIELD = WM_CAP_START + 4, 1992 WM_CAP_SET_CALLBACK_FRAME = WM_CAP_START + 5, 1993 WM_CAP_SET_CALLBACK_VIDEOSTREAM = WM_CAP_START + 6, 1994 WM_CAP_SET_CALLBACK_WAVESTREAM = WM_CAP_START + 7, 1995 WM_CAP_GET_USER_DATA = WM_CAP_START + 8, 1996 WM_CAP_SET_USER_DATA = WM_CAP_START + 9, 1997 WM_CAP_DRIVER_CONNECT = WM_CAP_START + 10, 1998 WM_CAP_DRIVER_DISCONNECT = WM_CAP_START + 11, 1999 WM_CAP_DRIVER_GET_NAMEA = WM_CAP_START + 12, 2000 WM_CAP_DRIVER_GET_VERSIONA = WM_CAP_START + 13, 2001 2002 WM_CAP_DRIVER_GET_NAMEW = WM_CAP_UNICODE_START + 12, 2003 WM_CAP_DRIVER_GET_VERSIONW = WM_CAP_UNICODE_START + 13, 2004 } 2005 2006 version (Unicode) { 2007 alias WM_CAP_DRIVER_GET_NAMEW WM_CAP_DRIVER_GET_NAME; 2008 alias WM_CAP_DRIVER_GET_VERSIONW WM_CAP_DRIVER_GET_VERSION; 2009 } else { // Unicode 2010 alias WM_CAP_DRIVER_GET_NAMEA WM_CAP_DRIVER_GET_NAME; 2011 alias WM_CAP_DRIVER_GET_VERSIONA WM_CAP_DRIVER_GET_VERSION; 2012 } 2013 2014 enum { 2015 WM_CAP_DRIVER_GET_CAPS = WM_CAP_START + 14, 2016 WM_CAP_FILE_SET_CAPTURE_FILEA = WM_CAP_START + 20, 2017 WM_CAP_FILE_GET_CAPTURE_FILEA = WM_CAP_START + 21, 2018 WM_CAP_FILE_SAVEASA = WM_CAP_START + 23, 2019 WM_CAP_FILE_SAVEDIBA = WM_CAP_START + 25, 2020 2021 WM_CAP_FILE_SET_CAPTURE_FILEW = WM_CAP_UNICODE_START + 20, 2022 WM_CAP_FILE_GET_CAPTURE_FILEW = WM_CAP_UNICODE_START + 21, 2023 WM_CAP_FILE_SAVEASW = WM_CAP_UNICODE_START + 23, 2024 WM_CAP_FILE_SAVEDIBW = WM_CAP_UNICODE_START + 25, 2025 } 2026 2027 version (Unicode) { 2028 alias WM_CAP_FILE_SET_CAPTURE_FILE = WM_CAP_FILE_SET_CAPTURE_FILEW; 2029 alias WM_CAP_FILE_GET_CAPTURE_FILE = WM_CAP_FILE_GET_CAPTURE_FILEW; 2030 alias WM_CAP_FILE_SAVEASW WM_CAP_FILE_SAVEAS; 2031 alias WM_CAP_FILE_SAVEDIBW WM_CAP_FILE_SAVEDIB; 2032 } else { // Unicode 2033 alias WM_CAP_FILE_SET_CAPTURE_FILE = WM_CAP_FILE_SET_CAPTURE_FILEA; 2034 alias WM_CAP_FILE_GET_CAPTURE_FILE = WM_CAP_FILE_GET_CAPTURE_FILEA; 2035 alias WM_CAP_FILE_SAVEASA WM_CAP_FILE_SAVEAS; 2036 alias WM_CAP_FILE_SAVEDIBA WM_CAP_FILE_SAVEDIB; 2037 } 2038 2039 enum { 2040 WM_CAP_FILE_ALLOCATE = WM_CAP_START + 22, 2041 WM_CAP_FILE_SET_INFOCHUNK = WM_CAP_START + 24, 2042 WM_CAP_EDIT_COPY = WM_CAP_START + 30, 2043 WM_CAP_SET_AUDIOFORMAT = WM_CAP_START + 35, 2044 WM_CAP_GET_AUDIOFORMAT = WM_CAP_START + 36, 2045 WM_CAP_DLG_VIDEOFORMAT = WM_CAP_START + 41, 2046 WM_CAP_DLG_VIDEOSOURCE = WM_CAP_START + 42, 2047 WM_CAP_DLG_VIDEODISPLAY = WM_CAP_START + 43, 2048 WM_CAP_GET_VIDEOFORMAT = WM_CAP_START + 44, 2049 WM_CAP_SET_VIDEOFORMAT = WM_CAP_START + 45, 2050 WM_CAP_DLG_VIDEOCOMPRESSION = WM_CAP_START + 46, 2051 WM_CAP_SET_PREVIEW = WM_CAP_START + 50, 2052 WM_CAP_SET_OVERLAY = WM_CAP_START + 51, 2053 WM_CAP_SET_PREVIEWRATE = WM_CAP_START + 52, 2054 WM_CAP_SET_SCALE = WM_CAP_START + 53, 2055 WM_CAP_GET_STATUS = WM_CAP_START + 54, 2056 WM_CAP_SET_SCROLL = WM_CAP_START + 55, 2057 WM_CAP_GRAB_FRAME = WM_CAP_START + 60, 2058 WM_CAP_GRAB_FRAME_NOSTOP = WM_CAP_START + 61, 2059 WM_CAP_SEQUENCE = WM_CAP_START + 62, 2060 WM_CAP_SEQUENCE_NOFILE = WM_CAP_START + 63, 2061 WM_CAP_SET_SEQUENCE_SETUP = WM_CAP_START + 64, 2062 WM_CAP_GET_SEQUENCE_SETUP = WM_CAP_START + 65, 2063 WM_CAP_SET_MCI_DEVICEA = WM_CAP_START + 66, 2064 WM_CAP_GET_MCI_DEVICEA = WM_CAP_START + 67, 2065 2066 WM_CAP_SET_MCI_DEVICEW = WM_CAP_UNICODE_START + 66, 2067 WM_CAP_GET_MCI_DEVICEW = WM_CAP_UNICODE_START + 67, 2068 } 2069 2070 version (Unicode) { 2071 alias WM_CAP_SET_MCI_DEVICEW WM_CAP_SET_MCI_DEVICE; 2072 alias WM_CAP_GET_MCI_DEVICEW WM_CAP_GET_MCI_DEVICE; 2073 } else { // Unicode 2074 alias WM_CAP_SET_MCI_DEVICEA WM_CAP_SET_MCI_DEVICE; 2075 alias WM_CAP_GET_MCI_DEVICEA WM_CAP_GET_MCI_DEVICE; 2076 } 2077 2078 enum { 2079 WM_CAP_STOP = WM_CAP_START + 68, 2080 WM_CAP_ABORT = WM_CAP_START + 69, 2081 WM_CAP_SINGLE_FRAME_OPEN = WM_CAP_START + 70, 2082 WM_CAP_SINGLE_FRAME_CLOSE = WM_CAP_START + 71, 2083 WM_CAP_SINGLE_FRAME = WM_CAP_START + 72, 2084 WM_CAP_PAL_OPENA = WM_CAP_START + 80, 2085 WM_CAP_PAL_SAVEA = WM_CAP_START + 81, 2086 2087 WM_CAP_PAL_OPENW = WM_CAP_UNICODE_START + 80, 2088 WM_CAP_PAL_SAVEW = WM_CAP_UNICODE_START + 81, 2089 } 2090 2091 version (Unicode) { 2092 alias WM_CAP_PAL_OPENW WM_CAP_PAL_OPEN; 2093 alias WM_CAP_PAL_SAVEW WM_CAP_PAL_SAVE; 2094 } else { // Unicode 2095 alias WM_CAP_PAL_OPENA WM_CAP_PAL_OPEN; 2096 alias WM_CAP_PAL_SAVEA WM_CAP_PAL_SAVE; 2097 } 2098 2099 enum { 2100 WM_CAP_PAL_PASTE = WM_CAP_START + 82, 2101 WM_CAP_PAL_AUTOCREATE = WM_CAP_START + 83, 2102 WM_CAP_PAL_MANUALCREATE = WM_CAP_START + 84, 2103 WM_CAP_SET_CALLBACK_CAPCONTROL = WM_CAP_START + 85, 2104 WM_CAP_UNICODE_END = WM_CAP_PAL_SAVEW, 2105 WM_CAP_END = WM_CAP_UNICODE_END, 2106 } 2107 2108 /** 2109 * message wrapper 2110 */ 2111 2112 BOOL capSetCallbackOnError(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_ERROR, 0, cast(LPARAM)fpProc); } 2113 BOOL capSetCallbackOnStatus(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_STATUS, 0, cast(LPARAM)fpProc); } 2114 BOOL capSetCallbackOnYield(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_YIELD, 0, cast(LPARAM)fpProc); } 2115 BOOL capSetCallbackOnFrame(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_FRAME, 0, cast(LPARAM)fpProc); } 2116 BOOL capSetCallbackOnVideoStream(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_VIDEOSTREAM, 0, cast(LPARAM)fpProc); } 2117 BOOL capSetCallbackOnWaveStream(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_WAVESTREAM, 0, cast(LPARAM)fpProc); } 2118 BOOL capSetCallbackOnCapControl(HWND hWnd, LPVOID fpProc) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_CALLBACK_CAPCONTROL, 0, cast(LPARAM)fpProc); } 2119 2120 BOOL capSetUserData(HWND hWnd, LPARAM lUser) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_USER_DATA, 0, lUser); } 2121 BOOL capGetUserData(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GET_USER_DATA, 0, 0); } 2122 2123 BOOL capDriverConnect(HWND hWnd, WPARAM i) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_CONNECT, i, 0); } 2124 BOOL capDriverDisconnect(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_DISCONNECT, 0, 0); } 2125 BOOL capDriverGetName(HWND hWnd, LPTSTR szName, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_GET_NAME, wSize, cast(LPARAM)szName); } 2126 BOOL capDriverGetVersion(HWND hWnd, LPTSTR szVer, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_GET_VERSION, wSize, cast(LPARAM)szVer); } 2127 BOOL capDriverGetCaps(HWND hWnd, LPCAPDRIVERCAPS s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DRIVER_GET_CAPS, wSize, cast(LPARAM)s); } 2128 2129 BOOL capFileSetCaptureFile(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_SET_CAPTURE_FILE, 0, cast(LPARAM)szName); } 2130 BOOL capFileGetCaptureFile(HWND hWnd, LPTSTR szName, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_GET_CAPTURE_FILE, wSize, cast(LPARAM)szName); } 2131 BOOL capFileAlloc(HWND hWnd, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_ALLOCATE, wSize, 0); } 2132 BOOL capFileSaveAs(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_SAVEAS, 0, cast(LPARAM)szName); } 2133 BOOL capFileSetInfoChunk(HWND hWnd, LPCAPINFOCHUNK lpInfoChunk) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_SET_INFOCHUNK, 0, cast(LPARAM)lpInfoChunk); } 2134 BOOL capFileSaveDIB(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_FILE_SAVEDIB, 0, cast(LPARAM)szName); } 2135 2136 BOOL capEditCopy(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_EDIT_COPY, 0, 0); } 2137 2138 BOOL capSetAudioFormat(HWND hWnd, LPWAVEFORMATEX s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_AUDIOFORMAT, wSize, cast(LPARAM)s); } 2139 DWORD capGetAudioFormat(HWND hWnd, LPWAVEFORMATEX s, WPARAM wSize) { return cast(DWORD)AVICapSM(hWnd, WM_CAP_GET_AUDIOFORMAT, wSize, cast(LPARAM)s); } 2140 DWORD capGetAudioFormatSize(HWND hWnd) { return cast(DWORD)AVICapSM(hWnd, WM_CAP_GET_AUDIOFORMAT, 0, 0); } 2141 2142 BOOL capDlgVideoFormat(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DLG_VIDEOFORMAT, 0, 0); } 2143 BOOL capDlgVideoSource(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DLG_VIDEOSOURCE, 0, 0); } 2144 BOOL capDlgVideoDisplay(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DLG_VIDEODISPLAY, 0, 0); } 2145 BOOL capDlgVideoCompression(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_DLG_VIDEOCOMPRESSION, 0, 0); } 2146 2147 DWORD capGetVideoFormat(HWND hWnd, void* s, WPARAM wSize) { return cast(DWORD)AVICapSM(hWnd, WM_CAP_GET_VIDEOFORMAT, wSize, cast(LPARAM)s); } 2148 DWORD capGetVideoFormatSize(HWND hWnd) { return cast(DWORD)AVICapSM(hWnd, WM_CAP_GET_VIDEOFORMAT, 0, 0); } 2149 BOOL capSetVideoFormat(HWND hWnd, void* s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_VIDEOFORMAT, wSize, cast(LPARAM)s); } 2150 2151 BOOL capPreview(HWND hWnd, BOOL f) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_PREVIEW, cast(WPARAM)f, 0); } 2152 BOOL capPreviewRate(HWND hWnd, WPARAM wMS) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_PREVIEWRATE, wMS, 0); } 2153 BOOL capOverlay(HWND hWnd, BOOL f) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_OVERLAY, cast(WPARAM)f, 0); } 2154 BOOL capPreviewScale(HWND hWnd, BOOL f) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_SCALE, cast(WPARAM)f, 0); } 2155 BOOL capGetStatus(HWND hWnd, LPCAPSTATUS s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GET_STATUS, wSize, cast(LPARAM)s); } 2156 BOOL capSetScrollPos(HWND hWnd, LPPOINT lpP) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_SCROLL, 0, cast(LPARAM)lpP); } 2157 2158 BOOL capGrabFrame(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GRAB_FRAME, 0, 0); } 2159 BOOL capGrabFrameNoStop(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GRAB_FRAME_NOSTOP, 0, 0); } 2160 2161 BOOL capCaptureSequence(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SEQUENCE, 0, 0); } 2162 BOOL capCaptureSequenceNoFile(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SEQUENCE_NOFILE, 0, 0); } 2163 BOOL capCaptureStop(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_STOP, 0, 0); } 2164 BOOL capCaptureAbort(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_ABORT, 0, 0); } 2165 2166 BOOL capCaptureSingleFrameOpen(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SINGLE_FRAME_OPEN, 0, 0); } 2167 BOOL capCaptureSingleFrameClose(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SINGLE_FRAME_CLOSE, 0, 0); } 2168 BOOL capCaptureSingleFrame(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SINGLE_FRAME, 0, 0); } 2169 2170 BOOL capCaptureGetSetup(HWND hWnd, LPCAPTUREPARMS s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GET_SEQUENCE_SETUP, wSize, cast(LPARAM)s); } 2171 BOOL capCaptureSetSetup(HWND hWnd, LPCAPTUREPARMS s, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_SEQUENCE_SETUP, wSize, cast(LPARAM)s); } 2172 2173 BOOL capSetMCIDeviceName(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_SET_MCI_DEVICE, 0, cast(LPARAM)szName); } 2174 BOOL capGetMCIDeviceName(HWND hWnd, LPTSTR szName, WPARAM wSize) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_GET_MCI_DEVICE, wSize, cast(LPARAM)szName); } 2175 2176 BOOL capPaletteOpen(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_OPEN, 0, cast(LPARAM)szName); } 2177 BOOL capPaletteSave(HWND hWnd, LPTSTR szName) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_SAVE, 0, cast(LPARAM)szName); } 2178 BOOL capPalettePaste(HWND hWnd) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_PASTE, 0, 0); } 2179 BOOL capPaletteAuto(HWND hWnd, WPARAM iFrames, LPARAM iColors) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_AUTOCREATE, iFrames, iColors); } 2180 BOOL capPaletteManual(HWND hWnd, WPARAM fGrab, LPARAM iColors) { return cast(BOOL)AVICapSM(hWnd, WM_CAP_PAL_MANUALCREATE, fGrab, iColors); } 2181 2182 /** 2183 * structs 2184 */ 2185 2186 struct CAPDRIVERCAPS { 2187 UINT wDeviceIndex; 2188 BOOL fHasOverlay; 2189 BOOL fHasDlgVideoSource; 2190 BOOL fHasDlgVideoFormat; 2191 BOOL fHasDlgVideoDisplay; 2192 BOOL fCaptureInitialized; 2193 BOOL fDriverSuppliesPalettes; 2194 HANDLE hVideoIn; 2195 HANDLE hVideoOut; 2196 HANDLE hVideoExtIn; 2197 HANDLE hVideoExtOut; 2198 } 2199 alias CAPDRIVERCAPS* PCAPDRIVERCAPS, LPCAPDRIVERCAPS; 2200 2201 struct CAPSTATUS { 2202 UINT uiImageWidth; 2203 UINT uiImageHeight; 2204 BOOL fLiveWindow; 2205 BOOL fOverlayWindow; 2206 BOOL fScale; 2207 POINT ptScroll; 2208 BOOL fUsingDefaultPalette; 2209 BOOL fAudioHardware; 2210 BOOL fCapFileExists; 2211 DWORD dwCurrentVideoFrame; 2212 DWORD dwCurrentVideoFramesDropped; 2213 DWORD dwCurrentWaveSamples; 2214 DWORD dwCurrentTimeElapsedMS; 2215 HPALETTE hPalCurrent; 2216 BOOL fCapturingNow; 2217 DWORD dwReturn; 2218 UINT wNumVideoAllocated; 2219 UINT wNumAudioAllocated; 2220 } 2221 alias CAPSTATUS* PCAPSTATUS, LPCAPSTATUS; 2222 2223 struct CAPTUREPARMS { 2224 DWORD dwRequestMicroSecPerFrame; 2225 BOOL fMakeUserHitOKToCapture; 2226 UINT wPercentDropForError; 2227 BOOL fYield; 2228 DWORD dwIndexSize; 2229 UINT wChunkGranularity; 2230 BOOL fUsingDOSMemory; 2231 UINT wNumVideoRequested; 2232 BOOL fCaptureAudio; 2233 UINT wNumAudioRequested; 2234 UINT vKeyAbort; 2235 BOOL fAbortLeftMouse; 2236 BOOL fAbortRightMouse; 2237 BOOL fLimitEnabled; 2238 UINT wTimeLimit; 2239 BOOL fMCIControl; 2240 BOOL fStepMCIDevice; 2241 DWORD dwMCIStartTime; 2242 DWORD dwMCIStopTime; 2243 BOOL fStepCaptureAt2x; 2244 UINT wStepCaptureAverageFrames; 2245 DWORD dwAudioBufferSize; 2246 BOOL fDisableWriteCache; 2247 UINT AVStreamMaster; 2248 } 2249 alias CAPTUREPARMS* PCAPTUREPARMS, LPCAPTUREPARMS; 2250 2251 enum AVSTREAMMASTER_AUDIO = 0; 2252 enum AVSTREAMMASTER_NONE = 1; 2253 2254 struct CAPINFOCHUNK { 2255 FOURCC fccInfoID; 2256 LPVOID lpData; 2257 LONG cbData; 2258 } 2259 alias CAPINFOCHUNK* PCAPINFOCHUNK, LPCAPINFOCHUNK; 2260 2261 // Callback Definitions 2262 2263 extern (Windows) { 2264 alias LRESULT function(HWND hWnd) CAPYIELDCALLBACK; 2265 alias LRESULT function(HWND hWnd, int nID, LPCWSTR lpsz) CAPSTATUSCALLBACKW; 2266 alias LRESULT function(HWND hWnd, int nID, LPCWSTR lpsz) CAPERRORCALLBACKW; 2267 alias LRESULT function(HWND hWnd, int nID, LPCSTR lpsz) CAPSTATUSCALLBACKA; 2268 alias LRESULT function(HWND hWnd, int nID, LPCSTR lpsz) CAPERRORCALLBACKA; 2269 } 2270 2271 version (Unicode) { 2272 alias CAPSTATUSCALLBACKW CAPSTATUSCALLBACK; 2273 alias CAPERRORCALLBACKW CAPERRORCALLBACK; 2274 } else { // Unicode 2275 alias CAPSTATUSCALLBACKA CAPSTATUSCALLBACK; 2276 alias CAPERRORCALLBACKA CAPERRORCALLBACK; 2277 } 2278 2279 extern (Windows) { 2280 alias LRESULT function(HWND hWnd, LPVIDEOHDR lpVHdr) CAPVIDEOCALLBACK; 2281 alias LRESULT function(HWND hWnd, LPWAVEHDR lpWHdr) CAPWAVECALLBACK; 2282 alias LRESULT function(HWND hWnd, int nState) CAPCONTROLCALLBACK; 2283 } 2284 2285 // CapControlCallback states 2286 enum CONTROLCALLBACK_PREROLL = 1; 2287 enum CONTROLCALLBACK_CAPTURING = 2; 2288 2289 extern (Windows) { 2290 HWND capCreateCaptureWindowA(LPCSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hwndParent, int nID); 2291 BOOL capGetDriverDescriptionA(UINT wDriverIndex, LPSTR lpszName, int cbName, LPSTR lpszVer, int cbVer); 2292 HWND capCreateCaptureWindowW(LPCWSTR lpszWindowName, DWORD dwStyle, int x, int y, int nWidth, int nHeight, HWND hwndParent, int nID); 2293 BOOL capGetDriverDescriptionW(UINT wDriverIndex, LPWSTR lpszName, int cbName, LPWSTR lpszVer, int cbVer); 2294 } 2295 2296 version (Unicode) { 2297 alias capCreateCaptureWindowW capCreateCaptureWindow; 2298 alias capGetDriverDescriptionW capGetDriverDescription; 2299 } else { // Unicode 2300 alias capCreateCaptureWindowA capCreateCaptureWindow; 2301 alias capGetDriverDescriptionA capGetDriverDescription; 2302 } 2303 2304 // New Information chunk IDs 2305 enum infotypeDIGITIZATION_TIME = mmioFOURCC!('I', 'D', 'I', 'T'); 2306 enum infotypeSMPTE_TIME = mmioFOURCC!('I', 'S', 'M', 'P'); 2307 2308 // status and error callbacks 2309 enum { 2310 IDS_CAP_BEGIN = 300, 2311 IDS_CAP_END = 301, 2312 2313 IDS_CAP_INFO = 401, 2314 IDS_CAP_OUTOFMEM = 402, 2315 IDS_CAP_FILEEXISTS = 403, 2316 IDS_CAP_ERRORPALOPEN = 404, 2317 IDS_CAP_ERRORPALSAVE = 405, 2318 IDS_CAP_ERRORDIBSAVE = 406, 2319 IDS_CAP_DEFAVIEXT = 407, 2320 IDS_CAP_DEFPALEXT = 408, 2321 IDS_CAP_CANTOPEN = 409, 2322 IDS_CAP_SEQ_MSGSTART = 410, 2323 IDS_CAP_SEQ_MSGSTOP = 411, 2324 2325 IDS_CAP_VIDEDITERR = 412, 2326 IDS_CAP_READONLYFILE = 413, 2327 IDS_CAP_WRITEERROR = 414, 2328 IDS_CAP_NODISKSPACE = 415, 2329 IDS_CAP_SETFILESIZE = 416, 2330 IDS_CAP_SAVEASPERCENT = 417, 2331 2332 IDS_CAP_DRIVER_ERROR = 418, 2333 2334 IDS_CAP_WAVE_OPEN_ERROR = 419, 2335 IDS_CAP_WAVE_ALLOC_ERROR = 420, 2336 IDS_CAP_WAVE_PREPARE_ERROR = 421, 2337 IDS_CAP_WAVE_ADD_ERROR = 422, 2338 IDS_CAP_WAVE_SIZE_ERROR = 423, 2339 2340 IDS_CAP_VIDEO_OPEN_ERROR = 424, 2341 IDS_CAP_VIDEO_ALLOC_ERROR = 425, 2342 IDS_CAP_VIDEO_PREPARE_ERROR = 426, 2343 IDS_CAP_VIDEO_ADD_ERROR = 427, 2344 IDS_CAP_VIDEO_SIZE_ERROR = 428, 2345 2346 IDS_CAP_FILE_OPEN_ERROR = 429, 2347 IDS_CAP_FILE_WRITE_ERROR = 430, 2348 IDS_CAP_RECORDING_ERROR = 431, 2349 IDS_CAP_RECORDING_ERROR2 = 432, 2350 IDS_CAP_AVI_INIT_ERROR = 433, 2351 IDS_CAP_NO_FRAME_CAP_ERROR = 434, 2352 IDS_CAP_NO_PALETTE_WARN = 435, 2353 IDS_CAP_MCI_CONTROL_ERROR = 436, 2354 IDS_CAP_MCI_CANT_STEP_ERROR = 437, 2355 IDS_CAP_NO_AUDIO_CAP_ERROR = 438, 2356 IDS_CAP_AVI_DRAWDIB_ERROR = 439, 2357 IDS_CAP_COMPRESSOR_ERROR = 440, 2358 IDS_CAP_AUDIO_DROP_ERROR = 441, 2359 IDS_CAP_AUDIO_DROP_COMPERROR = 442, 2360 2361 IDS_CAP_STAT_LIVE_MODE = 500, 2362 IDS_CAP_STAT_OVERLAY_MODE = 501, 2363 IDS_CAP_STAT_CAP_INIT = 502, 2364 IDS_CAP_STAT_CAP_FINI = 503, 2365 IDS_CAP_STAT_PALETTE_BUILD = 504, 2366 IDS_CAP_STAT_OPTPAL_BUILD = 505, 2367 IDS_CAP_STAT_I_FRAMES = 506, 2368 IDS_CAP_STAT_L_FRAMES = 507, 2369 IDS_CAP_STAT_CAP_L_FRAMES = 508, 2370 IDS_CAP_STAT_CAP_AUDIO = 509, 2371 IDS_CAP_STAT_VIDEOCURRENT = 510, 2372 IDS_CAP_STAT_VIDEOAUDIO = 511, 2373 IDS_CAP_STAT_VIDEOONLY = 512, 2374 IDS_CAP_STAT_FRAMESDROPPED = 513, 2375 } 2376 2377 /** 2378 * FilePreview dialog. 2379 */ 2380 2381 extern (Windows) { 2382 BOOL GetOpenFileNamePreviewA(LPOPENFILENAMEA lpofn); 2383 BOOL GetSaveFileNamePreviewA(LPOPENFILENAMEA lpofn); 2384 BOOL GetOpenFileNamePreviewW(LPOPENFILENAMEW lpofn); 2385 BOOL GetSaveFileNamePreviewW(LPOPENFILENAMEW lpofn); 2386 } 2387 2388 version (Unicode) { 2389 alias GetOpenFileNamePreviewW GetOpenFileNamePreview; 2390 alias GetSaveFileNamePreviewW GetSaveFileNamePreview; 2391 } else { // Unicode 2392 alias GetOpenFileNamePreviewA GetOpenFileNamePreview; 2393 alias GetSaveFileNamePreviewA GetSaveFileNamePreview; 2394 }