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