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