From 6fcba1ced4f6551b6ff831391ae6490bba6da25a Mon Sep 17 00:00:00 2001 From: baldurk Date: Wed, 12 Dec 2018 13:50:02 +0000 Subject: [PATCH] Add use of MediaFoundation to decode video in D3D11 video texture demo * Where available - on Win8+ basically. On win7 the video doesn't play (but most of the demo also doesn't work, so that's not much change). * Added a short 10kb clip from Caminandes (http://www.caminandes.com/sharing) --- util/test/LICENSE.md | 23 - util/test/README.md | 2 + util/test/data/demos/README.md | 3 + .../data/demos/h264_yu420p_192x108_24fps.mp4 | Bin 0 -> 9547 bytes .../test/demos/d3d11/d3d11_video_textures.cpp | 239 +- util/test/demos/dx/official/mfapi.h | 4418 ++++ util/test/demos/dx/official/mfidl.h | 21182 ++++++++++++++++ util/test/demos/dx/official/mfmediaengine.h | 8806 +++++++ util/test/demos/dx/official/mfobjects.h | 6630 +++++ util/test/demos/dx/official/mftransform.h | 1317 + 10 files changed, 42596 insertions(+), 24 deletions(-) delete mode 100644 util/test/LICENSE.md create mode 100644 util/test/data/demos/README.md create mode 100644 util/test/data/demos/h264_yu420p_192x108_24fps.mp4 create mode 100644 util/test/demos/dx/official/mfapi.h create mode 100644 util/test/demos/dx/official/mfidl.h create mode 100644 util/test/demos/dx/official/mfmediaengine.h create mode 100644 util/test/demos/dx/official/mfobjects.h create mode 100644 util/test/demos/dx/official/mftransform.h diff --git a/util/test/LICENSE.md b/util/test/LICENSE.md deleted file mode 100644 index 7e9e68a2b..000000000 --- a/util/test/LICENSE.md +++ /dev/null @@ -1,23 +0,0 @@ -RenderDoc and this autotesting suite is licensed under the MIT License: - -> The MIT License (MIT) -> -> Copyright (c) 2015 Baldur Karlsson -> -> Permission is hereby granted, free of charge, to any person obtaining a copy -> of this software and associated documentation files (the "Software"), to deal -> in the Software without restriction, including without limitation the rights -> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -> copies of the Software, and to permit persons to whom the Software is -> furnished to do so, subject to the following conditions: -> -> The above copyright notice and this permission notice shall be included in -> all copies or substantial portions of the Software. -> -> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN -> THE SOFTWARE. diff --git a/util/test/README.md b/util/test/README.md index 5edee2de0..98244e19e 100644 --- a/util/test/README.md +++ b/util/test/README.md @@ -53,3 +53,5 @@ License RenderDoc is released under the MIT license, see [the main github repository](https://github.com/baldurk/renderdoc) for full details. The tests use [GLAD](https://github.com/Dav1dde/glad) for extension loading, which is MIT licensed. [LZ4](https://github.com/lz4/lz4) for compression, which is BSD licensed. [volk](https://github.com/zeux/volk) for vulkan loading, which is MIT licensed. [nuklear](https://github.com/vurtun/nuklear) for the launcher UI, which is MIT licensed. [shaderc](https://github.com/google/shaderc) for building SPIR-V shaders, which is Apache-2.0 licensed. + +A short clip from [Caminandes](http://www.caminandes.com/), available under the [Creative Commons Attribution 3.0 license (CC) caminandes.com](http://www.caminandes.com/sharing/), is used as a demo video. diff --git a/util/test/data/demos/README.md b/util/test/data/demos/README.md new file mode 100644 index 000000000..ff28d4425 --- /dev/null +++ b/util/test/data/demos/README.md @@ -0,0 +1,3 @@ +External data for use with demos, where not feasible to embed in the application. + +* `h264_yu420p_192x108_24fps.mp4.mp4` - 2 second clip encoded from [Caminandes](http://www.caminandes.com), available under the [Creative Commons Attribution 3.0 license (CC) caminandes.com](http://www.caminandes.com/sharing/). diff --git a/util/test/data/demos/h264_yu420p_192x108_24fps.mp4 b/util/test/data/demos/h264_yu420p_192x108_24fps.mp4 new file mode 100644 index 0000000000000000000000000000000000000000..db6e795e68c27303c83179932543453250ed933e GIT binary patch literal 9547 zcmd6NXH=8hwrJ>rf^R76BT1f)p^ zMVb`B0!SB8n($V1?{oG&_l@`d-Er3#Gjpz4SDEw6`U(UBfqD`{acBb84+0^FkT3ul zWRN@D4<`qQKp@9F@hB7o!q@HRfg}Q*Z`4#rM{84hOHE%U^y@Mu#-S5}YwIC03UW|M zs5=&qg2Lrxpm-T2c{wOb87Z$UEeiztFrXl1VybsuQVxo+)&ZIxD0d*x!Qw(OC{H3( zMp{}{QbroC2$L4@8Mp)-4)sJ5h%PvSFB(VE_~Re|=YsY0B%p}u zk}^=DHy&6Jz~C`htS{0VbX@-C!Jz~U+8vDLZ-z9~AOAasJK7IPB#i^@PekD{NT3Ax zZkRwkGStN#>xV-ULEjxL5fP6>`vVt15sxJ4c;bwsH_;8qusD>zix(CLq<@$=VCsts1-{i~2UHs7g>N0Xr zf;-9|my;$96OSYT&|);zsyp^u~?S z?dfm!=#HIXlkkQ9=nI|K6=s@LFKl!qeSGrFI^Qv(Y0eF%fhY0{ zs?NZZUaw-03jA~8)Tey!$$kIc;_}66qXs>g!r`OO%w83pr&u*7)cvMr@6AQOn{J#> z94mt`ba>y#JJjDXWjkR{&+VUAHEF${Pv^NEovrQ}J5$UREl;tFi z!NXD7$4N@v8H--laUbL{xnoiLlhCJSVsUgC)_iPn!|N1l8wWY7k_L>I;uf!gM9G6ZcV|!jhbAb7iSw4yProlSQcHm5TsShcQS7eF@0$(k9+SlgJ%HEJO#TP0N9f9h4N4E9r4 zX#K@W9~X-KruF&-eBpI3%Od6qzs$q-A!BctUmmw;o_Z@kJ-gnpThAJ^^${ak%w>OnwYX4hvVY>kxTA!* z_N1UA&Gg$4GYRhQ(}MzyD^Q(>jH$FeO2aqfAjlonn~UrMRN_w395dYf2Kh_!U-M47 z;YQ^>&UoE<$ZjR#&=R?@1oaPaNph~V%{T6|b?ec>P~Jku zJCg#$jY^0=yOhC@ey`?xL!qj?bz)-WSYIz8x^MNfNM5*8fy-S9kkzY}f^SQzZZRD3 zow!3dnSYSGAC}S}kj_-lJms-_y-TW1ZCepYHmJ zf((ozA(`*g{ms`s6?Su2uG3uAL%-*}uOD)Vb9Cf1h45#67*vw4*k}6?sDHm==k`M` zRNLgi*zFCgA9RiD7V4v92(;eFWBeU13Ym`l@NBNF<1Hmr?_2shhTWK3E~Kn(EuaHx zx6dW*zKHqUq-#Xi)49kz5@={*UUJ`cpH8t}L;o@ZZ5N}9g+rm{4l1FcN#sN7&ZntL zxLk3$=r;k4FKOH|Q>9EB8tL-aD7jzJ9M$It+}_BeSyPg0x)GD77o+UD(9$gnU+q3W z*?r=&|M=a^2tu^T_v6|pzIQ*d0bf;-f zI3r1jYSpHg_c;IeMUStwlqVb9T#u<2^Sv}N&NQ%D&uiNmi#FS;=Ha462Hi}MWZ$YahlCf_rSbiVfs7lnI;AJ%Ni9ks8t}5?3vP z-sqMYZIQ+6DVEo*Yupgo}#7S$K)^E84J8=Rw>$Aoxqg#IC1F>q11 zDRQmlKurAFmD$t$0pe|vO*UTI{cH*2TTV_L?>LCJnswuEvebJTcoL-9HtlXnP17Fo zm13H{OUCZV!R{lTXin~}h04epiB#ymAYq^oK{}J zR{M=i*vn74KPP|Yd3+C7Uuy2@=RrtNnG4kr)+M1gil%8|N&v#3F5e)Qu5vgfbp zG;{~0g*6zyzbxBmzOw|hgvbhz#PiX{SvBdNcwcjh9^S2(qXCsP%YzR;$LIAKYx^S^ zkRN~|Gg*PVk2asITpxUqdu`!8C0qz_LlC(rgK~s-jxlXCL{dIM%GhQ-fH(hs!^zg$ zj|NPBHki^lY&qFMkMSgqDZB|LJN{z3(fBmOHDxJ|JRO#4FO!B~`)6G985!}T{M{a0 zm#Eac-XFYw^}yER>YHKL`77Z!zY$Vr+htcDO$%nHuv=6Iof@ugY6~KO*m;QDO9pdv z<|t{ABM5!>tf;V9$b1f2N!8?ZR~zSq39k{^1JzGyy9vWHSU;9I&L!Tm*5{ct7DSd- zCjK2`s-n4l51e$N2n#R6Si|{kZS#K3QA}SCL-_KA;aJRZnNTVBxgO2j&Q5EDRdvYX zB`Qrm>f(LF9P4a$3I%vwav@1{sf28JyW|#fs8G(V+~p+Z($bw7RLQ|R13p=%XjudqD0OwzR#hqkyQ7MvI@K!p;v)aEnd z>DG)2?WQltwe9ALctyG7JSOK9Xi&ZhRM^Q1mO!=(8O++NGxTlP1^iN7f*!lv^Sp3(z=wk+$NCmJu2!T(f9F;551%jTH5`o+1|@@J2FDJ%7!XM zy2bbyqgn4=YWRa_Wn+%}cS}CwjpuR01=K~33oRR8@PeV5FMXpbuKa_lq zyX-O%j9v#Wpk#&OL~R!Vd&yj}?_GCc(Q1&dMFB||y&kBMWO|Je;*XA`kG6|ACvV=+ zfnY#OfQ443ZIAHiLh}o4JWsM3KhOzAF@gXXd;Fb4ca*;&!;uV(X3Xe43Jbe?`(|Jau?} zv@^?E&Jx6wFznK(X{LS?vVG#2_hwFz3hz@w@ltp(|J9E_yt;Y05%&(66EY_Q=IC#a z(Ewi>WQEs2rJU^vz1}g*s|tC|?fo*uschG-RWsYLOY*Qk`qVeoPiuErpEzMCpVcJV zHa7+D1wJhnqbZ*w6Pz zZ=Ig}@ZOvMg;Kh3pe~aV_^PTq*3;ssf7iI=TE?h)Gv?p`_lSixIF>PpwPVGYjJ>l-t_zer&{I97C3;>0v{dI_;sHEd#Xp&M(`ymw|-} zS>dS9`Dpo6U&|4tYw1sA$lun<+MJEqLp&BN{K0F|l&syJxIDJ@EhmX!VEgq2@kziE zM3Ban#w-?Cry%mi|5bNfTIBdQKBqrRLVD+K51Gl1Q`Sl5TG;7ukvGgP*qCFMZlD+t zP9DUs$@=dfM(o_*%dO52wcnUur}!8hZjNz`c=B$1j8V(A^R_7L^KwwT3MQRP^k-Sl z`c_l1@U^v{xZ3d~eV<(K#IQ^IwVDri1tB^ULE|Hb6~K2+bScY zvQFSrvn`uFWMirNxe`GbRWRc^j6Rskkh=xL|4U7h7ZC-gLGjs$NlIOE7?hH}>O4>ThHjySO*6)m(%PkCfsDSD{)#PB|T%#Owf$yYK|@W&86;pxQxv1)0DSAW!$Jo0+*6x1qq#ZK1wfjtKow+ztgrHl zI$tBEMKt-*a=QIiBXzRmT`tvop;>L$lXxp0Rc|1+&~mxPbF|>F(u~N3{<|E53t%&r z_-l)i7bu0a$}CX|=q6x`p14>R&4ggaA?EaO#r?sm#E zr`>W?pJdq0{B*rM!t>N?{e+kp-(bteZ->u19UcYUy{{0x?o53T zoMT+KWa_Rjc_y~>^~wX9Smc|*2GNH{=5ZGrjfPeZ!scsM6ShSs%iUnA3N>i8jb zMUDAgWW1By)!0XZ3k4I&hA+!t6&4P(rf;j08T1Y3qLPzeoj!9{q_jn!O(Lm*R18p0AS;OWITtNC zB0xpolY7bTjvDdfjrO>`OU=T+3>S=_GMyR!y7}XFMN_o?f_rIZYYLngs_c%L*`pVq z6kN(b7VwGeKxL9cPyA8n(&yz`y4PH~wQ9%Z8J(p{wvo(jzZ%?~Cyy_cYpGQ7>^Y{p z&UTC`Jc^{DT6ON&D9h%#BX_KSO2!Uk@+(BH$G@*;W;{i*8H#hYdh}%9Zthl5g^PZe z5pTz7h9Cd+hVOH;mR7BRR#^9{eUju;K89CUMv}yN9$kjppNT1*N;!Dm=*!x7h@`CG zX89nt?PKdf+4yO%*~ z$KSRuBckB!iEAd?Gj$JBj%3FlP1x2I+w%FEORwtf`v^Lfa9M5<*IwJv7->H1kC#z@ zcOhOr!+10AaRWuiubB2k&6VR*!4$Mi5@cyRVmiuFJ=!&o^o~6wF!mpHwyP+7;|6&YTK`{|zG;gK9hx#E* zOL5Wwm34Sju1H*oiz!`s!&^GdJ|Efx`=+N&-)W+4QY^Ie&HV06Xpm5Y$ki=AT&2p8 zu9qrQGJ8LcI=JVk8E3FL(oSbc*Uy3G@kT96Nf`zj+NZ`pro=*T$jAG2#yt`|<~%&< zy5e{I6t&n!5~-?G$qGt+^rA&@r%cuBIXCov5%|nv%svnb9uANo~K`$`x{j{+TC|Qb#K!h zIS~6SN6zQdGTIR z3MY4W!;6P9R5C$%?~vQq_#9H7e&}~*(PKN8t>S_klwI{uY_1R8T0%8vy%^vi)p0r^ zxBJgIK;S3|^C3#KcGMwbMiV8JGQCKfkn@9;QN+Ibs3BQkQ?xqmijoW)>ujcDj@)w> zOAMXWPTObE_ON6hW`{Cb`X4 zr`7?pTsw=~Jikz`$lNd~wwHLp?;U?RbV)gfF7fEsvN>aXnwd%T$RRc}w)ctEt*VQg zt;-h3#5}RHK6X4^k@S}Wl}?g9vlmXdpi!Z8;G3L(!z|)h_5Cj$mL(pwQq9A-l)OVC~cz zL%<}50(C>mf}&P7&*)88OGm3q11e)T)XSv|Tppo|$0F~6Yy$V&3wm-U(NfEA+_$r+ zy{^|5HQtIV+~`G$LpWU7uBG&Beew6LF{xXdj7jR6n}}gz>md~qIG$1yO^y`P`m6`u zVo;|pC~-;f^geoN)mPH-&drhT+tV8FDFwY&(6C%Q0@)xWbhS<9eru-3RH^`dG!A}#YoEAHSAhH z3u(c2_bem3h*946X0l_eoftlzjF{r-*%LQqOg~J&;d7X!BOx)8uV8Ao1HXsf?tRCp z9on}yu8TbzAuoZM5AiP!9^kH$4CYGM@epcDHu%ghG{;(AO{M=Z+A zum_ZrXDFav*RD)G-@P*<>mY5|Bluk3JcOJ=`DDZ_PzLwbhD3v-lQr|BS^4~aursk` zI3`C@aC)|0G|_)ckxg0vl`n#+V%os zE#hd5*5f$#)bp}&vG5tB>sMl?8fQ`!4ru|a^3@eA_y0Qet`ViCOR9D9OzJO=uQ zrtl&V-AGfoM<5dZ-Vl;b7U?StfJyD2KL2o9z_j%NNdi*)?;3yj|NcF7bObtZ;8lmr z19IYM4#MdLaOH%~$^8~xFcH!^Q9xSMOz+x~L8!c!SDr`!14bN@fCHEmfCQ%q#NX=- z$lraiaA1qU^uh2+>rZNb>5^S`|F^ExA3lijTTb^E{<}}=lI(u_BIV3q{r{&P(EtC* z|F`-1pBgXqKi88R?2S8#0oq@C10f|mi5>y6Fp}V}2KaQ9fL;I~3_uhBI{?x%#6n== z2CxzUK>()#33vkeot{kwKpFiZCTv J82GB>{{S*6RY?E< literal 0 HcmV?d00001 diff --git a/util/test/demos/d3d11/d3d11_video_textures.cpp b/util/test/demos/d3d11/d3d11_video_textures.cpp index e5273ed7f..b4f6dead4 100644 --- a/util/test/demos/d3d11/d3d11_video_textures.cpp +++ b/util/test/demos/d3d11/d3d11_video_textures.cpp @@ -24,6 +24,21 @@ #include "d3d11_test.h" +// forward declare a couple of interfaces trimmed out of our local copy of the MF headers +struct IMediaBuffer; +struct IPropertyStore; +struct INamedPropertyStore; + +#include "dx/official/mfapi.h" +#include "dx/official/mfmediaengine.h" + +COM_SMARTPTR(IMFDXGIDeviceManager); +COM_SMARTPTR(IMFMediaEngineClassFactory); +COM_SMARTPTR(IMFAttributes); +COM_SMARTPTR(IMFMediaEngine); +COM_SMARTPTR(IMFMediaEngineEx); +COM_SMARTPTR(IMFByteStream); + /////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// @@ -37,7 +52,7 @@ /////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////// -struct D3D11_Video_Textures : D3D11GraphicsTest +struct D3D11_Video_Textures : D3D11GraphicsTest, IMFMediaEngineNotify { static constexpr const char *Description = "Tests of YUV textures"; @@ -169,12 +184,182 @@ float4 main(v2f IN) : SV_Target0 Vec4i config[2]; }; + bool video_loaded = false; + + // implement IUnknown + ULONG AddRef() { return 1; } + ULONG Release() { return 1; } + HRESULT QueryInterface(const IID &iid, void **obj) + { + if(iid == __uuidof(IUnknown)) + { + *obj = (IUnknown *)this; + return S_OK; + } + else if(iid == __uuidof(IMFMediaEngineNotify)) + { + *obj = (IMFMediaEngineNotify *)this; + return S_OK; + } + + return E_NOINTERFACE; + } + // implement IMFMediaEngineNotify + HRESULT EventNotify(DWORD ev, DWORD_PTR param1, DWORD param2) + { + if(ev == MF_MEDIA_ENGINE_EVENT_CANPLAY) + video_loaded = true; + else if(ev == MF_MEDIA_ENGINE_EVENT_ERROR) + TEST_ERROR("Error loading video: %x", param2); + return S_OK; + } + int main(int argc, char **argv) { + // call this early to parse any data path parameters + GraphicsTest::Init(argc, argv); + + // check for the existence of the test video + std::string video_filename = GetDataPath("h264_yu420p_192x108_24fps.mp4"); + + FILE *f = fopen(video_filename.c_str(), "rb"); + if(f) + fclose(f); + else + video_filename = ""; + + using PFN_MFCreateDXGIDeviceManager = decltype(&MFCreateDXGIDeviceManager); + using PFN_MFStartup = decltype(&MFStartup); + using PFN_MFCreateFile = decltype(&MFCreateFile); + using PFN_MFShutdown = decltype(&MFShutdown); + using PFN_MFCreateAttributes = decltype(&MFCreateAttributes); + + PFN_MFCreateDXGIDeviceManager dyn_MFCreateDXGIDeviceManager = NULL; + PFN_MFStartup dyn_MFStartup = NULL; + PFN_MFCreateFile dyn_MFCreateFile = NULL; + PFN_MFShutdown dyn_MFShutdown = NULL; + PFN_MFCreateAttributes dyn_MFCreateAttributes = NULL; + + HMODULE mfplat = LoadLibraryA("mfplat.dll"); + + if(mfplat && !video_filename.empty()) + { + dyn_MFCreateDXGIDeviceManager = + (PFN_MFCreateDXGIDeviceManager)GetProcAddress(mfplat, "MFCreateDXGIDeviceManager"); + dyn_MFStartup = (PFN_MFStartup)GetProcAddress(mfplat, "MFStartup"); + dyn_MFShutdown = (PFN_MFShutdown)GetProcAddress(mfplat, "MFShutdown"); + dyn_MFCreateFile = (PFN_MFCreateFile)GetProcAddress(mfplat, "MFCreateFile"); + dyn_MFCreateAttributes = (PFN_MFCreateAttributes)GetProcAddress(mfplat, "MFCreateAttributes"); + + if(dyn_MFCreateDXGIDeviceManager && dyn_MFStartup && dyn_MFCreateFile && dyn_MFCreateAttributes) + { + createFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT | D3D11_CREATE_DEVICE_VIDEO_SUPPORT; + + CoInitializeEx(NULL, COINIT_MULTITHREADED); + dyn_MFStartup(MF_VERSION, MFSTARTUP_FULL); + + TEST_LOG("Initialising MediaFoundation"); + } + else + { + dyn_MFCreateDXGIDeviceManager = NULL; + dyn_MFStartup = NULL; + dyn_MFShutdown = NULL; + dyn_MFCreateFile = NULL; + dyn_MFCreateAttributes = NULL; + + TEST_LOG("MediaFoundation not available"); + } + } + // initialise, create window, create device, etc if(!Init(argc, argv)) return 3; + IMFMediaEnginePtr engine = NULL; + + // if we initialised MF this create flag will be set + if(createFlags & D3D11_CREATE_DEVICE_VIDEO_SUPPORT) + { + // need to enable multithreaded as MediaFoundation breaks threading rules if any rendering is + // going on + { + ID3D11MultithreadPtr mt; + dev->QueryInterface(&mt); + mt->SetMultithreadProtected(true); + } + + IMFDXGIDeviceManagerPtr dxgiManager; + + // create DXGI Manager + { + UINT resetToken = 0; + CHECK_HR(dyn_MFCreateDXGIDeviceManager(&resetToken, &dxgiManager)); + + CHECK_HR(dxgiManager->ResetDevice(dev, resetToken)); + } + + // create class factory + IMFMediaEngineClassFactoryPtr classFactory; + CHECK_HR(CoCreateInstance(CLSID_MFMediaEngineClassFactory, NULL, CLSCTX_INPROC_SERVER, + __uuidof(IMFMediaEngineClassFactory), (void **)&classFactory)); + + // initialise attributes where we'll store our init properties + IMFAttributesPtr attr; + dyn_MFCreateAttributes(&attr, 3); + + CHECK_HR(attr->SetUnknown(MF_MEDIA_ENGINE_DXGI_MANAGER, dxgiManager)); + CHECK_HR(attr->SetUINT32(MF_MEDIA_ENGINE_VIDEO_OUTPUT_FORMAT, DXGI_FORMAT_NV12)); + CHECK_HR(attr->SetUnknown(MF_MEDIA_ENGINE_CALLBACK, this)); + + // create the media engine itself + CHECK_HR(classFactory->CreateInstance(0, attr, &engine)); + + // set it looping + CHECK_HR(engine->SetLoop(true)); + + const std::wstring filename = UTF82Wide(video_filename); + + // open a bytestream for the file + IMFByteStreamPtr byteStream; + CHECK_HR(dyn_MFCreateFile(MF_ACCESSMODE_READ, MF_OPENMODE_FAIL_IF_NOT_EXIST, + MF_FILEFLAGS_NONE, filename.c_str(), &byteStream)); + + size_t len = filename.length(); + + // make a BSTR with the URL + wchar_t *url = new wchar_t[len + 1 + 8]; + + memcpy(url + 1 + 8, filename.c_str(), len * sizeof(wchar_t)); + memcpy(url + 1, L"file:///", 8 * sizeof(wchar_t)); + url[0] = (wchar_t)(len + 8); + + for(size_t i = 1; i < len + 1 + 8; i++) + if(url[i] == '\\') + url[i] = '/'; + + // query for IMFMediaEngineEx so we can set the source from a byte stream + { + IMFMediaEngineExPtr engineex; + CHECK_HR(engine->QueryInterface(&engineex)); + + CHECK_HR(engineex->SetSourceFromByteStream(byteStream, url)); + } + + delete[] url; + + // wait for the video to load + for(int i = 0; i < 300; i++) + { + if(video_loaded) + break; + Sleep(10); + } + + if(!video_loaded) + TEST_FATAL("Video wasn't playable after 3 seconds"); + } + ID3DBlobPtr vsblob = Compile(D3DDefaultVertex, "main", "vs_4_0"); ID3DBlobPtr psblob = Compile(pixel, "main", "ps_4_0"); @@ -549,6 +734,28 @@ float4 main(v2f IN) : SV_Target0 // don't do sRGB conversion, as we won't in the shader either ID3D11RenderTargetViewPtr bbDirectRTV = MakeRTV(bbTex).Format(DXGI_FORMAT_R8G8B8A8_UNORM); + IDXGISurfacePtr videoSurface = NULL; + ID3D11ShaderResourceViewPtr videoSRVs[2] = {}; + + // if we got a media engine, create a surface to render to + if(engine) + { + DWORD videoWidth = 0, videoHeight = 0; + CHECK_HR(engine->GetNativeVideoSize(&videoWidth, &videoHeight)); + + if(videoWidth > 0 && videoHeight > 0) + { + ID3D11Texture2DPtr tex = + MakeTexture(DXGI_FORMAT_NV12, videoWidth, videoHeight).Mips(1).SRV().RTV(); + tex->QueryInterface(&videoSurface); + videoSRVs[0] = MakeSRV(tex).Format(DXGI_FORMAT_R8_UNORM); + videoSRVs[1] = MakeSRV(tex).Format(DXGI_FORMAT_R8G8_UNORM); + } + + // start playing the video + CHECK_HR(engine->Play()); + } + while(Running()) { ClearRenderTargetView(bbRTV, {0.4f, 0.5f, 0.6f, 1.0f}); @@ -591,9 +798,39 @@ float4 main(v2f IN) : SV_Target0 } } + if(engine && videoSurface) + { + DWORD videoWidth = 0, videoHeight = 0; + CHECK_HR(engine->GetNativeVideoSize(&videoWidth, &videoHeight)); + + LONGLONG timestamp = 0; + if(engine->OnVideoStreamTick(×tamp) == S_OK) + { + MFVideoNormalizedRect srcRect = {0.0f, 0.0f, 1.0f, 1.0f}; + RECT dstRect = {0, 0, (LONG)videoWidth, (LONG)videoHeight}; + MFARGB fillColor = {}; + + engine->TransferVideoFrame(videoSurface, &srcRect, &dstRect, &fillColor); + } + + RSSetViewport({0.0f, 100.0f, 356.0f, 200.0f, 0.0f, 1.0f}); + + Vec4i videoConfig[] = { + Vec4i(videoWidth, videoHeight, 2, 2), Vec4i(0, 4, 5, 1), + }; + + ctx->UpdateSubresource(cb, 0, NULL, videoConfig, sizeof(videoConfig), sizeof(videoConfig)); + + ctx->PSSetShaderResources(0, 2, (ID3D11ShaderResourceView **)videoSRVs); + ctx->Draw(4, 0); + } + Present(); } + if(dyn_MFShutdown) + dyn_MFShutdown(); + return 0; } }; diff --git a/util/test/demos/dx/official/mfapi.h b/util/test/demos/dx/official/mfapi.h new file mode 100644 index 000000000..e0f77412e --- /dev/null +++ b/util/test/demos/dx/official/mfapi.h @@ -0,0 +1,4418 @@ +#include "winapifamily.h" + +//*@@@+++@@@@****************************************************************** +// +// Microsoft Windows Media Foundation +// Copyright (C) Microsoft Corporation. All rights reserved. +// +//*@@@---@@@@****************************************************************** +// + +// +// MFAPI.h is the header containing the APIs for using the MF platform. +// + +#pragma once +#if !defined(__MFAPI_H__) +#define __MFAPI_H__ + +#pragma pack(push, mfhrds) +#include "mfobjects.h" +#pragma pack(pop, mfhrds) + +//#include "mmreg.h" + +//#include +#ifndef AVRT_DATA +#define AVRT_DATA +#endif +#ifndef AVRT_BSS +#define AVRT_BSS +#endif + +#if !defined(MF_VERSION) + +#if (WINVER >= _WIN32_WINNT_WIN7) + +#define MF_SDK_VERSION 0x0002 + +#else // Vista + +#define MF_SDK_VERSION 0x0001 + +#endif // (WINVER >= _WIN32_WINNT_WIN7) + +#define MF_API_VERSION 0x0070 // This value is unused in the Win7 release and left at its Vista release value +#define MF_VERSION (MF_SDK_VERSION << 16 | MF_API_VERSION) + +#endif //!defined(MF_VERSION) + + +#define MFSTARTUP_NOSOCKET 0x1 +#define MFSTARTUP_LITE (MFSTARTUP_NOSOCKET) +#define MFSTARTUP_FULL 0 + +#if defined(__cplusplus) +extern "C" { +#endif + +//////////////////////////////////////////////////////////////////////////////// +/////////////////////////////// Startup/Shutdown //////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + +// +// Initializes the platform object. +// Must be called before using Media Foundation. +// A matching MFShutdown call must be made when the application is done using +// Media Foundation. +// The "Version" parameter should be set to MF_API_VERSION. +// Application should not call MFStartup / MFShutdown from workqueue threads +// +#if defined(__cplusplus) + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFStartup( ULONG Version, DWORD dwFlags = MFSTARTUP_FULL ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#else + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFStartup( ULONG Version, DWORD dwFlags ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#endif + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +// +// Shuts down the platform object. +// Releases all resources including threads. +// Application should call MFShutdown the same number of times as MFStartup +// Application should not call MFStartup / MFShutdown from workqueue threads +// +STDAPI MFShutdown(); + + +//////////////////////////////////////////////////////////////////////////////// +///////////////////////////////// Platform /////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + +// +// These functions can be used to keep the MF platform object in place. +// Every call to MFLockPlatform should have a matching call to MFUnlockPlatform +// +STDAPI MFLockPlatform(); +STDAPI MFUnlockPlatform(); + +/////////////////////////////////////////////////////////////////////////////// + +// +// MF workitem functions +// +typedef unsigned __int64 MFWORKITEM_KEY; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +STDAPI MFPutWorkItem( + DWORD dwQueue, + IMFAsyncCallback * pCallback, + IUnknown * pState); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFPutWorkItem2( + DWORD dwQueue, + LONG Priority, + _In_ IMFAsyncCallback * pCallback, + _In_opt_ IUnknown * pState); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +STDAPI MFPutWorkItemEx( + DWORD dwQueue, + IMFAsyncResult * pResult); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFPutWorkItemEx2( + DWORD dwQueue, + LONG Priority, + _In_ IMFAsyncResult * pResult); + +STDAPI MFPutWaitingWorkItem ( + HANDLE hEvent, + LONG Priority, + _In_ IMFAsyncResult * pResult, + _Out_opt_ MFWORKITEM_KEY * pKey + ); + +STDAPI MFAllocateSerialWorkQueue ( + _In_ DWORD dwWorkQueue, + _Out_ OUT DWORD * pdwWorkQueue); + +STDAPI MFScheduleWorkItemEx( + IMFAsyncResult * pResult, + INT64 Timeout, + _Out_opt_ MFWORKITEM_KEY * pKey); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +STDAPI MFScheduleWorkItem( + IMFAsyncCallback * pCallback, + IUnknown * pState, + INT64 Timeout, + _Out_opt_ MFWORKITEM_KEY * pKey); + +// +// The CancelWorkItem method is used by objects to cancel scheduled operation +// Due to asynchronous nature of timers, application might still get a +// timer callback after MFCancelWorkItem has returned. +// +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFCancelWorkItem( + MFWORKITEM_KEY Key); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +/////////////////////////////////////////////////////////////////////////////// + +// +// MF periodic callbacks +// +STDAPI MFGetTimerPeriodicity( + _Out_ DWORD * Periodicity); + +typedef void (*MFPERIODICCALLBACK)(IUnknown* pContext); + +STDAPI MFAddPeriodicCallback( + MFPERIODICCALLBACK Callback, + IUnknown * pContext, + _Out_opt_ DWORD * pdwKey); + +STDAPI MFRemovePeriodicCallback( + DWORD dwKey); + +/////////////////////////////////////////////////////////////////////////////// + +// +// MF work queues +// + +#if (WINVER >= _WIN32_WINNT_WIN7) +// +// MFASYNC_WORKQUEUE_TYPE: types of work queue used by MFAllocateWorkQueueEx +// +typedef enum +{ + // MF_STANDARD_WORKQUEUE: Work queue in a thread without Window + // message loop. + MF_STANDARD_WORKQUEUE = 0, + + // MF_WINDOW_WORKQUEUE: Work queue in a thread running Window + // Message loop that calls PeekMessage() / DispatchMessage().. + MF_WINDOW_WORKQUEUE = 1, + + // + // + MF_MULTITHREADED_WORKQUEUE = 2, // common MT threadpool +} MFASYNC_WORKQUEUE_TYPE; + +STDAPI MFAllocateWorkQueueEx( + _In_ MFASYNC_WORKQUEUE_TYPE WorkQueueType, + _Out_ OUT DWORD * pdwWorkQueue); +#endif // (WINVER >= _WIN32_WINNT_WIN7) + +// +// Allocate a standard work queue. the behaviour is the same with: +// MFAllocateWorkQueueEx( MF_STANDARD_WORKQUEUE, pdwWorkQueue ) +// +STDAPI MFAllocateWorkQueue( + _Out_ OUT DWORD * pdwWorkQueue); + + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFLockWorkQueue( + _In_ DWORD dwWorkQueue); + +STDAPI MFUnlockWorkQueue( + _In_ DWORD dwWorkQueue); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +STDAPI MFBeginRegisterWorkQueueWithMMCSS( + DWORD dwWorkQueueId, + _In_ LPCWSTR wszClass, + DWORD dwTaskId, + _In_ IMFAsyncCallback * pDoneCallback, + _In_ IUnknown * pDoneState ); + +STDAPI MFBeginRegisterWorkQueueWithMMCSSEx( + DWORD dwWorkQueueId, + _In_ LPCWSTR wszClass, + DWORD dwTaskId, + LONG lPriority, + _In_ IMFAsyncCallback * pDoneCallback, + _In_ IUnknown * pDoneState ); + +STDAPI MFEndRegisterWorkQueueWithMMCSS( + _In_ IMFAsyncResult * pResult, + _Out_ DWORD * pdwTaskId ); + +STDAPI MFBeginUnregisterWorkQueueWithMMCSS( + DWORD dwWorkQueueId, + _In_ IMFAsyncCallback * pDoneCallback, + _In_ IUnknown * pDoneState ); + +STDAPI MFEndUnregisterWorkQueueWithMMCSS( + _In_ IMFAsyncResult * pResult ); + +STDAPI MFGetWorkQueueMMCSSClass( + DWORD dwWorkQueueId, + _Out_writes_to_opt_(*pcchClass,*pcchClass) LPWSTR pwszClass, + _Inout_ DWORD *pcchClass ); + +STDAPI MFGetWorkQueueMMCSSTaskId( + DWORD dwWorkQueueId, + _Out_ LPDWORD pdwTaskId ); + +STDAPI MFRegisterPlatformWithMMCSS( + _In_ PCWSTR wszClass, + _Inout_ DWORD* pdwTaskId, + _In_ LONG lPriority ); + +STDAPI MFUnregisterPlatformFromMMCSS(); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFLockSharedWorkQueue( + _In_ PCWSTR wszClass, + _In_ LONG BasePriority, + _Inout_ DWORD* pdwTaskId, + _Out_ DWORD* pID ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +STDAPI MFGetWorkQueueMMCSSPriority( + DWORD dwWorkQueueId, + _Out_ LONG* lPriority ); + + +/////////////////////////////////////////////////////////////////////////////// +///////////////////////////////// Async Model ////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +// +// Instantiates the MF-provided Async Result implementation +// +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFCreateAsyncResult( + IUnknown * punkObject, + IMFAsyncCallback * pCallback, + IUnknown * punkState, + _Out_ IMFAsyncResult ** ppAsyncResult ); + +// +// Helper for calling IMFAsyncCallback::Invoke +// +STDAPI MFInvokeCallback( + IMFAsyncResult * pAsyncResult ); + +// +// MFASYNCRESULT struct. +// Any implementation of IMFAsyncResult must inherit from this struct; +// the Media Foundation workqueue implementation depends on this. +// +#if defined(__cplusplus) && !defined(CINTERFACE) +typedef struct tagMFASYNCRESULT : public IMFAsyncResult +{ + OVERLAPPED overlapped; + IMFAsyncCallback * pCallback; + HRESULT hrStatusResult; + DWORD dwBytesTransferred; + HANDLE hEvent; +} MFASYNCRESULT; +#else /* C style interface */ +typedef struct tagMFASYNCRESULT +{ + IMFAsyncResult AsyncResult; + OVERLAPPED overlapped; + IMFAsyncCallback * pCallback; + HRESULT hrStatusResult; + DWORD dwBytesTransferred; + HANDLE hEvent; +} MFASYNCRESULT; +#endif /* C style interface */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +/////////////////////////////////////////////////////////////////////////////// +///////////////////////////////// Files ////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +// +// Regardless of the access mode with which the file is opened, the sharing +// permissions will allow shared reading and deleting. +// +STDAPI MFCreateFile( + MF_FILE_ACCESSMODE AccessMode, + MF_FILE_OPENMODE OpenMode, + MF_FILE_FLAGS fFlags, + LPCWSTR pwszFileURL, + _Out_ IMFByteStream **ppIByteStream ); + +STDAPI MFCreateTempFile( + MF_FILE_ACCESSMODE AccessMode, + MF_FILE_OPENMODE OpenMode, + MF_FILE_FLAGS fFlags, + _Out_ IMFByteStream **ppIByteStream ); + +STDAPI MFBeginCreateFile( + MF_FILE_ACCESSMODE AccessMode, + MF_FILE_OPENMODE OpenMode, + MF_FILE_FLAGS fFlags, + LPCWSTR pwszFilePath, + IMFAsyncCallback * pCallback, + IUnknown * pState, + _Out_ IUnknown ** ppCancelCookie); + +STDAPI MFEndCreateFile( + IMFAsyncResult * pResult, + _Out_ IMFByteStream **ppFile ); + +STDAPI MFCancelCreateFile( + IUnknown * pCancelCookie); + + +/////////////////////////////////////////////////////////////////////////////// +///////////////////////////////// Buffers ////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +// +// Creates an IMFMediaBuffer in memory +// +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFCreateMemoryBuffer( + _In_ DWORD cbMaxLength, + _Out_ IMFMediaBuffer ** ppBuffer ); + +// +// Creates an IMFMediaBuffer wrapper at the given offset and length +// within an existing IMFMediaBuffer +// +STDAPI MFCreateMediaBufferWrapper( + _In_ IMFMediaBuffer * pBuffer, + _In_ DWORD cbOffset, + _In_ DWORD dwLength, + _Out_ IMFMediaBuffer ** ppBuffer ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +// +// Creates a legacy buffer (IMediaBuffer) wrapper at the given offset within +// an existing IMFMediaBuffer. +// pSample is optional. It can point to the original IMFSample from which this +// IMFMediaBuffer came. If provided, then *ppMediaBuffer will succeed +// QueryInterface for IID_IMFSample, from which the original sample's attributes +// can be obtained +// +STDAPI MFCreateLegacyMediaBufferOnMFMediaBuffer( + _In_opt_ IMFSample * pSample, + _In_ IMFMediaBuffer * pMFMediaBuffer, + _In_ DWORD cbOffset, + _Outptr_ IMediaBuffer ** ppMediaBuffer ); + +// +// Create a DirectX surface buffer +// +#include "dxgiformat.h" +STDAPI_(DXGI_FORMAT) MFMapDX9FormatToDXGIFormat( _In_ DWORD dx9 ); +STDAPI_(DWORD) MFMapDXGIFormatToDX9Format( _In_ DXGI_FORMAT dx11 ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFLockDXGIDeviceManager( + _Out_opt_ UINT* pResetToken, + _Outptr_ IMFDXGIDeviceManager** ppManager + ); + +STDAPI MFUnlockDXGIDeviceManager(); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +STDAPI MFCreateDXSurfaceBuffer( + _In_ REFIID riid, + _In_ IUnknown * punkSurface, + _In_ BOOL fBottomUpWhenLinear, + _Outptr_ IMFMediaBuffer ** ppBuffer ); + +STDAPI MFCreateWICBitmapBuffer( + _In_ REFIID riid, + _In_ IUnknown * punkSurface, + _Outptr_ IMFMediaBuffer ** ppBuffer + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI +MFCreateDXGISurfaceBuffer( + _In_ REFIID riid, + _In_ IUnknown* punkSurface, + _In_ UINT uSubresourceIndex, + _In_ BOOL fBottomUpWhenLinear, + _Outptr_ IMFMediaBuffer** ppBuffer + ); + +STDAPI MFCreateVideoSampleAllocatorEx( + _In_ REFIID riid, + _Outptr_ void** ppSampleAllocator + ); + +STDAPI +MFCreateDXGIDeviceManager( + _Out_ UINT* resetToken, + _Outptr_ IMFDXGIDeviceManager** ppDeviceManager + ); + +#define MF_E_DXGI_DEVICE_NOT_INITIALIZED ((HRESULT)0x80041000L) // DXVA2_E_NOT_INITIALIZED +#define MF_E_DXGI_NEW_VIDEO_DEVICE ((HRESULT)0x80041001L) // DXVA2_E_NEW_VIDEO_DEVICE +#define MF_E_DXGI_VIDEO_DEVICE_LOCKED ((HRESULT)0x80041002L) // DXVA2_E_VIDEO_DEVICE_LOCKED + +// +// Create an aligned memory buffer. +// The following constants were chosen for parity with the alignment constants +// in ntioapi.h +// +#define MF_1_BYTE_ALIGNMENT 0x00000000 +#define MF_2_BYTE_ALIGNMENT 0x00000001 +#define MF_4_BYTE_ALIGNMENT 0x00000003 +#define MF_8_BYTE_ALIGNMENT 0x00000007 +#define MF_16_BYTE_ALIGNMENT 0x0000000f +#define MF_32_BYTE_ALIGNMENT 0x0000001f +#define MF_64_BYTE_ALIGNMENT 0x0000003f +#define MF_128_BYTE_ALIGNMENT 0x0000007f +#define MF_256_BYTE_ALIGNMENT 0x000000ff +#define MF_512_BYTE_ALIGNMENT 0x000001ff +#define MF_1024_BYTE_ALIGNMENT 0x000003ff +#define MF_2048_BYTE_ALIGNMENT 0x000007ff +#define MF_4096_BYTE_ALIGNMENT 0x00000fff +#define MF_8192_BYTE_ALIGNMENT 0x00001fff + +STDAPI MFCreateAlignedMemoryBuffer( + _In_ DWORD cbMaxLength, + _In_ DWORD cbAligment, + _Out_ IMFMediaBuffer ** ppBuffer ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +// +// This GUID is used in IMFGetService::GetService calls to retrieve +// interfaces from the buffer. Its value is defined in evr.h +// +EXTERN_C const GUID MR_BUFFER_SERVICE; + +/////////////////////////////////////////////////////////////////////////////// +///////////////////////////////// Events ////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +// +// Instantiates the MF-provided Media Event implementation. +// + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFCreateMediaEvent( + _In_ MediaEventType met, + _In_ REFGUID guidExtendedType, + _In_ HRESULT hrStatus, + _In_opt_ const PROPVARIANT * pvValue, + _Out_ IMFMediaEvent ** ppEvent ); + +// +// Instantiates an object that implements IMFMediaEventQueue. +// Components that provide an IMFMediaEventGenerator can use this object +// internally to do their Media Event Generator work for them. +// IMFMediaEventGenerator calls should be forwarded to the similar call +// on this object's IMFMediaEventQueue interface (e.g. BeginGetEvent, +// EndGetEvent), and the various IMFMediaEventQueue::QueueEventXXX methods +// can be used to queue events that the caller will consume. +// +STDAPI MFCreateEventQueue( + _Out_ IMFMediaEventQueue **ppMediaEventQueue ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +// +// Event attributes +// Some of the common Media Foundation events have associated attributes +// that go in their IMFAttributes stores +// + +// +// MESessionCapabilitiesChanged attributes +// + +// MF_EVENT_SESSIONCAPS {7E5EBCD0-11B8-4abe-AFAD-10F6599A7F42} +// Type: UINT32 +DEFINE_GUID(MF_EVENT_SESSIONCAPS, +0x7e5ebcd0, 0x11b8, 0x4abe, 0xaf, 0xad, 0x10, 0xf6, 0x59, 0x9a, 0x7f, 0x42); + +// MF_EVENT_SESSIONCAPS_DELTA {7E5EBCD1-11B8-4abe-AFAD-10F6599A7F42} +// Type: UINT32 +DEFINE_GUID(MF_EVENT_SESSIONCAPS_DELTA, +0x7e5ebcd1, 0x11b8, 0x4abe, 0xaf, 0xad, 0x10, 0xf6, 0x59, 0x9a, 0x7f, 0x42); + +// Session capabilities bitflags +#define MFSESSIONCAP_START 0x00000001 +#define MFSESSIONCAP_SEEK 0x00000002 +#define MFSESSIONCAP_PAUSE 0x00000004 +#define MFSESSIONCAP_RATE_FORWARD 0x00000010 +#define MFSESSIONCAP_RATE_REVERSE 0x00000020 +#define MFSESSIONCAP_DOES_NOT_USE_NETWORK 0x00000040 + +// +// MESessionTopologyStatus attributes +// + +// Possible values for MF_EVENT_TOPOLOGY_STATUS attribute. +// +// For a given topology, these status values will arrive via +// MESessionTopologyStatus in the order below. +// +// However, there are no guarantees about how these status values will be +// ordered between two consecutive topologies. For example, +// MF_TOPOSTATUS_READY could arrive for topology n+1 before +// MF_TOPOSTATUS_ENDED arrives for topology n if the application called +// IMFMediaSession::SetTopology for topology n+1 well enough in advance of the +// end of topology n. Conversely, if topology n ends before the application +// calls IMFMediaSession::SetTopology for topology n+1, then +// MF_TOPOSTATUS_ENDED will arrive for topology n before MF_TOPOSTATUS_READY +// arrives for topology n+1. +typedef enum +{ + // MF_TOPOSTATUS_INVALID: Invalid value; will not be sent + MF_TOPOSTATUS_INVALID = 0, + + // MF_TOPOSTATUS_READY: The topology has been put in place and is + // ready to start. All GetService calls to the Media Session will use + // this topology. + MF_TOPOSTATUS_READY = 100, + + // MF_TOPOSTATUS_STARTED_SOURCE: The Media Session has started to read + // and process data from the Media Source(s) in this topology. + MF_TOPOSTATUS_STARTED_SOURCE = 200, + + +#if (WINVER >= _WIN32_WINNT_WIN7) + // MF_TOPOSTATUS_DYNAMIC_CHANGED: The topology has been dynamic changed + // due to the format change. + MF_TOPOSTATUS_DYNAMIC_CHANGED = 210, +#endif // (WINVER >= _WIN32_WINNT_WIN7) + + // MF_TOPOSTATUS_SINK_SWITCHED: The Media Sinks in the pipeline have + // switched from a previous topology to this topology. + // Note that this status does not get sent for the first topology; + // applications can assume that the sinks are playing the first + // topology when they receive MESessionStarted. + MF_TOPOSTATUS_SINK_SWITCHED = 300, + + // MF_TOPOSTATUS_ENDED: Playback of this topology is complete. + // Before deleting this topology, however, the application should wait + // for either MESessionEnded or the MF_TOPOSTATUS_STARTED_SOURCE status + // on the next topology to ensure that the Media Session is no longer + // using this topology. + MF_TOPOSTATUS_ENDED = 400, + +} MF_TOPOSTATUS; + +// MF_EVENT_TOPOLOGY_STATUS {30C5018D-9A53-454b-AD9E-6D5F8FA7C43B} +// Type: UINT32 {MF_TOPOLOGY_STATUS} +DEFINE_GUID(MF_EVENT_TOPOLOGY_STATUS, +0x30c5018d, 0x9a53, 0x454b, 0xad, 0x9e, 0x6d, 0x5f, 0x8f, 0xa7, 0xc4, 0x3b); + +// +// MESessionNotifyPresentationTime attributes +// + +// MF_EVENT_START_PRESENTATION_TIME {5AD914D0-9B45-4a8d-A2C0-81D1E50BFB07} +// Type: UINT64 +DEFINE_GUID(MF_EVENT_START_PRESENTATION_TIME, +0x5ad914d0, 0x9b45, 0x4a8d, 0xa2, 0xc0, 0x81, 0xd1, 0xe5, 0xb, 0xfb, 0x7); + +// MF_EVENT_PRESENTATION_TIME_OFFSET {5AD914D1-9B45-4a8d-A2C0-81D1E50BFB07} +// Type: UINT64 +DEFINE_GUID(MF_EVENT_PRESENTATION_TIME_OFFSET, +0x5ad914d1, 0x9b45, 0x4a8d, 0xa2, 0xc0, 0x81, 0xd1, 0xe5, 0xb, 0xfb, 0x7); + +// MF_EVENT_START_PRESENTATION_TIME_AT_OUTPUT {5AD914D2-9B45-4a8d-A2C0-81D1E50BFB07} +// Type: UINT64 +DEFINE_GUID(MF_EVENT_START_PRESENTATION_TIME_AT_OUTPUT, +0x5ad914d2, 0x9b45, 0x4a8d, 0xa2, 0xc0, 0x81, 0xd1, 0xe5, 0xb, 0xfb, 0x7); + +// + +// +// MESourceStarted attributes +// + +// MF_EVENT_SOURCE_FAKE_START {a8cc55a7-6b31-419f-845d-ffb351a2434b} +// Type: UINT32 +DEFINE_GUID(MF_EVENT_SOURCE_FAKE_START, +0xa8cc55a7, 0x6b31, 0x419f, 0x84, 0x5d, 0xff, 0xb3, 0x51, 0xa2, 0x43, 0x4b); + +// MF_EVENT_SOURCE_PROJECTSTART {a8cc55a8-6b31-419f-845d-ffb351a2434b} +// Type: UINT64 +DEFINE_GUID(MF_EVENT_SOURCE_PROJECTSTART, +0xa8cc55a8, 0x6b31, 0x419f, 0x84, 0x5d, 0xff, 0xb3, 0x51, 0xa2, 0x43, 0x4b); + +// MF_EVENT_SOURCE_ACTUAL_START {a8cc55a9-6b31-419f-845d-ffb351a2434b} +// Type: UINT64 +DEFINE_GUID(MF_EVENT_SOURCE_ACTUAL_START, +0xa8cc55a9, 0x6b31, 0x419f, 0x84, 0x5d, 0xff, 0xb3, 0x51, 0xa2, 0x43, 0x4b); + +// +// MEEndOfPresentationSegment attributes +// + +// MF_EVENT_SOURCE_TOPOLOGY_CANCELED {DB62F650-9A5E-4704-ACF3-563BC6A73364} +// Type: UINT32 +DEFINE_GUID(MF_EVENT_SOURCE_TOPOLOGY_CANCELED, +0xdb62f650, 0x9a5e, 0x4704, 0xac, 0xf3, 0x56, 0x3b, 0xc6, 0xa7, 0x33, 0x64); + +// +// MESourceCharacteristicsChanged attributes +// + +// MF_EVENT_SOURCE_CHARACTERISTICS {47DB8490-8B22-4f52-AFDA-9CE1B2D3CFA8} +// Type: UINT32 +DEFINE_GUID(MF_EVENT_SOURCE_CHARACTERISTICS, +0x47db8490, 0x8b22, 0x4f52, 0xaf, 0xda, 0x9c, 0xe1, 0xb2, 0xd3, 0xcf, 0xa8); + +// MF_EVENT_SOURCE_CHARACTERISTICS_OLD {47DB8491-8B22-4f52-AFDA-9CE1B2D3CFA8} +// Type: UINT32 +DEFINE_GUID(MF_EVENT_SOURCE_CHARACTERISTICS_OLD, +0x47db8491, 0x8b22, 0x4f52, 0xaf, 0xda, 0x9c, 0xe1, 0xb2, 0xd3, 0xcf, 0xa8); + +// +// MESourceRateChangeRequested attributes +// + +// MF_EVENT_DO_THINNING {321EA6FB-DAD9-46e4-B31D-D2EAE7090E30} +// Type: UINT32 +DEFINE_GUID(MF_EVENT_DO_THINNING, +0x321ea6fb, 0xdad9, 0x46e4, 0xb3, 0x1d, 0xd2, 0xea, 0xe7, 0x9, 0xe, 0x30); + +// +// MEStreamSinkScrubSampleComplete attributes +// + +// MF_EVENT_SCRUBSAMPLE_TIME {9AC712B3-DCB8-44d5-8D0C-37455A2782E3} +// Type: UINT64 +DEFINE_GUID(MF_EVENT_SCRUBSAMPLE_TIME, +0x9ac712b3, 0xdcb8, 0x44d5, 0x8d, 0xc, 0x37, 0x45, 0x5a, 0x27, 0x82, 0xe3); + +// +// MESinkInvalidated and MESessionStreamSinkFormatChanged attributes +// + +// MF_EVENT_OUTPUT_NODE {830f1a8b-c060-46dd-a801-1c95dec9b107} +// Type: UINT64 +DEFINE_GUID(MF_EVENT_OUTPUT_NODE, +0x830f1a8b, 0xc060, 0x46dd, 0xa8, 0x01, 0x1c, 0x95, 0xde, 0xc9, 0xb1, 0x07); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +#if (WINVER >= _WIN32_WINNT_WIN7) +// +// METransformNeedInput attributes +// + +// MF_EVENT_MFT_INPUT_STREAM_ID {F29C2CCA-7AE6-42d2-B284-BF837CC874E2} +// Type: UINT32 +DEFINE_GUID(MF_EVENT_MFT_INPUT_STREAM_ID, +0xf29c2cca, 0x7ae6, 0x42d2, 0xb2, 0x84, 0xbf, 0x83, 0x7c, 0xc8, 0x74, 0xe2); + +// +// METransformDrainComplete and METransformMarker attributes +// + +// MF_EVENT_MFT_CONTEXT {B7CD31F1-899E-4b41-80C9-26A896D32977} +// Type: UINT64 +DEFINE_GUID(MF_EVENT_MFT_CONTEXT, +0xb7cd31f1, 0x899e, 0x4b41, 0x80, 0xc9, 0x26, 0xa8, 0x96, 0xd3, 0x29, 0x77); + +#endif // (WINVER >= _WIN32_WINNT_WIN7) + +#if (WINVER >= _WIN32_WINNT_WINBLUE) +// +// MEContentProtectionMetadata attributes +// + +// MF_EVENT_STREAM_METADATA_KEYDATA {CD59A4A1-4A3B-4BBD-8665-72A40FBEA776} +// Type: BLOB +DEFINE_GUID(MF_EVENT_STREAM_METADATA_KEYDATA, +0xcd59a4a1, 0x4a3b, 0x4bbd, 0x86, 0x65, 0x72, 0xa4, 0xf, 0xbe, 0xa7, 0x76); + +// MF_EVENT_STREAM_METADATA_CONTENT_KEYIDS {5063449D-CC29-4FC6-A75A-D247B35AF85C} +// Type: BLOB +DEFINE_GUID(MF_EVENT_STREAM_METADATA_CONTENT_KEYIDS, +0x5063449d, 0xcc29, 0x4fc6, 0xa7, 0x5a, 0xd2, 0x47, 0xb3, 0x5a, 0xf8, 0x5c); + +// MF_EVENT_STREAM_METADATA_SYSTEMID {1EA2EF64-BA16-4A36-8719-FE7560BA32AD} +// Type: BLOB +DEFINE_GUID(MF_EVENT_STREAM_METADATA_SYSTEMID, +0x1ea2ef64, 0xba16, 0x4a36, 0x87, 0x19, 0xfe, 0x75, 0x60, 0xba, 0x32, 0xad); + + + +#endif // (WINVER >= _WIN32_WINNT_WINBLUE) + +//////////////////////////////////////////////////////////////////////////////// +/////////////////////////////// Samples ////////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + +// +// Creates an instance of the Media Foundation implementation of IMFSample +// + + + +STDAPI MFCreateSample( _Out_ IMFSample **ppIMFSample ); + + +// +// Sample attributes +// These are the well-known attributes that can be present on an MF Sample's +// IMFAttributes store +// + +//@@MFSampleExtension_MaxDecodeFrameSize +/// +// {D3CC654F-F9F3-4A13-889F-F04EB2B5B957} MFSampleExtension_MaxDecodeFrameSize {UINT64 (HI32(Width),LO32(Height))} +// specify the maxiumum resolution of compressed input bitstream, +// the decoder shall decode any comressed pictures below the specified maximum resolution +// any input compressed pictures beyond the maximum resolution shall not be decoded and dropped by the decoder +// the attribute shall be set on input sample +/// +DEFINE_GUID(MFSampleExtension_MaxDecodeFrameSize, + 0xd3cc654f, 0xf9f3, 0x4a13, 0x88, 0x9f, 0xf0, 0x4e, 0xb2, 0xb5, 0xb9, 0x57); + + +//@@MFSampleExtension_AccumulatedNonRefPicPercent +/// +// {79EA74DF-A740-445B-BC98-C9ED1F260EEE} MFSampleExtension_AccumulatedNonRefPicPercent +// Type: UINT32 +// specify the percentage of accumulated non-reference pictures up to this output sample in decoding order +// The most common examples are, +// 1. if the sequence has the GOP structure of IPPPP......, the value will be 0 +// 2. if the sequence has the GOP structure of IPBPB......, the percentage will be around 40%~50%. The value is 40~50. +// 3. if the sequence has the GOP structure of IPBBPBB......, the percentage will be around 50%~66%. The value is 50~60. +// where B frames are not used for reference. +// This is some statistic to application or pipeline whether decoder alone can have graceful degradation on quality management +// In the above example, +// 1. Decoder alone can't have graceful quality management. Because it can only have full frame rate or 1/15 of full frame rate when GOP size is 15 frames or 1/30 when GOP size is 30 frames +// 2. Decoder alone can have quality management. Because it can have full frame rate or 1/2 of full frame rate or 1/GOPSize +// 2. Decoder alone can have quality management. Because it can have full frame rate, or down to 1/3 of full frame rate or 1/GOPSize +// the attribute could be set on output sample from decoders +/// +// {79EA74DF-A740-445B-BC98-C9ED1F260EEE} +DEFINE_GUID(MFSampleExtension_AccumulatedNonRefPicPercent, + 0x79ea74df, 0xa740, 0x445b, 0xbc, 0x98, 0xc9, 0xed, 0x1f, 0x26, 0xe, 0xee); + +//////////////////////////////////////////////////////////////////////////////// +// Sample extensions for SAMPLE-AES encryption + +// MFSampleExtension_Encryption_ProtectionScheme {D054D096-28BB-45DA-87EC-74F351871406} +// Type: UINT32 +// Specifies the cipher and mode used to encrypt the content +DEFINE_GUID(MFSampleExtension_Encryption_ProtectionScheme, + 0xd054d096, 0x28bb, 0x45da, 0x87, 0xec, 0x74, 0xf3, 0x51, 0x87, 0x14, 0x6); + + +typedef enum _MFSampleEncryptionProtectionScheme +{ + MF_SAMPLE_ENCRYPTION_PROTECTION_SCHEME_NONE = 0, + MF_SAMPLE_ENCRYPTION_PROTECTION_SCHEME_AES_CTR = 1, + MF_SAMPLE_ENCRYPTION_PROTECTION_SCHEME_AES_CBC = 2, +} MFSampleEncryptionProtectionScheme; + + + +// MFSampleExtension_Encryption_CryptByteBlock {9D84289B-0C7F-4713-AB95-108AB42AD801} +// Type: UINT32 +// Represents the number of encrypted blocks in the protection pattern, where each block is 16 bytes. +DEFINE_GUID(MFSampleExtension_Encryption_CryptByteBlock, + 0x9d84289b, 0xc7f, 0x4713, 0xab, 0x95, 0x10, 0x8a, 0xb4, 0x2a, 0xd8, 0x1); + +// MFSampleExtension_Encryption_SkipByteBlock {0D550548-8317-4AB1-845F-D06306E293E3} +// Type: UINT32 +// Represents the number of unencrypted blocks in the protection pattern, where each block is 16 bytes. +DEFINE_GUID(MFSampleExtension_Encryption_SkipByteBlock, + 0xd550548, 0x8317, 0x4ab1, 0x84, 0x5f, 0xd0, 0x63, 0x6, 0xe2, 0x93, 0xe3); + +//////////////////////////////////////////////////////////////////////////////// + +// Attributes for HW-DRM support + +//@@MFSampleExtension_Encryption_SubSample_Mapping +/// +/// The data blob associated with this attribute should contain an array of byte +/// ranges as DWORDs where every two DWORDs make a set. The first DWORD in each set +/// is the number of clear bytes and the second DWORD of the set is the number of +/// encrypted bytes. +/// Note that a pair of 0s is not a valid set (either value can be 0, but not both). +/// The array of byte ranges that indicate which ranges to decrypt, including the +/// possibility that the entire sample should NOT be decrypted. +/// It must be set on an IMFSample using SetBlob +/// +DEFINE_GUID(MFSampleExtension_Encryption_SubSample_Mapping, + 0x8444F27A, 0x69A1, 0x48DA, 0xBD, 0x08, 0x11, 0xCE, 0xF3, 0x68, 0x30, 0xD2); + + +// MFSampleExtension_Encryption_ClearSliceHeaderData {5509A4F4-320D-4E6C-8D1A-94C66DD20CB0} +/* +The MF blob should be parsed in the way below defined in SliceHeaderSet, with proper verifications + +============================================================================================================= +Note the slice header data here DO NOT have all bits for all the syntaxes. +Some bits are removed on purpose to send out a lossy compressed slice header in order to be 100% secure +The partial slice header data here SHALL not include any bits for emulation prevention byte 0x03 +============================================================================================================= + +typedef struct SliceHeader_tag { +WORD dSliceHeaderLen; // indicate the length of the following slice header in byte, it shall not be more than 1024 +BYTE SliceHeaderBytes[0]; // slice header data, the last byte might contain some bits not used, leave them random +} SliceHeader; + +With dSliceHeaderLen bytes serialized after the SliceHeader struct. +And then use an array of these serialized consecutively, + +typedef struct SliceHeaderSet_tag { +WORD dNumHeaders; // indicate the number of slice headers in the input sample +SliceHeader rgstSliceheader[0]; // cNumHeaders slice header data +} SliceHeaderSet; +*/ +// Type: BLOB +DEFINE_GUID(MFSampleExtension_Encryption_ClearSliceHeaderData, + 0x5509a4f4, 0x320d, 0x4e6c, 0x8d, 0x1a, 0x94, 0xc6, 0x6d, 0xd2, 0xc, 0xb0); + + +// MFSampleExtension_Encryption_HardwareProtection_KeyInfoID {8CBFCCEB-94A5-4DE1-8231-A85E47CF81E7} +// Type: GUID +// This attribute applies to media samples. The GUID associated with this +// attribute indicates an identifier (KID/LID) for the hardware protection to be +// used for the given sample. All hardware protected samples flowing out of the +// MFT decryptor should have this attribute set with the proper GUID. +DEFINE_GUID(MFSampleExtension_Encryption_HardwareProtection_KeyInfoID, +0x8cbfcceb, 0x94a5, 0x4de1, 0x82, 0x31, 0xa8, 0x5e, 0x47, 0xcf, 0x81, 0xe7); + + +// MFSampleExtension_Encryption_HardwareProtection_KeyInfo {B2372080-455B-4DD7-9989-1A955784B754} +// Type: BLOB +// This attribute applies to media samples. The data blob associated with this +// sample has all the information relative to the slot/ID for the hardware +// protection to be used for the given sample. All hardware protected samples +// flowing out of the MFT decryptor should have this attribute set with the +// proper blob. +DEFINE_GUID(MFSampleExtension_Encryption_HardwareProtection_KeyInfo, +0xb2372080, 0x455b, 0x4dd7, 0x99, 0x89, 0x1a, 0x95, 0x57, 0x84, 0xb7, 0x54); + +// MFSampleExtension_Encryption_HardwareProtection_VideoDecryptorContext {693470C8-E837-47A0-88CB-535B905E3582} +// Data type: IUnknown * (IMFContentDecryptorContext) +// This attribute applies to media samples. It associates a sample with a +// given IMFContentDecryptorContext which is needed to be able to to +// decrypt/decode the sample properly when using hardware protection. +DEFINE_GUID(MFSampleExtension_Encryption_HardwareProtection_VideoDecryptorContext, +0x693470c8, 0xe837, 0x47a0, 0x88, 0xcb, 0x53, 0x5b, 0x90, 0x5e, 0x35, 0x82); + + +// MFSampleExtension_Encryption_Opaque_Data {224D77E5-1391-4FFB-9F41-B432F68C611D} +// Data type : BLOB +// This attribute applies to media samples.The data blob associated with this sample has some private information +// set by OEM secure environment to be used for the given sample.The hardware protected samples flowing out of the +// MFT decryptor might have this attribute set with the proper blob. +// When present, this attribute is set by the decryptor MFT with data that originates from the OEM secure environment. +// The host decoder may extract this and provide the data to the D3D11 device for VLD decoding through(UINT PrivateDataSize, void* pPrivateData) +// of D3D11_VIDEO_DECODER_BEGIN_FRAME_CRYPTO_SESSION data structure in the DecoderBeginFrame() call, when present. +DEFINE_GUID(MFSampleExtension_Encryption_Opaque_Data, + 0x224d77e5, 0x1391, 0x4ffb, 0x9f, 0x41, 0xb4, 0x32, 0xf6, 0x8c, 0x61, 0x1d); + + +// MFSampleExtension_NALULengthInfo. This is an alias of MF_NALU_LENGTH_INFORMATION +// Type: BLOB +// Set MFSampleExtension_NALULengthInfo as a BLOB on the input sample, +// with one DWORD for each NALU including start code and NALU type in the sample. For example, if +// there are AUD (9 bytes), SPS (25 bytes), PPS (10 bytes), IDR slice1 (50 k), IDR slice 2 (60 k), +// then there should be 5 DWORDs with values 9, 25, 10, 50 k, 60 k in the BLOB. +// +DEFINE_GUID(MFSampleExtension_NALULengthInfo, + 0x19124E7C, 0xAD4B, 0x465F, 0xBB, 0x18, 0x20, 0x18, 0x62, 0x87, 0xB6, 0xAF); + + + +// MFSampleExtension_Encryption_ResumeVideoOutput. {A435ABA5-AFDE-4CF5-BC1C-F6ACAF13949D} +// Type: UINT32 +// +// This attribute shall be used in hardware DRM scenario only +// it is set on input compressed sample to (H.264/HEVC) video decoder +// +// when present, it indicates video output in video render should resume on the first output (uncompressed) sample +// with the attribute MFSampleExtension_Encryption_ResumeVideoOutput set to true +// +// note: (H.264/HEVC) video decoder should buffer the attribute when video decoder +// detects the attribute set to true on some input sample, which might be dropped since +// those input sample might not be decode-able because of missing references, +// and set the attribute to true on the first output sample not dropped in video decoder +// +DEFINE_GUID(MFSampleExtension_Encryption_ResumeVideoOutput, + 0xa435aba5, 0xafde, 0x4cf5, 0xbc, 0x1c, 0xf6, 0xac, 0xaf, 0x13, 0x94, 0x9d); + + + +// MFSampleExtension_Encryption_NALUTypes. {B0F067C7-714C-416C-8D59-5F4DDF8913B6} +// Type: BLOB +// The MF blob contains all the NALU type byte for different NALUs in the MF sample.One NALU type is one byte, including the syntaxes forbidden_zero_bit, nal_ref_idc, and nal_unit_type. +DEFINE_GUID(MFSampleExtension_Encryption_NALUTypes, + 0xb0f067c7, 0x714c, 0x416c, 0x8d, 0x59, 0x5f, 0x4d, 0xdf, 0x89, 0x13, 0xb6); + + +// MFSampleExtension_Encryption_SPSPPSData {AEDE0FA2-0E0C-453C-B7F3-DE8693364D11} +// Type : BLOB +// When present, the MF blob contains all SPS(s) and / or PPS(s) NALUs inside the MF sample. +// SPSs and PPSs shall be present in the same order as that in the MF sample and in the format of AvcC, +// which is DWORD, four - byte length inforamtion for the bytes followed, and NALU data of SPS or PPS, for each NALU. +// For example, the layout could be 10 in DWORD, 10 bytes data for SPS, 5 in DWORD, and 5 bytes data for PPS.In total, it has 4 + 10 + 4 + 5 = 23 bytes. +DEFINE_GUID(MFSampleExtension_Encryption_SPSPPSData, + 0xaede0fa2, 0xe0c, 0x453c, 0xb7, 0xf3, 0xde, 0x86, 0x93, 0x36, 0x4d, 0x11); + + + +// MFSampleExtension_Encryption_SEIData {3CF0E972-4542-4687-9999-585F565FBA7D} +// Type : BLOB +// When present, the MF blob contains all SEI NALUs inside the MF sample. (If there are multiple SEIs in the protected MF sample, all the SEIs shall be present in the blob.) +// SEIs shall be present in the same order as that in the MF sample and in the format of AvcC, +// which is DWORD, four - byte length inforamtion for the bytes followed, and NALU data of SEI. +// For example, the layout could be 10 in DWORD, 10 bytes data for the first SEI, 5 in DWORD, and 5 bytes data for the second SEI.In total, it has 4 + 10 + 4 + 5 = 23 bytes. +// +// Some note about how to process the SEI NALUs in the blob of MFSampleExtension_Encryption_SEIData +// Decoder should verify every byte of an SEI NALU is clear, not protected, before parsing the SEI NALU +// otherwise, decoder should treat the SEI NALU as corrupted by encryption and skip the parsing of the SEI NALU +DEFINE_GUID(MFSampleExtension_Encryption_SEIData, + 0x3cf0e972, 0x4542, 0x4687, 0x99, 0x99, 0x58, 0x5f, 0x56, 0x5f, 0xba, 0x7d); + + +// MFSampleExtension_Encryption_HardwareProtection {9A2B2D2B-8270-43E3-8448-994F426E8886} +// Type: UINT32 +// When present, this UINT32 attribute indicates whether the sample is hardware protected. +// 0 = not hardware protected, nonzero = hardware protected +DEFINE_GUID(MFSampleExtension_Encryption_HardwareProtection, + 0x9a2b2d2b, 0x8270, 0x43e3, 0x84, 0x48, 0x99, 0x4f, 0x42, 0x6e, 0x88, 0x86); + + +// MFSampleExtension_CleanPoint {9cdf01d8-a0f0-43ba-b077-eaa06cbd728a} +// Type: UINT32 +// If present and nonzero, indicates that the sample is a clean point (key +// frame), and decoding can begin at this sample. +DEFINE_GUID(MFSampleExtension_CleanPoint, +0x9cdf01d8, 0xa0f0, 0x43ba, 0xb0, 0x77, 0xea, 0xa0, 0x6c, 0xbd, 0x72, 0x8a); + +// MFSampleExtension_Discontinuity {9cdf01d9-a0f0-43ba-b077-eaa06cbd728a} +// Type: UINT32 +// If present and nonzero, indicates that the sample data represents the first +// sample following a discontinuity (gap) in the stream of samples. +// This can happen, for instance, if the previous sample was lost in +// transmission. +DEFINE_GUID(MFSampleExtension_Discontinuity, +0x9cdf01d9, 0xa0f0, 0x43ba, 0xb0, 0x77, 0xea, 0xa0, 0x6c, 0xbd, 0x72, 0x8a); + +// MFSampleExtension_Token {8294da66-f328-4805-b551-00deb4c57a61} +// Type: IUNKNOWN +// When an IMFMediaStream delivers a sample via MEMediaStream, this attribute +// should be set to the IUnknown *pToken argument that was passed with the +// IMFMediaStream::RequestSample call to which this sample corresponds. +DEFINE_GUID(MFSampleExtension_Token, +0x8294da66, 0xf328, 0x4805, 0xb5, 0x51, 0x00, 0xde, 0xb4, 0xc5, 0x7a, 0x61); + +// MFSampleExtension_ClosedCaption_CEA708 {26f09068-e744-47dc-aa03-dbf20403bde6} +// Type: BLOB +// MF sample attribute contained the closed caption data in CEA-708 format. +DEFINE_GUID(MFSampleExtension_ClosedCaption_CEA708, 0x26f09068, 0xe744, 0x47dc, 0xaa, 0x03, 0xdb, 0xf2, 0x04, 0x03, 0xbd, 0xe6); +#define MFSampleExtension_ClosedCaption_CEA708_MAX_SIZE 256 + +// MFSampleExtension_DecodeTimestamp {73A954D4-09E2-4861-BEFC-94BD97C08E6E} +// Type : UINT64 +// If present, contains the DTS (Decoding Time Stamp) of the sample. +DEFINE_GUID(MFSampleExtension_DecodeTimestamp, +0x73a954d4, 0x9e2, 0x4861, 0xbe, 0xfc, 0x94, 0xbd, 0x97, 0xc0, 0x8e, 0x6e); + +// MFSampleExtension_VideoEncodeQP {B2EFE478-F979-4C66-B95E-EE2B82C82F36} +// Type: UINT64 +// Used by video encoders to specify the QP used to encode the output sample. +DEFINE_GUID(MFSampleExtension_VideoEncodeQP, +0xb2efe478, 0xf979, 0x4c66, 0xb9, 0x5e, 0xee, 0x2b, 0x82, 0xc8, 0x2f, 0x36); + +// MFSampleExtension_VideoEncPictureType {973704E6-CD14-483C-8F20-C9FC0928BAD5} +// Type: UINT32 +// Used by video encoders to specify the output sample's picture type. +DEFINE_GUID(MFSampleExtension_VideoEncodePictureType, +0x973704e6, 0xcd14, 0x483c, 0x8f, 0x20, 0xc9, 0xfc, 0x9, 0x28, 0xba, 0xd5); + +// MFSampleExtension_FrameCorruption {B4DD4A8C-0BEB-44C4-8B75-B02B913B04F0} +// Type: UINT32 +// Indicates whether the frame in the sample has corruption or not +// value 0 indicates that there is no corruption, or it is unknown +// Value 1 indicates that some corruption was detected e.g, during decoding +DEFINE_GUID(MFSampleExtension_FrameCorruption, +0xb4dd4a8c, 0xbeb, 0x44c4, 0x8b, 0x75, 0xb0, 0x2b, 0x91, 0x3b, 0x4, 0xf0); + +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) + +// MFSampleExtension_DirtyRects {9BA70225-B342-4E97-9126-0B566AB7EA7E} +// Type: BLOB +// This is a blob containing information about the dirty rectangles within +// a frame. The blob is a struct of type DIRTYRECT_INFO containing an array +// of NumDirtyRects number of DirtyRects elements. +DEFINE_GUID(MFSampleExtension_DirtyRects, +0x9ba70225, 0xb342, 0x4e97, 0x91, 0x26, 0x0b, 0x56, 0x6a, 0xb7, 0xea, 0x7e); + +// MFSampleExtension_MoveRegions {E2A6C693-3A8B-4B8D-95D0-F60281A12FB7} +// Type: BLOB +// This is a blob containing information about the moved regions within +// a frame. The blob is a struct of type MOVEREGION_INFO containing an array +// of NumMoveRegions number of MoveRegions elements. +DEFINE_GUID(MFSampleExtension_MoveRegions, +0xe2a6c693, 0x3a8b, 0x4b8d, 0x95, 0xd0, 0xf6, 0x02, 0x81, 0xa1, 0x2f, 0xb7); + +typedef struct _MOVE_RECT +{ + POINT SourcePoint; + RECT DestRect; +} MOVE_RECT; + +typedef struct _DIRTYRECT_INFO +{ + UINT FrameNumber; + UINT NumDirtyRects; + RECT DirtyRects[1]; +} DIRTYRECT_INFO; + +typedef struct _MOVEREGION_INFO +{ + UINT FrameNumber; + UINT NumMoveRegions; + MOVE_RECT MoveRegions[1]; +} MOVEREGION_INFO; + +// MFSampleExtension_HDCP_OptionalHeader +// Type: BLOB +// This blob contains LPCM header in front of LPCM sample in a PES packet. It is +// encrypted when HDCP 2.x frames are sent, and is needed for decryption. +DEFINE_GUID(MFSampleExtension_HDCP_OptionalHeader, + 0x9a2e7390, 0x121f, 0x455f, 0x83, 0x76, 0xc9, 0x74, 0x28, 0xe0, 0xb5, 0x40); + +// MFSampleExtension_HDCP_FrameCounter +// Type: BLOB +// This blob contains the PES_private_data section of a PES packet according to the +// HDCP 2.2/2.1 specification. This blob should contain the stream counter and +// input counter. +DEFINE_GUID(MFSampleExtension_HDCP_FrameCounter, + 0x9d389c60, 0xf507, 0x4aa6, 0xa4, 0xa, 0x71, 0x2, 0x7a, 0x2, 0xf3, 0xde); + +// MFSampleExtension_HDCP_StreamID {177E5D74-C370-4A7A-95A2-36833C01D0AF} +// Type: UINT32 +// This UINT32 value is provided to the HDCP Encryptor MFT on each input sample. +// The Stream ID value allows the HDCP Encryptor MFT to support time-multiplexed +// encryption of multiple independent streams. An example is using 0 for first +// display video stream, 1 for second display video stream, 2 for first display audio +// stream, 3 for second display audio stream. +// Per the HDCP 2.2 specification, this value is referred to as streamCtr. It is called +// StreamID here to be more intuitive. +DEFINE_GUID(MFSampleExtension_HDCP_StreamID, + 0x177e5d74, 0xc370, 0x4a7a, 0x95, 0xa2, 0x36, 0x83, 0x3c, 0x01, 0xd0, 0xaf); + +// MFSampleExtension_Timestamp +// Type: int64 +// { 1e436999-69be-4c7a-9369-70068c0260cb } MFSampleExtension_Timestamp {INT64 } +// The timestamp of a sample +// +DEFINE_GUID(MFSampleExtension_Timestamp, + 0x1e436999, 0x69be, 0x4c7a, 0x93, 0x69, 0x70, 0x06, 0x8c, 0x02, 0x60, 0xcb); + +// MFSampleExtension_RepeatFrame {88BE738F-0711-4F42-B458-344AED42EC2F} +// Type: UINT32 +// This UINT32 when set to 1 indicates that the frame is a repeat of the previous frame +DEFINE_GUID(MFSampleExtension_RepeatFrame, + 0x88be738f, 0x711, 0x4f42, 0xb4, 0x58, 0x34, 0x4a, 0xed, 0x42, 0xec, 0x2f); + +// MFT_ENCODER_ERROR {C8D1EDA4-98E4-41D5-9297-44F53852F90E} +// Type: GUID +// This is the GUID of a property that caused the encoder MFT to fail initialization +DEFINE_GUID(MFT_ENCODER_ERROR, + 0xc8d1eda4, 0x98e4, 0x41d5, 0x92, 0x97, 0x44, 0xf5, 0x38, 0x52, 0xf9, 0x0e); + +// MFT_GFX_DRIVER_VERSION_ID_Attribute {F34B9093-05E0-4B16-993D-3E2A2CDE6AD3} +// Type: WSTR +// For hardware MFTs, this attribute allows the HMFT to report the graphics driver version. +DEFINE_GUID(MFT_GFX_DRIVER_VERSION_ID_Attribute, + 0xf34b9093, 0x05e0, 0x4b16, 0x99, 0x3d, 0x3e, 0x2a, 0x2c, 0xde, 0x6a, 0xd3); + +#endif + +///////////////////////////////////////////////////////////////////////////// +// +// The following sample attributes are used for encrypted samples +// +///////////////////////////////////////////////////////////////////////////// + +// MFSampleExtension_DescrambleData {43483BE6-4903-4314-B032-2951365936FC} +// Type: UINT64 +DEFINE_GUID(MFSampleExtension_DescrambleData, +0x43483be6, 0x4903, 0x4314, 0xb0, 0x32, 0x29, 0x51, 0x36, 0x59, 0x36, 0xfc); + +// MFSampleExtension_SampleKeyID {9ED713C8-9B87-4B26-8297-A93B0C5A8ACC} +// Type: UINT32 +DEFINE_GUID(MFSampleExtension_SampleKeyID, +0x9ed713c8, 0x9b87, 0x4b26, 0x82, 0x97, 0xa9, 0x3b, 0x0c, 0x5a, 0x8a, 0xcc); + +// MFSampleExtension_GenKeyFunc {441CA1EE-6B1F-4501-903A-DE87DF42F6ED} +// Type: UINT64 +DEFINE_GUID(MFSampleExtension_GenKeyFunc, +0x441ca1ee, 0x6b1f, 0x4501, 0x90, 0x3a, 0xde, 0x87, 0xdf, 0x42, 0xf6, 0xed); + +// MFSampleExtension_GenKeyCtx {188120CB-D7DA-4B59-9B3E-9252FD37301C} +// Type: UINT64 +DEFINE_GUID(MFSampleExtension_GenKeyCtx, +0x188120cb, 0xd7da, 0x4b59, 0x9b, 0x3e, 0x92, 0x52, 0xfd, 0x37, 0x30, 0x1c); + +// MFSampleExtension_PacketCrossOffsets {2789671D-389F-40BB-90D9-C282F77F9ABD} +// Type: BLOB +DEFINE_GUID(MFSampleExtension_PacketCrossOffsets, +0x2789671d, 0x389f, 0x40bb, 0x90, 0xd9, 0xc2, 0x82, 0xf7, 0x7f, 0x9a, 0xbd); + +// MFSampleExtension_Encryption_SampleID {6698B84E-0AFA-4330-AEB2-1C0A98D7A44D} +// Type: BLOB +DEFINE_GUID(MFSampleExtension_Encryption_SampleID, +0x6698b84e, 0x0afa, 0x4330, 0xae, 0xb2, 0x1c, 0x0a, 0x98, 0xd7, 0xa4, 0x4d); + +// MFSampleExtension_Encryption_KeyID {76376591-795F-4DA1-86ED-9D46ECA109A9} +// Type: BLOB +DEFINE_GUID(MFSampleExtension_Encryption_KeyID, +0x76376591, 0x795f, 0x4da1, 0x86, 0xed, 0x9d, 0x46, 0xec, 0xa1, 0x09, 0xa9); + +// MFSampleExtension_Content_KeyID {C6C7F5B0-ACCA-415B-87D9-10441469EFC6} +// Type: GUID +DEFINE_GUID(MFSampleExtension_Content_KeyID, +0xc6c7f5b0, 0xacca, 0x415b, 0x87, 0xd9, 0x10, 0x44, 0x14, 0x69, 0xef, 0xc6); + +// MFSampleExtension_Encryption_SubSampleMappingSplit {FE0254B9-2AA5-4EDC-99F7-17E89DBF9174} +// Type: BLOB +// Specifies the regions of clear and encrypted bytes in the sample +DEFINE_GUID(MFSampleExtension_Encryption_SubSampleMappingSplit, +0xfe0254b9, 0x2aa5, 0x4edc, 0x99, 0xf7, 0x17, 0xe8, 0x9d, 0xbf, 0x91, 0x74); + +///////////////////////////////////////////////////////////////////////////// +// +// MFSample STANDARD EXTENSION ATTRIBUTE GUIDs +// +///////////////////////////////////////////////////////////////////////////// + +// {b1d5830a-deb8-40e3-90fa-389943716461} MFSampleExtension_Interlaced {UINT32 (BOOL)} +DEFINE_GUID(MFSampleExtension_Interlaced, +0xb1d5830a, 0xdeb8, 0x40e3, 0x90, 0xfa, 0x38, 0x99, 0x43, 0x71, 0x64, 0x61); + +// {941ce0a3-6ae3-4dda-9a08-a64298340617} MFSampleExtension_BottomFieldFirst {UINT32 (BOOL)} +DEFINE_GUID(MFSampleExtension_BottomFieldFirst, +0x941ce0a3, 0x6ae3, 0x4dda, 0x9a, 0x08, 0xa6, 0x42, 0x98, 0x34, 0x06, 0x17); + +// {304d257c-7493-4fbd-b149-9228de8d9a99} MFSampleExtension_RepeatFirstField {UINT32 (BOOL)} +DEFINE_GUID(MFSampleExtension_RepeatFirstField, +0x304d257c, 0x7493, 0x4fbd, 0xb1, 0x49, 0x92, 0x28, 0xde, 0x8d, 0x9a, 0x99); + +// {9d85f816-658b-455a-bde0-9fa7e15ab8f9} MFSampleExtension_SingleField {UINT32 (BOOL)} +DEFINE_GUID(MFSampleExtension_SingleField, +0x9d85f816, 0x658b, 0x455a, 0xbd, 0xe0, 0x9f, 0xa7, 0xe1, 0x5a, 0xb8, 0xf9); + +// {6852465a-ae1c-4553-8e9b-c3420fcb1637} MFSampleExtension_DerivedFromTopField {UINT32 (BOOL)} +DEFINE_GUID(MFSampleExtension_DerivedFromTopField, +0x6852465a, 0xae1c, 0x4553, 0x8e, 0x9b, 0xc3, 0x42, 0x0f, 0xcb, 0x16, 0x37); + +// MFSampleExtension_MeanAbsoluteDifference {1cdbde11-08b4-4311-a6dd-0f9f371907aa} +// Type: UINT32 +DEFINE_GUID(MFSampleExtension_MeanAbsoluteDifference, +0x1cdbde11, 0x08b4, 0x4311, 0xa6, 0xdd, 0x0f, 0x9f, 0x37, 0x19, 0x07, 0xaa); + +// MFSampleExtension_LongTermReferenceFrameInfo {9154733f-e1bd-41bf-81d3-fcd918f71332} +// Type: UINT32 +DEFINE_GUID(MFSampleExtension_LongTermReferenceFrameInfo, +0x9154733f, 0xe1bd, 0x41bf, 0x81, 0xd3, 0xfc, 0xd9, 0x18, 0xf7, 0x13, 0x32); + +typedef struct _ROI_AREA { + RECT rect; + INT32 QPDelta; +} ROI_AREA, *PROI_AREA; + +// MFSampleExtension_ROIRectangle {3414a438-4998-4d2c-be82-be3ca0b24d43} +// Type: BLOB +DEFINE_GUID(MFSampleExtension_ROIRectangle, +0x3414a438, 0x4998, 0x4d2c, 0xbe, 0x82, 0xbe, 0x3c, 0xa0, 0xb2, 0x4d, 0x43); + +// MFSampleExtension_LastSlice {2b5d5457-5547-4f07-b8c8-b4a3a9a1daac} +// Type: UINT32 +DEFINE_GUID(MFSampleExtension_LastSlice, +0x2b5d5457, 0x5547, 0x4f07, 0xb8, 0xc8, 0xb4, 0xa3, 0xa9, 0xa1, 0xda, 0xac); + +// Indicates macroblock is not needed for output and can be skipped +#define MACROBLOCK_FLAG_SKIP 0x00000001 +// Indicates macroblock is changed from the previous frame +#define MACROBLOCK_FLAG_DIRTY 0x00000002 +// Indicates macroblock from the previous frame has moved to a new position +#define MACROBLOCK_FLAG_MOTION 0x00000004 +// Indicates macroblock contains video playback or other continuous motion, rather than a slower moving screen capture +#define MACROBLOCK_FLAG_VIDEO 0x00000008 +// Indicates that the motion vector values of MACROBLOCK_DATA are valid, and should be used in preference to +// the encoder's calculated motion vector values +#define MACROBLOCK_FLAG_HAS_MOTION_VECTOR 0x00000010 +// Indicates that the QPDelta value of MACROBLOCK_DATA is valid, and specifies the QP of this macroblock relative +// to the rest of the frame +#define MACROBLOCK_FLAG_HAS_QP 0x00000020 + +typedef struct _MACROBLOCK_DATA { + UINT32 flags; + INT16 motionVectorX; + INT16 motionVectorY; + INT32 QPDelta; +} MACROBLOCK_DATA; + +// MFSampleExtension_FeatureMap {a032d165-46fc-400a-b449-49de53e62a6e} +// Type: BLOB +// Blob should contain one MACROBLOCK_DATA structure for each macroblock in the +// input frame. +DEFINE_GUID(MFSampleExtension_FeatureMap, +0xa032d165, 0x46fc, 0x400a, 0xb4, 0x49, 0x49, 0xde, 0x53, 0xe6, 0x2a, 0x6e); + +// MFSampleExtension_ChromaOnly {1eb9179c-a01f-4845-8c04-0e65a26eb04f} +// Type: BOOL (UINT32) +// Set to 1 if the input sample is a chroma-only frame +DEFINE_GUID(MFSampleExtension_ChromaOnly, +0x1eb9179c, 0xa01f, 0x4845, 0x8c, 0x04, 0x0e, 0x65, 0xa2, 0x6e, 0xb0, 0x4f); + +/////////////////////////////////////////////////////////////////////////////// +/// These are the attribute GUIDs that need to be used by MFT0 to provide +/// thumbnail support. We are declaring these in our internal idl first and +/// once we pass API spec review, we can move it to the public header. +/////////////////////////////////////////////////////////////////////////////// +// MFSampleExtension_PhotoThumbnail +// {74BBC85C-C8BB-42DC-B586DA17FFD35DCC} +// Type: IUnknown +// If this attribute is set on the IMFSample provided by the MFT0, this will contain the IMFMediaBuffer which contains +// the Photo Thumbnail as configured using the KSPROPERTYSETID_ExtendedCameraControl. +DEFINE_GUID(MFSampleExtension_PhotoThumbnail, +0x74BBC85C, 0xC8BB, 0x42DC, 0xB5, 0x86, 0xDA, 0x17, 0xFF, 0xD3, 0x5D, 0xCC); + +// MFSampleExtension_PhotoThumbnailMediaType +// {61AD5420-EBF8-4143-89AF6BF25F672DEF} +// Type: IUnknown +// This attribute will contain the IMFMediaType which describes the image format type contained in the +// MFSampleExtension_PhotoThumbnail attribute. If the MFSampleExtension_PhotoThumbnail attribute +// is present on the photo sample, the MFSampleExtension_PhotoThumbnailMediaType is required. +DEFINE_GUID(MFSampleExtension_PhotoThumbnailMediaType, +0x61AD5420, 0xEBF8, 0x4143, 0x89, 0xAF, 0x6B, 0xF2, 0x5F, 0x67, 0x2D, 0xEF); + +// MFSampleExtension_CaptureMetadata +// Type: IUnknown (IMFAttributes) +// This is the IMFAttributes store for all the metadata related to the capture +// pipeline. It can be potentially present on any IMFSample. +DEFINE_GUID(MFSampleExtension_CaptureMetadata, +0x2EBE23A8, 0xFAF5, 0x444A, 0xA6, 0xA2, 0xEB, 0x81, 0x08, 0x80, 0xAB, 0x5D); + +// MFSampleExtension_MDLCacheCookie +// Type: IUnknown (IMFAttributes) +// This is the IMFAttributes stored in the sample if the mini driver +// desires to cache MDL's. This is used internally by the pipeline. +// {5F002AF9-D8F9-41A3-B6C3-A2AD43F647AD} + +DEFINE_GUID(MFSampleExtension_MDLCacheCookie, +0x5F002AF9, 0xD8F9, 0x41A3, 0xB6, 0xC3, 0xA2, 0xAD, 0x43, 0xF6, 0x47, 0xAD); + +// Put all MF_CAPTURE_METADATA_* here. +// {0F9DD6C6-6003-45D8-BD59-F1F53E3D04E8} MF_CAPTURE_METADATA_PHOTO_FRAME_FLASH {UINT32} +// 0 - No flash triggered on this frame. +// non-0 - Flash triggered on this frame. +// Do not explicitly check for a value of 1 here, we may overload this to +// indicate special types of flash going forward (applications should only +// check for != 0 to indicate flash took place). +DEFINE_GUID(MF_CAPTURE_METADATA_PHOTO_FRAME_FLASH, +0x0F9DD6C6, 0x6003, 0x45D8, 0xBD, 0x59, 0xF1, 0xF5, 0x3E, 0x3D, 0x04, 0xE8); + +// The raw IUnknown corresponding to the IMFMediaBuffer that contains the metadata +// stream as written by the camera driver. This may be a mix of pre-defined metadata +// such as photo confirmation, focus notification, or custom metadata that only +// the MFT0 can parse. +DEFINE_GUID(MF_CAPTURE_METADATA_FRAME_RAWSTREAM, +0x9252077B, 0x2680, 0x49B9, 0xAE, 0x02, 0xB1, 0x90, 0x75, 0x97, 0x3B, 0x70); + +// {A87EE154-997F-465D-B91F-29D53B982B88} +// TYPE: UINT32 +DEFINE_GUID(MF_CAPTURE_METADATA_FOCUSSTATE, +0xa87ee154, 0x997f, 0x465d, 0xb9, 0x1f, 0x29, 0xd5, 0x3b, 0x98, 0x2b, 0x88); + +// {BB3716D9-8A61-47A4-8197-459C7FF174D5} +// TYPE: UINT32 +DEFINE_GUID(MF_CAPTURE_METADATA_REQUESTED_FRAME_SETTING_ID, +0xbb3716d9, 0x8a61, 0x47a4, 0x81, 0x97, 0x45, 0x9c, 0x7f, 0xf1, 0x74, 0xd5); + +// {16B9AE99-CD84-4063-879D-A28C7633729E} +// TYPE: UINT32 +DEFINE_GUID(MF_CAPTURE_METADATA_EXPOSURE_TIME, +0x16b9ae99, 0xcd84, 0x4063, 0x87, 0x9d, 0xa2, 0x8c, 0x76, 0x33, 0x72, 0x9e); + +// {D198AA75-4B62-4345-ABF3-3C31FA12C299} +DEFINE_GUID(MF_CAPTURE_METADATA_EXPOSURE_COMPENSATION, +0xd198aa75, 0x4b62, 0x4345, 0xab, 0xf3, 0x3c, 0x31, 0xfa, 0x12, 0xc2, 0x99); + +// {E528A68F-B2E3-44FE-8B65-07BF4B5A13FF} +// TYPE: UINT32 +DEFINE_GUID(MF_CAPTURE_METADATA_ISO_SPEED, +0xe528a68f, 0xb2e3, 0x44fe, 0x8b, 0x65, 0x7, 0xbf, 0x4b, 0x5a, 0x13, 0xff); + +// {B5FC8E86-11D1-4E70-819B-723A89FA4520} +// TYPE: UINT32 +DEFINE_GUID(MF_CAPTURE_METADATA_LENS_POSITION, +0xb5fc8e86, 0x11d1, 0x4e70, 0x81, 0x9b, 0x72, 0x3a, 0x89, 0xfa, 0x45, 0x20); + +// {9CC3B54D-5ED3-4BAE-B388-7670AEF59E13} +// TYPE: UINT64 +DEFINE_GUID(MF_CAPTURE_METADATA_SCENE_MODE, +0x9cc3b54d, 0x5ed3, 0x4bae, 0xb3, 0x88, 0x76, 0x70, 0xae, 0xf5, 0x9e, 0x13); + +// {4A51520B-FB36-446C-9DF2-68171B9A0389} +// TYPE: UINT32 +DEFINE_GUID(MF_CAPTURE_METADATA_FLASH, +0x4a51520b, 0xfb36, 0x446c, 0x9d, 0xf2, 0x68, 0x17, 0x1b, 0x9a, 0x3, 0x89); + +// {9C0E0D49-0205-491A-BC9D-2D6E1F4D5684} +// TYPE: UINT32 +DEFINE_GUID(MF_CAPTURE_METADATA_FLASH_POWER, +0x9c0e0d49, 0x205, 0x491a, 0xbc, 0x9d, 0x2d, 0x6e, 0x1f, 0x4d, 0x56, 0x84); + +// {C736FD77-0FB9-4E2E-97A2-FCD490739EE9} +// TYPE: UINT32 +DEFINE_GUID(MF_CAPTURE_METADATA_WHITEBALANCE, +0xc736fd77, 0xfb9, 0x4e2e, 0x97, 0xa2, 0xfc, 0xd4, 0x90, 0x73, 0x9e, 0xe9); + +// {E50B0B81-E501-42C2-ABF2-857ECB13FA5C} +// TYPE: UINT32 +DEFINE_GUID(MF_CAPTURE_METADATA_ZOOMFACTOR, +0xe50b0b81, 0xe501, 0x42c2, 0xab, 0xf2, 0x85, 0x7e, 0xcb, 0x13, 0xfa, 0x5c); + +// {864F25A6-349F-46B1-A30E-54CC22928A47} +// TYPE: BLOB +DEFINE_GUID(MF_CAPTURE_METADATA_FACEROIS, +0x864f25a6, 0x349f, 0x46b1, 0xa3, 0xe, 0x54, 0xcc, 0x22, 0x92, 0x8a, 0x47); + +// {E94D50CC-3DA0-44d4-BB34-83198A741868} +// TYPE: BLOB +DEFINE_GUID(MF_CAPTURE_METADATA_FACEROITIMESTAMPS, +0xe94d50cc, 0x3da0, 0x44d4, 0xbb, 0x34, 0x83, 0x19, 0x8a, 0x74, 0x18, 0x68); + +// {B927A1A8-18EF-46d3-B3AF-69372F94D9B2} +// TYPE: BLOB +DEFINE_GUID(MF_CAPTURE_METADATA_FACEROICHARACTERIZATIONS, +0xb927a1a8, 0x18ef, 0x46d3, 0xb3, 0xaf, 0x69, 0x37, 0x2f, 0x94, 0xd9, 0xb2); + +// {05802AC9-0E1D-41c7-A8C8-7E7369F84E1E} +// TYPE: BLOB +DEFINE_GUID(MF_CAPTURE_METADATA_ISO_GAINS, +0x5802ac9, 0xe1d, 0x41c7, 0xa8, 0xc8, 0x7e, 0x73, 0x69, 0xf8, 0x4e, 0x1e); + +// {DB51357E-9D3D-4962-B06D-07CE650D9A0A} +// TYPE: UINT64 +DEFINE_GUID(MF_CAPTURE_METADATA_SENSORFRAMERATE, +0xdb51357e, 0x9d3d, 0x4962, 0xb0, 0x6d, 0x7, 0xce, 0x65, 0xd, 0x9a, 0xa); + +// {E7570C8F-2DCB-4c7c-AACE-22ECE7CCE647} +// TYPE: BLOB +DEFINE_GUID(MF_CAPTURE_METADATA_WHITEBALANCE_GAINS, +0xe7570c8f, 0x2dcb, 0x4c7c, 0xaa, 0xce, 0x22, 0xec, 0xe7, 0xcc, 0xe6, 0x47); + +// {85358432-2EF6-4ba9-A3FB-06D82974B895} +// TYPE: BLOB +DEFINE_GUID(MF_CAPTURE_METADATA_HISTOGRAM, +0x85358432, 0x2ef6, 0x4ba9, 0xa3, 0xfb, 0x6, 0xd8, 0x29, 0x74, 0xb8, 0x95); + +// {2e9575b8-8c31-4a02-8575-42b197b71592} +// TYPE: BLOB +DEFINE_GUID(MF_CAPTURE_METADATA_EXIF, +0x2e9575b8, 0x8c31, 0x4a02, 0x85, 0x75, 0x42, 0xb1, 0x97, 0xb7, 0x15, 0x92); + +// {6D688FFC-63D3-46FE-BADA-5B947DB0D080} +// TYPE: UINT64 +DEFINE_GUID(MF_CAPTURE_METADATA_FRAME_ILLUMINATION, +0x6D688FFC, 0x63D3, 0x46FE, 0xBA, 0xDA, 0x5B, 0x94, 0x7D, 0xB0, 0xD0, 0x80); + +// MF_CAPTURE_METADATA_UVC_PAYLOADHEADER {F9F88A87-E1DD-441E-95CB-42E21A64F1D9} +// Value type: Blob +// Stores USB Video Class Camera's payload header for user mode components to +// get the camera timestamps and other header information. +DEFINE_GUID(MF_CAPTURE_METADATA_UVC_PAYLOADHEADER, + 0xf9f88a87, 0xe1dd, 0x441e, 0x95, 0xcb, 0x42, 0xe2, 0x1a, 0x64, 0xf1, 0xd9); + +// MFSampleExtension_Depth_MinReliableDepth +// Type: UINT32, minimum reliable depth value in a D16 format depth frame. +// Default value if the attribute is absent is 1, because 0 represent invalid depth +// {5F8582B2-E36B-47C8-9B87-FEE1CA72C5B0} +DEFINE_GUID(MFSampleExtension_Depth_MinReliableDepth, +0x5f8582b2, 0xe36b, 0x47c8, 0x9b, 0x87, 0xfe, 0xe1, 0xca, 0x72, 0xc5, 0xb0); + +// MFSampleExtension_Depth_MaxReliableDepth +// Type: UINT32, maximum reliable depth value in a D16 format depth frame +// Default value if the attribute is absent is 65535 +// {E45545D1-1F0F-4A32-A8A7-6101A24EA8BE} +DEFINE_GUID(MFSampleExtension_Depth_MaxReliableDepth, +0xe45545d1, 0x1f0f, 0x4a32, 0xa8, 0xa7, 0x61, 0x1, 0xa2, 0x4e, 0xa8, 0xbe); + +// MF_CAPTURE_METADATA_FIRST_SCANLINE_START_TIME_QPC {F9F88A87-E1DD-441E-95CB-42E21A64F1D9} +// Value type: UINT64 +// Stores value of the start of scan in QPC time +DEFINE_GUID(MF_CAPTURE_METADATA_FIRST_SCANLINE_START_TIME_QPC, + 0x6a2c49f1, 0xe052, 0x46b6, 0xb2, 0xd9, 0x73, 0xc1, 0x55, 0x87, 0x09, 0xaf); + +// MF_CAPTURE_METADATA_LAST_SCANLINE_END_TIME_QPC {F9F88A87-E1DD-441E-95CB-42E21A64F1D9} +// Value type: UINT64 +// Stores value of the end of scan in QPC time +DEFINE_GUID(MF_CAPTURE_METADATA_LAST_SCANLINE_END_TIME_QPC, + 0xdccadecb, 0xc4d4, 0x400d, 0xb4, 0x18, 0x10, 0xe8, 0x85, 0x25, 0xe1, 0xf6); + +// MF_CAPTURE_METADATA_SCANLINE_TIME_QPC_ACCURACY {F9F88A87-E1DD-441E-95CB-42E21A64F1D9} +// Value type: UINT64 +// Stores value of timestamp accuracy in QPC time absolute value +DEFINE_GUID(MF_CAPTURE_METADATA_SCANLINE_TIME_QPC_ACCURACY, + 0x4cd79c51, 0xf765, 0x4b09, 0xb1, 0xe1, 0x27, 0xd1, 0xf7, 0xeb, 0xea, 0x09); + +// MF_CAPTURE_METADATA_SCAN_DIRECTION {F9F88A87-E1DD-441E-95CB-42E21A64F1D9} +// Value type: UINT32 +// Bitfield of the way the scan is read. If value is 0x00, scan is Left to Right, Top to Bottom +// 0x0 - Left -> Right +// 0x1 - Right -> Left +// 0x2 Bottom -> Top +// 0x0 - Horizontal Scanline +// 0x4 - Vertical Scanline +DEFINE_GUID(MF_CAPTURE_METADATA_SCANLINE_DIRECTION, + 0x6496a3ba, 0x1907, 0x49e6, 0xb0, 0xc3, 0x12, 0x37, 0x95, 0xf3, 0x80, 0xa9); + +#define MFCAPTURE_METADATA_SCAN_RIGHT_LEFT 0x00000001 +#define MFCAPTURE_METADATA_SCAN_BOTTOM_TOP 0x00000002 +#define MFCAPTURE_METADATA_SCANLINE_VERTICAL 0x00000004 + +typedef struct tagFaceRectInfoBlobHeader +{ + ULONG Size; // Size of this header + all FaceRectInfo following + ULONG Count; // Number of FaceRectInfo's in the blob +} FaceRectInfoBlobHeader; + +typedef struct tagFaceRectInfo +{ + RECT Region; // Relative coordinates on the frame (Q31 format) + LONG confidenceLevel; // Confidence Level of the region being a face +} FaceRectInfo; + + +typedef struct tagFaceCharacterizationBlobHeader +{ + ULONG Size; // Size of this header + all FaceCharacterization following + ULONG Count; // Number of FaceCharacterization's in the blob. Must match the number of FaceRectInfo's in FaceRectInfoBlobHeader +} FaceCharacterizationBlobHeader; + + +typedef struct tagFaceCharacterization +{ + ULONG BlinkScoreLeft; // [0, 100]. 0 indicates no blink for the left eye. 100 indicates definite blink for the left eye + ULONG BlinkScoreRight; // [0, 100]. 0 indicates no blink for the right eye. 100 indicates definite blink for the right eye + ULONG FacialExpression; // Any one of the MF_METADATAFACIALEXPRESSION_XXX defined + ULONG FacialExpressionScore; // [0, 100]. 0 indicates no such facial expression as identified. 100 indicates definite such facial expression as defined +} FaceCharacterization; + +#define MF_METADATAFACIALEXPRESSION_SMILE 0x00000001 + +typedef struct tagCapturedMetadataExposureCompensation +{ + UINT64 Flags; // KSCAMERA_EXTENDEDPROP_EVCOMP_XXX step flag + INT32 Value; // EV Compensation value in units of the step +} CapturedMetadataExposureCompensation; + + +typedef struct tagCapturedMetadataISOGains +{ + FLOAT AnalogGain; + FLOAT DigitalGain; +} CapturedMetadataISOGains; + +typedef struct tagCapturedMetadataWhiteBalanceGains +{ + FLOAT R; + FLOAT G; + FLOAT B; +} CapturedMetadataWhiteBalanceGains; + +typedef struct tagMetadataTimeStamps +{ + ULONG Flags; // Bitwise OR of MF_METADATATIMESTAMPS_XXX flags + LONGLONG Device; // QPC time for the sample where the metadata is derived from (in 100ns) + LONGLONG Presentation; // PTS for the sample where the metadata is derived from (in 100ns) +} MetadataTimeStamps; + +#define MF_METADATATIMESTAMPS_DEVICE 0x00000001 +#define MF_METADATATIMESTAMPS_PRESENTATION 0x00000002 + +typedef struct tagHistogramGrid +{ + ULONG Width; // Width of the sensor output that histogram is collected from + ULONG Height; // Height of the sensor output that histogram is collected from + + RECT Region; // Absolute coordinates of the region on the sensor output that the histogram is collected for +} HistogramGrid; + +typedef struct tagHistogramBlobHeader +{ + ULONG Size; // Size of the entire histogram blob in bytes + ULONG Histograms; // Number of histograms in the blob. Each histogram is identified by a HistogramHeader +} HistogramBlobHeader; + +typedef struct tagHistogramHeader +{ + ULONG Size; // Size in bytes of this header + (HistogramDataHeader + histogram data following)*number of channels available + ULONG Bins; // Number of bins in the histogram + ULONG FourCC; // Color space that the histogram is collected from + ULONG ChannelMasks; // Masks of the color channels that the histogram is collected for + HistogramGrid Grid; // Grid that the histogram is collected from +} HistogramHeader; + +typedef struct tagHistogramDataHeader +{ + ULONG Size; // Size in bytes of this header + histogram data following + ULONG ChannelMask; // Mask of the color channel for the histogram data + ULONG Linear; // 1, if linear; 0 nonlinear +} HistogramDataHeader; + +#define MF_HISTOGRAM_CHANNEL_Y 0x00000001 +#define MF_HISTOGRAM_CHANNEL_R 0x00000002 +#define MF_HISTOGRAM_CHANNEL_G 0x00000004 +#define MF_HISTOGRAM_CHANNEL_B 0x00000008 +#define MF_HISTOGRAM_CHANNEL_Cb 0x00000010 +#define MF_HISTOGRAM_CHANNEL_Cr 0x00000020 + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////// Attributes //////////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + + +STDAPI +MFCreateAttributes( + _Out_ IMFAttributes** ppMFAttributes, + _In_ UINT32 cInitialSize + ); + +STDAPI +MFInitAttributesFromBlob( + _In_ IMFAttributes* pAttributes, + _In_reads_bytes_(cbBufSize) const UINT8* pBuf, + _In_ UINT cbBufSize + ); + +STDAPI +MFGetAttributesAsBlobSize( + _In_ IMFAttributes* pAttributes, + _Out_ UINT32* pcbBufSize + ); + +STDAPI +MFGetAttributesAsBlob( + _In_ IMFAttributes* pAttributes, + _Out_writes_bytes_(cbBufSize) UINT8* pBuf, + _In_ UINT cbBufSize + ); + + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////// MFT Register & Enum //////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + +// +// MFT Registry categories +// + +#ifdef MF_INIT_GUIDS +//#include +#endif + +// {d6c02d4b-6833-45b4-971a-05a4b04bab91} MFT_CATEGORY_VIDEO_DECODER +DEFINE_GUID(MFT_CATEGORY_VIDEO_DECODER, +0xd6c02d4b, 0x6833, 0x45b4, 0x97, 0x1a, 0x05, 0xa4, 0xb0, 0x4b, 0xab, 0x91); + +// {f79eac7d-e545-4387-bdee-d647d7bde42a} MFT_CATEGORY_VIDEO_ENCODER +DEFINE_GUID(MFT_CATEGORY_VIDEO_ENCODER, +0xf79eac7d, 0xe545, 0x4387, 0xbd, 0xee, 0xd6, 0x47, 0xd7, 0xbd, 0xe4, 0x2a); + +// {12e17c21-532c-4a6e-8a1c-40825a736397} MFT_CATEGORY_VIDEO_EFFECT +DEFINE_GUID(MFT_CATEGORY_VIDEO_EFFECT, +0x12e17c21, 0x532c, 0x4a6e, 0x8a, 0x1c, 0x40, 0x82, 0x5a, 0x73, 0x63, 0x97); + +// {059c561e-05ae-4b61-b69d-55b61ee54a7b} MFT_CATEGORY_MULTIPLEXER +DEFINE_GUID(MFT_CATEGORY_MULTIPLEXER, +0x059c561e, 0x05ae, 0x4b61, 0xb6, 0x9d, 0x55, 0xb6, 0x1e, 0xe5, 0x4a, 0x7b); + +// {a8700a7a-939b-44c5-99d7-76226b23b3f1} MFT_CATEGORY_DEMULTIPLEXER +DEFINE_GUID(MFT_CATEGORY_DEMULTIPLEXER, +0xa8700a7a, 0x939b, 0x44c5, 0x99, 0xd7, 0x76, 0x22, 0x6b, 0x23, 0xb3, 0xf1); + +// {9ea73fb4-ef7a-4559-8d5d-719d8f0426c7} MFT_CATEGORY_AUDIO_DECODER +DEFINE_GUID(MFT_CATEGORY_AUDIO_DECODER, +0x9ea73fb4, 0xef7a, 0x4559, 0x8d, 0x5d, 0x71, 0x9d, 0x8f, 0x04, 0x26, 0xc7); + +// {91c64bd0-f91e-4d8c-9276-db248279d975} MFT_CATEGORY_AUDIO_ENCODER +DEFINE_GUID(MFT_CATEGORY_AUDIO_ENCODER, +0x91c64bd0, 0xf91e, 0x4d8c, 0x92, 0x76, 0xdb, 0x24, 0x82, 0x79, 0xd9, 0x75); + +// {11064c48-3648-4ed0-932e-05ce8ac811b7} MFT_CATEGORY_AUDIO_EFFECT +DEFINE_GUID(MFT_CATEGORY_AUDIO_EFFECT, +0x11064c48, 0x3648, 0x4ed0, 0x93, 0x2e, 0x05, 0xce, 0x8a, 0xc8, 0x11, 0xb7); + +#if (WINVER >= _WIN32_WINNT_WIN7) +// {302EA3FC-AA5F-47f9-9F7A-C2188BB163021}...MFT_CATEGORY_VIDEO_PROCESSOR +DEFINE_GUID(MFT_CATEGORY_VIDEO_PROCESSOR, +0x302ea3fc, 0xaa5f, 0x47f9, 0x9f, 0x7a, 0xc2, 0x18, 0x8b, 0xb1, 0x63, 0x2); +#endif // (WINVER >= _WIN32_WINNT_WIN7) + +// {90175d57-b7ea-4901-aeb3-933a8747756f} MFT_CATEGORY_OTHER +DEFINE_GUID(MFT_CATEGORY_OTHER, +0x90175d57, 0xb7ea, 0x4901, 0xae, 0xb3, 0x93, 0x3a, 0x87, 0x47, 0x75, 0x6f); + +#if (NTDDI_VERSION >= NTDDI_WIN10_RS1) +DEFINE_GUID(MFT_CATEGORY_ENCRYPTOR, +0xb0c687be, 0x01cd, 0x44b5, 0xb8, 0xb2, 0x7c, 0x1d, 0x7e, 0x05, 0x8b, 0x1f); +#endif + +// TODO: switch to NTDDI_WIN10_RS3 when _NT_TARGET_VERSION is updated to support RS3 +#if (NTDDI_VERSION >= NTDDI_WIN10_RS2) +// {145CD8B4-92F4-4b23-8AE7-E0DF06C2DA95} MFT_CATEGORY_VIDEO_RENDERER_EFFECT +DEFINE_GUID(MFT_CATEGORY_VIDEO_RENDERER_EFFECT, +0x145cd8b4, 0x92f4, 0x4b23, 0x8a, 0xe7, 0xe0, 0xdf, 0x6, 0xc2, 0xda, 0x95); +#endif + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +// +// "Flags" is for future expansion - for now must be 0 +// +STDAPI +MFTRegister( + _In_ CLSID clsidMFT, + _In_ GUID guidCategory, + _In_ LPWSTR pszName, + _In_ UINT32 Flags, + _In_ UINT32 cInputTypes, + _In_reads_opt_(cInputTypes) MFT_REGISTER_TYPE_INFO* pInputTypes, + _In_ UINT32 cOutputTypes, + _In_reads_opt_(cOutputTypes) MFT_REGISTER_TYPE_INFO* pOutputTypes, + _In_opt_ IMFAttributes* pAttributes + ); + +STDAPI +MFTUnregister( + _In_ CLSID clsidMFT + ); + +#if (WINVER >= _WIN32_WINNT_WIN7) +// Register an MFT class in-process +STDAPI +MFTRegisterLocal( + _In_ IClassFactory* pClassFactory, + _In_ REFGUID guidCategory, + _In_ LPCWSTR pszName, + _In_ UINT32 Flags, + _In_ UINT32 cInputTypes, + _In_reads_opt_(cInputTypes)const MFT_REGISTER_TYPE_INFO* pInputTypes, + _In_ UINT32 cOutputTypes, + _In_reads_opt_(cOutputTypes)const MFT_REGISTER_TYPE_INFO* pOutputTypes + ); + +// Unregister locally registered MFT +// If pClassFactory is NULL all local MFTs are unregistered +STDAPI +MFTUnregisterLocal( + _In_opt_ IClassFactory * pClassFactory + ); + +// Register an MFT class in-process, by CLSID +STDAPI +MFTRegisterLocalByCLSID( + _In_ REFCLSID clisdMFT, + _In_ REFGUID guidCategory, + _In_ LPCWSTR pszName, + _In_ UINT32 Flags, + _In_ UINT32 cInputTypes, + _In_reads_opt_(cInputTypes)const MFT_REGISTER_TYPE_INFO* pInputTypes, + _In_ UINT32 cOutputTypes, + _In_reads_opt_(cOutputTypes)const MFT_REGISTER_TYPE_INFO* pOutputTypes + ); + +// Unregister locally registered MFT by CLSID +STDAPI +MFTUnregisterLocalByCLSID( + _In_ CLSID clsidMFT + ); +#endif // (WINVER >= _WIN32_WINNT_WIN7) + +// +// result *ppclsidMFT must be freed with CoTaskMemFree. +// +STDAPI +MFTEnum( + _In_ GUID guidCategory, + _In_ UINT32 Flags, + _In_opt_ MFT_REGISTER_TYPE_INFO* pInputType, + _In_opt_ MFT_REGISTER_TYPE_INFO* pOutputType, + _In_opt_ IMFAttributes* pAttributes, + _Outptr_result_buffer_(*pcMFTs) CLSID** ppclsidMFT, // must be freed with CoTaskMemFree + _Out_ UINT32* pcMFTs + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +#if (WINVER >= _WIN32_WINNT_WIN7) + +enum _MFT_ENUM_FLAG +{ + MFT_ENUM_FLAG_SYNCMFT = 0x00000001, // Enumerates V1 MFTs. This is default. + MFT_ENUM_FLAG_ASYNCMFT = 0x00000002, // Enumerates only software async MFTs also known as V2 MFTs + MFT_ENUM_FLAG_HARDWARE = 0x00000004, // Enumerates V2 hardware async MFTs + MFT_ENUM_FLAG_FIELDOFUSE = 0x00000008, // Enumerates MFTs that require unlocking + MFT_ENUM_FLAG_LOCALMFT = 0x00000010, // Enumerates Locally (in-process) registered MFTs + MFT_ENUM_FLAG_TRANSCODE_ONLY = 0x00000020, // Enumerates decoder MFTs used by transcode only + MFT_ENUM_FLAG_SORTANDFILTER = 0x00000040, // Apply system local, do not use and preferred sorting and filtering + MFT_ENUM_FLAG_SORTANDFILTER_APPROVED_ONLY = 0x000000C0, // Similar to MFT_ENUM_FLAG_SORTANDFILTER, but apply a local policy of: MF_PLUGIN_CONTROL_POLICY_USE_APPROVED_PLUGINS + MFT_ENUM_FLAG_SORTANDFILTER_WEB_ONLY = 0x00000140, // Similar to MFT_ENUM_FLAG_SORTANDFILTER, but apply a local policy of: MF_PLUGIN_CONTROL_POLICY_USE_WEB_PLUGINS + MFT_ENUM_FLAG_SORTANDFILTER_WEB_ONLY_EDGEMODE = 0x00000240, // Similar to MFT_ENUM_FLAG_SORTANDFILTER, but apply a local policy of: MF_PLUGIN_CONTROL_POLICY_USE_WEB_PLUGINS_EDGEMODE + MFT_ENUM_FLAG_UNTRUSTED_STOREMFT = 0x00000400, // Enumerates all untrusted store MFTs downloaded from the store + MFT_ENUM_FLAG_ALL = 0x0000003F, // Enumerates all MFTs including SW and HW MFTs and applies filtering +}; + +// +// result *pppMFTActivate must be freed with CoTaskMemFree. Each IMFActivate pointer inside this +// buffer should be released. +// + +STDAPI +MFTEnumEx( + _In_ GUID guidCategory, + _In_ UINT32 Flags, + _In_opt_ const MFT_REGISTER_TYPE_INFO* pInputType, + _In_opt_ const MFT_REGISTER_TYPE_INFO* pOutputType, + _Outptr_result_buffer_(*pnumMFTActivate) IMFActivate*** pppMFTActivate, + _Out_ UINT32* pnumMFTActivate +); +#endif // (WINVER >= _WIN32_WINNT_WIN7) + +// TODO: switch to NTDDI_WIN10_RS3 when _NT_TARGET_VERSION is updated to support RS3 +#if (NTDDI_VERSION >= NTDDI_WIN10_RS2) + +// MFT_ENUM_VIDEO_RENDERER_EXTENSION_PROFILE {62C56928-9A4E-443b-B9DC-CAC830C24100} +// Type: VT_VECTOR | VT_LPWSTR +// MFTEnumEx stores this on the attribute store of the IMFActivate object that +// MFTEnumEx creates for MFTs that have an associated UWP Manifest containing the tag +// VideoRendererExtensionProfiles. This contains a list of all VideoRendererExtensionProfile +// entries in the VideoRendererExtensionProfiles tag. +DEFINE_GUID(MFT_ENUM_VIDEO_RENDERER_EXTENSION_PROFILE, +0x62c56928, 0x9a4e, 0x443b, 0xb9, 0xdc, 0xca, 0xc8, 0x30, 0xc2, 0x41, 0x0); + +#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS2) + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +#if (NTDDI_VERSION >= NTDDI_WIN10_RS1) + +// {1D39518C-E220-4DA8-A07F-BA172552D6B1} MFT_ENUM_ADAPTER_LUID +DEFINE_GUID( MFT_ENUM_ADAPTER_LUID, + 0x1d39518c, 0xe220, 0x4da8, 0xa0, 0x7f, 0xba, 0x17, 0x25, 0x52, 0xd6, 0xb1 ); + +STDAPI +MFTEnum2( + _In_ GUID guidCategory, + _In_ UINT32 Flags, + _In_opt_ const MFT_REGISTER_TYPE_INFO* pInputType, + _In_opt_ const MFT_REGISTER_TYPE_INFO* pOutputType, + _In_opt_ IMFAttributes* pAttributes, + _Outptr_result_buffer_( *pnumMFTActivate ) IMFActivate*** pppMFTActivate, + _Out_ UINT32* pnumMFTActivate + ); + +#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS1) + + +// +// results *pszName, *ppInputTypes, and *ppOutputTypes must be freed with CoTaskMemFree. +// *ppAttributes must be released. +// +STDAPI +MFTGetInfo( + _In_ CLSID clsidMFT, + _Out_opt_ LPWSTR* pszName, + _Outptr_opt_result_buffer_(*pcInputTypes) MFT_REGISTER_TYPE_INFO** ppInputTypes, + _Out_opt_ UINT32* pcInputTypes, + _Outptr_opt_result_buffer_(*pcOutputTypes) MFT_REGISTER_TYPE_INFO** ppOutputTypes, + _Out_opt_ UINT32* pcOutputTypes, + _Outptr_opt_result_maybenull_ IMFAttributes** ppAttributes + ); + + +#if (WINVER >= _WIN32_WINNT_WIN7) + +// +// Get the plugin control API +// +STDAPI +MFGetPluginControl( + _Out_ IMFPluginControl **ppPluginControl + ); + +// +// Get MFT's merit - checking that is has a valid certificate +// +STDAPI +MFGetMFTMerit( + _Inout_ IUnknown *pMFT, + _In_ UINT32 cbVerifier, + _In_reads_bytes_(cbVerifier) const BYTE * verifier, + _Out_ DWORD *merit + ); + +#endif // (WINVER >= _WIN32_WINNT_WIN7) + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#if (WINVER >= _WIN32_WINNT_WIN8) + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +STDAPI +MFRegisterLocalSchemeHandler( + _In_ PCWSTR szScheme, + _In_ IMFActivate* pActivate + ); + +STDAPI +MFRegisterLocalByteStreamHandler( + _In_ PCWSTR szFileExtension, + _In_ PCWSTR szMimeType, + _In_ IMFActivate* pActivate + ); + +// +// Wrap a bytestream so that calling Close() on the wrapper +// closes the wrapper but not the original bytestream. The +// original bytestream can then be passed to another +// media source for instance. +// +STDAPI +MFCreateMFByteStreamWrapper( + _In_ IMFByteStream* pStream, + _Out_ IMFByteStream** ppStreamWrapper + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +// +// Create a MF activate object that can instantiate media extension objects. +// The activate object supports both IMFActivate and IClassFactory. +// +STDAPI +MFCreateMediaExtensionActivate( + _In_ PCWSTR szActivatableClassId, + _In_opt_ IUnknown* pConfiguration, + _In_ REFIID riid, + _Outptr_ LPVOID* ppvObject + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#endif // (WINVER >= _WIN32_WINNT_WIN8) + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////// MFT Attributes GUIDs //////////////////////////// +// {53476A11-3F13-49fb-AC42-EE2733C96741} MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE {UINT32 (BOOL)} +DEFINE_GUID(MFT_SUPPORT_DYNAMIC_FORMAT_CHANGE, +0x53476a11, 0x3f13, 0x49fb, 0xac, 0x42, 0xee, 0x27, 0x33, 0xc9, 0x67, 0x41); +/////////////////////////////////////////////////////////////////////////////////////////////////////////////// Media Type GUIDs //////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + +// +// GUIDs for media types +// + +// +// In MF, media types for uncompressed video formats MUST be composed from a FourCC or D3DFORMAT combined with +// the "base GUID" {00000000-0000-0010-8000-00AA00389B71} by replacing the initial 32 bits with the FourCC/D3DFORMAT +// +// Audio media types for types which already have a defined wFormatTag value can be constructed similarly, by +// putting the wFormatTag (zero-extended to 32 bits) into the first 32 bits of the base GUID. +// +// Compressed video or audio can also use any well-known GUID that exists, or can create a new GUID. +// +// GUIDs for common media types are defined below. +// + +// needed for the GUID definition macros below +#ifndef FCC +#define FCC(ch4) ((((DWORD)(ch4) & 0xFF) << 24) | \ + (((DWORD)(ch4) & 0xFF00) << 8) | \ + (((DWORD)(ch4) & 0xFF0000) >> 8) | \ + (((DWORD)(ch4) & 0xFF000000) >> 24)) +#endif + + + + +// +// this macro creates a media type GUID from a FourCC, D3DFMT, or WAVE_FORMAT +// +#ifndef DEFINE_MEDIATYPE_GUID +#define DEFINE_MEDIATYPE_GUID(name, format) \ + DEFINE_GUID(name, \ + format, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); +#endif + +// +// video media types +// + +// +// If no D3D headers have been included yet, define local versions of D3DFMT constants we use. +// We can't include D3D headers from this header because we need it to be compatible with all versions +// of D3D. +// +#ifndef DIRECT3D_VERSION +#define D3DFMT_R8G8B8 20 +#define D3DFMT_A8R8G8B8 21 +#define D3DFMT_X8R8G8B8 22 +#define D3DFMT_R5G6B5 23 +#define D3DFMT_X1R5G5B5 24 +#define D3DFMT_A2B10G10R10 31 +#define D3DFMT_P8 41 +#define D3DFMT_L8 50 +#define D3DFMT_D16 80 +#define D3DFMT_L16 81 +#define D3DFMT_A16B16G16R16F 113 +#define LOCAL_D3DFMT_DEFINES 1 +#endif + +DEFINE_MEDIATYPE_GUID( MFVideoFormat_Base, 0x00000000 ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_RGB32, D3DFMT_X8R8G8B8 ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_ARGB32, D3DFMT_A8R8G8B8 ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_RGB24, D3DFMT_R8G8B8 ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_RGB555, D3DFMT_X1R5G5B5 ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_RGB565, D3DFMT_R5G6B5 ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_RGB8, D3DFMT_P8 ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_L8, D3DFMT_L8 ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_L16, D3DFMT_L16 ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_D16, D3DFMT_D16 ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_AI44, FCC('AI44') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_AYUV, FCC('AYUV') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_YUY2, FCC('YUY2') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_YVYU, FCC('YVYU') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_YVU9, FCC('YVU9') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_UYVY, FCC('UYVY') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_NV11, FCC('NV11') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_NV12, FCC('NV12') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_YV12, FCC('YV12') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_I420, FCC('I420') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_IYUV, FCC('IYUV') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_Y210, FCC('Y210') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_Y216, FCC('Y216') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_Y410, FCC('Y410') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_Y416, FCC('Y416') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_Y41P, FCC('Y41P') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_Y41T, FCC('Y41T') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_Y42T, FCC('Y42T') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_P210, FCC('P210') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_P216, FCC('P216') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_P010, FCC('P010') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_P016, FCC('P016') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_v210, FCC('v210') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_v216, FCC('v216') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_v410, FCC('v410') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_MP43, FCC('MP43') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_MP4S, FCC('MP4S') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_M4S2, FCC('M4S2') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_MP4V, FCC('MP4V') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_WMV1, FCC('WMV1') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_WMV2, FCC('WMV2') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_WMV3, FCC('WMV3') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_WVC1, FCC('WVC1') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_MSS1, FCC('MSS1') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_MSS2, FCC('MSS2') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_MPG1, FCC('MPG1') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_DVSL, FCC('dvsl') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_DVSD, FCC('dvsd') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_DVHD, FCC('dvhd') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_DV25, FCC('dv25') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_DV50, FCC('dv50') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_DVH1, FCC('dvh1') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_DVC, FCC('dvc ') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_H264, FCC('H264') ); // assume MFVideoFormat_H264 is frame aligned. that is, each input sample has one complete compressed frame (one frame picture, two field pictures or a single unpaired field picture) +DEFINE_MEDIATYPE_GUID( MFVideoFormat_H265, FCC('H265') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_MJPG, FCC('MJPG') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_420O, FCC('420O') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_HEVC, FCC('HEVC') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_HEVC_ES, FCC('HEVS') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_VP80, FCC('VP80') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_VP90, FCC('VP90') ); +DEFINE_MEDIATYPE_GUID( MFVideoFormat_ORAW, FCC('ORAW') ); + +#if (WINVER >= _WIN32_WINNT_WIN8) +DEFINE_MEDIATYPE_GUID( MFVideoFormat_H263, FCC('H263') ); +#endif // (WINVER >= _WIN32_WINNT_WIN8) + +#if (WDK_NTDDI_VERSION >= NTDDI_WIN10) +DEFINE_MEDIATYPE_GUID(MFVideoFormat_A2R10G10B10, D3DFMT_A2B10G10R10); +DEFINE_MEDIATYPE_GUID(MFVideoFormat_A16B16G16R16F, D3DFMT_A16B16G16R16F); +#endif + +#if (WDK_NTDDI_VERSION >= NTDDI_WIN10_RS3) +DEFINE_MEDIATYPE_GUID(MFVideoFormat_VP10, FCC('VP10')); +DEFINE_MEDIATYPE_GUID(MFVideoFormat_AV1, FCC('AV01')); +#endif + +#if (WDK_NTDDI_VERSION >= NTDDI_WIN10) +// +// MFSample Perception Date Type-specific attribute GUIDs should be in sync with KSCameraProfileSensorType +// +typedef enum _MFFrameSourceTypes +{ + MFFrameSourceTypes_Color = 0x0001, + MFFrameSourceTypes_Infrared = 0x0002, + MFFrameSourceTypes_Depth = 0x0004, + MFFrameSourceTypes_Image = 0x0008, + MFFrameSourceTypes_Custom = 0x0080 +} MFFrameSourceTypes; + +#endif // (WINVER > _WIN32_WINNT_WIN10) + +// +// undef the local D3DFMT definitions to avoid later clashes with D3D headers +// +#ifdef LOCAL_D3DFMT_DEFINES +#undef D3DFMT_R8G8B8 +#undef D3DFMT_A8R8G8B8 +#undef D3DFMT_X8R8G8B8 +#undef D3DFMT_R5G6B5 +#undef D3DFMT_X1R5G5B5 +#undef D3DFMT_P8 +#undef D3DFMT_A2B10G10R10 +#undef D3DFMT_A16B16G16R16F +#undef D3DFMT_L8 +#undef D3DFMT_D16 +#undef D3DFMT_L16 +#undef LOCAL_D3DFMT_DEFINES +#endif + + +// assume MFVideoFormat_H264_ES may not be frame aligned. that is, each input sample may have one partial frame, +// multiple frames, some frames plus some partial frame +// or more general, N.M frames, N is the integer part and M is the fractional part. +// +// {3F40F4F0-5622-4FF8-B6D8-A17A584BEE5E} MFVideoFormat_H264_ES +DEFINE_GUID(MFVideoFormat_H264_ES, +0x3f40f4f0, 0x5622, 0x4ff8, 0xb6, 0xd8, 0xa1, 0x7a, 0x58, 0x4b, 0xee, 0x5e); + + +// +// some legacy formats that don't fit the common pattern +// + +// {e06d8026-db46-11cf-b4d1-00805f6cbbea} MFVideoFormat_MPEG2 +DEFINE_GUID(MFVideoFormat_MPEG2, +0xe06d8026, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea); + +#define MFVideoFormat_MPG2 MFVideoFormat_MPEG2 + + + +// +// audio media types +// +DEFINE_MEDIATYPE_GUID( MFAudioFormat_Base, 0x00000000 ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_PCM, WAVE_FORMAT_PCM ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_Float, WAVE_FORMAT_IEEE_FLOAT ); + +// MFAudioFormat_DTS is for S/PDIF-encapsulated DTS core streams. It is the same as KSDATAFORMAT_SUBTYPE_IEC61937_DTS in ksmedia.h. +// Use MEDIASUBTYPE_DTS2 (defined in wmcodecdsp.h) for raw DTS core streams. +// If DTS extension substreams may be present, use MEDIASUBTYPE_DTS_HD instead for Master Audio, and MEDIASUBTYPE_DTS_HD_HRA for +// High Resolution Audio and other extension substream variants. +// (KSDATAFORMAT_SUBTYPE_IEC61937_DTS_HD is the S/PDIF media subtype for MEDIASUBTYPE_DTS_HD and MEDIASUBTYPE_DTS_HD_HRA.) +DEFINE_MEDIATYPE_GUID( MFAudioFormat_DTS, WAVE_FORMAT_DTS ); + +// MFAudioFormat_Dolby_AC3_SPDIF is for S/PDIF-encapsulated AC-3. It is the same as KSDATAFORMAT_SUBTYPE_IEC61937_DOLBY_DIGITAL in ksmedia.h. +// Use MFAudioFormat_Dolby_AC3 (MEDIASUBTYPE_DOLBY_AC3 in wmcodecdsp.h) for raw AC-3 streams. +DEFINE_MEDIATYPE_GUID( MFAudioFormat_Dolby_AC3_SPDIF, WAVE_FORMAT_DOLBY_AC3_SPDIF ); + +DEFINE_MEDIATYPE_GUID( MFAudioFormat_DRM, WAVE_FORMAT_DRM ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_WMAudioV8, WAVE_FORMAT_WMAUDIO2 ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_WMAudioV9, WAVE_FORMAT_WMAUDIO3 ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_WMAudio_Lossless, WAVE_FORMAT_WMAUDIO_LOSSLESS ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_WMASPDIF, WAVE_FORMAT_WMASPDIF ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_MSP1, WAVE_FORMAT_WMAVOICE9 ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_MP3, WAVE_FORMAT_MPEGLAYER3 ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_MPEG, WAVE_FORMAT_MPEG ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_AAC, WAVE_FORMAT_MPEG_HEAAC ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_ADTS, WAVE_FORMAT_MPEG_ADTS_AAC ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_AMR_NB, WAVE_FORMAT_AMR_NB ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_AMR_WB, WAVE_FORMAT_AMR_WB ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_AMR_WP, WAVE_FORMAT_AMR_WP ); +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +DEFINE_MEDIATYPE_GUID( MFAudioFormat_FLAC, WAVE_FORMAT_FLAC ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_ALAC, WAVE_FORMAT_ALAC ); +DEFINE_MEDIATYPE_GUID( MFAudioFormat_Opus, WAVE_FORMAT_OPUS ); +#endif + +// These audio types are not derived from an existing wFormatTag +DEFINE_GUID(MFAudioFormat_Dolby_AC3, // == MEDIASUBTYPE_DOLBY_AC3 defined in ksuuids.h +0xe06d802c, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x05f, 0x6c, 0xbb, 0xea); +DEFINE_GUID(MFAudioFormat_Dolby_DDPlus, // == MEDIASUBTYPE_DOLBY_DDPLUS defined in wmcodecdsp.h +0xa7fb87af, 0x2d02, 0x42fb, 0xa4, 0xd4, 0x5, 0xcd, 0x93, 0x84, 0x3b, 0xdd); +DEFINE_GUID(MFAudioFormat_Vorbis, // {8D2FD10B-5841-4a6b-8905-588FEC1ADED9} +0x8D2FD10B, 0x5841, 0x4a6b, 0x89, 0x05, 0x58, 0x8F, 0xEC, 0x1A, 0xDE, 0xD9); + + +#if (NTDDI_VERSION >= NTDDI_WIN10_RS2) + +DEFINE_GUID( MFAudioFormat_Float_SpatialObjects, + 0xfa39cd94, 0xbc64, 0x4ab1, 0x9b, 0x71, 0xdc, 0xd0, 0x9d, 0x5a, 0x7e, 0x7a ); + +#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS2) + +#if (WINVER >= _WIN32_WINNT_THRESHOLD) +// LPCM audio with headers for encapsulation in an MPEG2 bitstream +DEFINE_GUID(MFAudioFormat_LPCM, // == MEDIASUBTYPE_LPCM defined in ksmedia.h +0xe06d8032L, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea); + +DEFINE_GUID(MFAudioFormat_PCM_HDCP, +0xa5e7ff01, 0x8411, 0x4acc, 0xa8, 0x65, 0x5f, 0x49, 0x41, 0x28, 0x8d, 0x80); + +DEFINE_GUID(MFAudioFormat_Dolby_AC3_HDCP, +0x97663a80, 0x8ffb, 0x4445, 0xa6, 0xba, 0x79, 0x2d, 0x90, 0x8f, 0x49, 0x7f); + +DEFINE_GUID(MFAudioFormat_AAC_HDCP, +0x419bce76, 0x8b72, 0x400f, 0xad, 0xeb, 0x84, 0xb5, 0x7d, 0x63, 0x48, 0x4d); + +DEFINE_GUID(MFAudioFormat_ADTS_HDCP, +0xda4963a3, 0x14d8, 0x4dcf, 0x92, 0xb7, 0x19, 0x3e, 0xb8, 0x43, 0x63, 0xdb); + +DEFINE_GUID(MFAudioFormat_Base_HDCP, +0x3884b5bc, 0xe277, 0x43fd, 0x98, 0x3d, 0x03, 0x8a, 0xa8, 0xd9, 0xb6, 0x05); + +DEFINE_GUID(MFVideoFormat_H264_HDCP, +0x5d0ce9dd, 0x9817, 0x49da, 0xbd, 0xfd, 0xf5, 0xf5, 0xb9, 0x8f, 0x18, 0xa6); + +DEFINE_GUID(MFVideoFormat_HEVC_HDCP, +0x3cfe0fe6, 0x05c4, 0x47dc, 0x9d, 0x70, 0x4b, 0xdb, 0x29, 0x59, 0x72, 0x0f); + +DEFINE_GUID(MFVideoFormat_Base_HDCP, +0xeac3b9d5, 0xbd14, 0x4237, 0x8f, 0x1f, 0xba, 0xb4, 0x28, 0xe4, 0x93, 0x12); + +#endif + + +// +// MPEG-4 media types +// + +// {00000000-767a-494d-b478-f29d25dc9037} MFMPEG4Format_Base +DEFINE_GUID(MFMPEG4Format_Base, +0x00000000, 0x767a, 0x494d, 0xb4, 0x78, 0xf2, 0x9d, 0x25, 0xdc, 0x90, 0x37); + + +// +// Subtitle media types +// + +// {2006F94F-29CA-4195-B8DB-00DED8FF0C97} MFSubtitleFormat_XML +DEFINE_GUID(MFSubtitleFormat_XML, + 0x2006f94f, 0x29ca, 0x4195, 0xb8, 0xdb, 0x00, 0xde, 0xd8, 0xff, 0x0c, 0x97); + +// {73E73992-9a10-4356-9557-7194E91E3E54} MFSubtitleFormat_TTML +DEFINE_GUID(MFSubtitleFormat_TTML, + 0x73e73992, 0x9a10, 0x4356, 0x95, 0x57, 0x71, 0x94, 0xe9, 0x1e, 0x3e, 0x54); + +// {7FA7FAA3-FEAE-4E16-AEDF-36B9ACFBB099} MFSubtitleFormat_ATSC +DEFINE_GUID(MFSubtitleFormat_ATSC, + 0x7fa7faa3, 0xfeae, 0x4e16, 0xae, 0xdf, 0x36, 0xb9, 0xac, 0xfb, 0xb0, 0x99); + +// {C886D215-F485-40BB-8DB6-FADBC619A45D} MFSubtitleFormat_WebVTT +DEFINE_GUID(MFSubtitleFormat_WebVTT, + 0xc886d215, 0xf485, 0x40bb, 0x8d, 0xb6, 0xfa, 0xdb, 0xc6, 0x19, 0xa4, 0x5d); + +// {5E467F2E-77CA-4CA5-8391-D142ED4B76C8} MFSubtitleFormat_SRT +DEFINE_GUID(MFSubtitleFormat_SRT, + 0x5e467f2e, 0x77ca, 0x4ca5, 0x83, 0x91, 0xd1, 0x42, 0xed, 0x4b, 0x76, 0xc8); + +// {57176A1B-1A9E-4EEA-ABEF-C61760198AC4} MFSubtitleFormat_SSA +DEFINE_GUID(MFSubtitleFormat_SSA, + 0x57176a1b, 0x1a9e, 0x4eea, 0xab, 0xef, 0xc6, 0x17, 0x60, 0x19, 0x8a, 0xc4); + +// {1BB3D849-6614-4D80-8882-ED24AA82DA92} MFSubtitleFormat_CustomUserData +DEFINE_GUID(MFSubtitleFormat_CustomUserData, + 0x1bb3d849, 0x6614, 0x4d80, 0x88, 0x82, 0xed, 0x24, 0xaa, 0x82, 0xda, 0x92); + + +// +// Binary Data MediaTypes +// + +#ifndef DEFINE_BINARY_MEDIATYPE_GUID +#define DEFINE_BINARY_MEDIATYPE_GUID(name, format) \ + DEFINE_GUID(name, \ + format, 0xbf10, 0x48b4, 0xbc, 0x18, 0x59, 0x3d, 0xc1, 0xdb, 0x95, 0xf); +#endif + +DEFINE_BINARY_MEDIATYPE_GUID(MFBinaryFormat_Base, 0x00000000); +DEFINE_BINARY_MEDIATYPE_GUID(MFBinaryFormat_GPMD, 'gpmd'); + + + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////// Media Type Attributes GUIDs //////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + +// +// GUIDs for IMFMediaType properties - prefix 'MF_MT_' - basic prop type in {}, +// with type to cast to in (). +// + + +// +// core info for all types +// +// {48eba18e-f8c9-4687-bf11-0a74c9f96a8f} MF_MT_MAJOR_TYPE {GUID} +DEFINE_GUID(MF_MT_MAJOR_TYPE, +0x48eba18e, 0xf8c9, 0x4687, 0xbf, 0x11, 0x0a, 0x74, 0xc9, 0xf9, 0x6a, 0x8f); + +// {f7e34c9a-42e8-4714-b74b-cb29d72c35e5} MF_MT_SUBTYPE {GUID} +DEFINE_GUID(MF_MT_SUBTYPE, +0xf7e34c9a, 0x42e8, 0x4714, 0xb7, 0x4b, 0xcb, 0x29, 0xd7, 0x2c, 0x35, 0xe5); + +// {c9173739-5e56-461c-b713-46fb995cb95f} MF_MT_ALL_SAMPLES_INDEPENDENT {UINT32 (BOOL)} +DEFINE_GUID(MF_MT_ALL_SAMPLES_INDEPENDENT, +0xc9173739, 0x5e56, 0x461c, 0xb7, 0x13, 0x46, 0xfb, 0x99, 0x5c, 0xb9, 0x5f); + +// {b8ebefaf-b718-4e04-b0a9-116775e3321b} MF_MT_FIXED_SIZE_SAMPLES {UINT32 (BOOL)} +DEFINE_GUID(MF_MT_FIXED_SIZE_SAMPLES, +0xb8ebefaf, 0xb718, 0x4e04, 0xb0, 0xa9, 0x11, 0x67, 0x75, 0xe3, 0x32, 0x1b); + +// {3afd0cee-18f2-4ba5-a110-8bea502e1f92} MF_MT_COMPRESSED {UINT32 (BOOL)} +DEFINE_GUID(MF_MT_COMPRESSED, +0x3afd0cee, 0x18f2, 0x4ba5, 0xa1, 0x10, 0x8b, 0xea, 0x50, 0x2e, 0x1f, 0x92); + +// +// MF_MT_SAMPLE_SIZE is only valid if MF_MT_FIXED_SIZED_SAMPLES is TRUE +// +// {dad3ab78-1990-408b-bce2-eba673dacc10} MF_MT_SAMPLE_SIZE {UINT32} +DEFINE_GUID(MF_MT_SAMPLE_SIZE, +0xdad3ab78, 0x1990, 0x408b, 0xbc, 0xe2, 0xeb, 0xa6, 0x73, 0xda, 0xcc, 0x10); + +// 4d3f7b23-d02f-4e6c-9bee-e4bf2c6c695d MF_MT_WRAPPED_TYPE {Blob} +DEFINE_GUID(MF_MT_WRAPPED_TYPE, +0x4d3f7b23, 0xd02f, 0x4e6c, 0x9b, 0xee, 0xe4, 0xbf, 0x2c, 0x6c, 0x69, 0x5d); + +#if (WINVER >= _WIN32_WINNT_WIN8) + +// +// Media Type & Sample attributes for 3D Video +// + +// {CB5E88CF-7B5B-476b-85AA-1CA5AE187555} MF_MT_VIDEO_3D {UINT32 (BOOL)} +DEFINE_GUID( MF_MT_VIDEO_3D, +0xcb5e88cf, 0x7b5b, 0x476b, 0x85, 0xaa, 0x1c, 0xa5, 0xae, 0x18, 0x75, 0x55); + +// Enum describing the packing for 3D video frames +typedef enum _MFVideo3DFormat { + MFVideo3DSampleFormat_BaseView = 0, + MFVideo3DSampleFormat_MultiView = 1, + MFVideo3DSampleFormat_Packed_LeftRight = 2, + MFVideo3DSampleFormat_Packed_TopBottom = 3, +} MFVideo3DFormat; + +// {5315d8a0-87c5-4697-b793-666c67c49b} MF_MT_VIDEO_3D_FORMAT {UINT32 (anyof MFVideo3DFormat)} +DEFINE_GUID(MF_MT_VIDEO_3D_FORMAT, +0x5315d8a0, 0x87c5, 0x4697, 0xb7, 0x93, 0x66, 0x6, 0xc6, 0x7c, 0x4, 0x9b); + +// {BB077E8A-DCBF-42eb-AF60-418DF98AA495} MF_MT_VIDEO_3D_NUM_VIEW {UINT32} +DEFINE_GUID( MF_MT_VIDEO_3D_NUM_VIEWS, +0xbb077e8a, 0xdcbf, 0x42eb, 0xaf, 0x60, 0x41, 0x8d, 0xf9, 0x8a, 0xa4, 0x95); + +// {6D4B7BFF-5629-4404-948C-C634F4CE26D4} MF_MT_VIDEO_3D_LEFT_IS_BASE {UINT32} +DEFINE_GUID( MF_MT_VIDEO_3D_LEFT_IS_BASE, +0x6d4b7bff, 0x5629, 0x4404, 0x94, 0x8c, 0xc6, 0x34, 0xf4, 0xce, 0x26, 0xd4); + +// {EC298493-0ADA-4ea1-A4FE-CBBD36CE9331} MF_MT_VIDEO_3D_FIRST_IS_LEFT {UINT32 (BOOL)} +DEFINE_GUID( MF_MT_VIDEO_3D_FIRST_IS_LEFT, +0xec298493, 0xada, 0x4ea1, 0xa4, 0xfe, 0xcb, 0xbd, 0x36, 0xce, 0x93, 0x31); + + +// MFSampleExtension_3DVideo {F86F97A4-DD54-4e2e-9A5E-55FC2D74A005} +// Type: UINT32 +// If present and nonzero, indicates that the sample contains 3D Video data +DEFINE_GUID( MFSampleExtension_3DVideo, +0xf86f97a4, 0xdd54, 0x4e2e, 0x9a, 0x5e, 0x55, 0xfc, 0x2d, 0x74, 0xa0, 0x05); + +// Enum describing the packing for 3D video frames in a sample +typedef enum _MFVideo3DSampleFormat { + MFSampleExtension_3DVideo_MultiView = 1, + MFSampleExtension_3DVideo_Packed = 0, +} MFVideo3DSampleFormat; + +// MFSampleExtension_3DVideo_SampleFormat {08671772-E36F-4cff-97B3-D72E20987A48} +// Type: UINT32 +// The value of this attribute is a member of the MFVideo3DSampleFormat enumeration. +// MFVideo3DSampleFormat enumeration identifies how 3D views are stored in the sample +// - in a packed representation, all views are stored in a single buffer +// - in a multiview representation, each view is stored in its own buffer +DEFINE_GUID( MFSampleExtension_3DVideo_SampleFormat, +0x8671772, 0xe36f, 0x4cff, 0x97, 0xb3, 0xd7, 0x2e, 0x20, 0x98, 0x7a, 0x48); + +// Enum describing the video rotation formats +// Only the values of 0, 90, 180, and 270 are valid. +#ifndef _MFVideoRotationFormat_ +#define _MFVideoRotationFormat_ +typedef enum _MFVideoRotationFormat { + MFVideoRotationFormat_0 = 0, + MFVideoRotationFormat_90 = 90, + MFVideoRotationFormat_180 = 180, + MFVideoRotationFormat_270 = 270, +} MFVideoRotationFormat; +#endif + +// MF_MT_VIDEO_ROTATION {C380465D-2271-428C-9B83-ECEA3B4A85C1} +// Type: UINT32 +// Description: MF_MT_VIDEO_ROTATION attribute means the degree that the content +// has already been rotated in the counter clockwise direction. +// Currently, only the values of 0, 90, 180, and 270 are valid for MF_MT_VIDEO_ROTATION. +// For convenience, these currently supported values are enumerated in MFVideoRotationFormat. +// Example: if the media type has MF_MT_VIDEO_ROTATION set as MFVideoRotationFormat_90, +// it means the content has been rotated 90 degree in the counter clockwise direction. +// If the content was actually rotated 90 degree in the clockwise direction, 90 degree in +// clockwise should be converted into 270 degree in the counter clockwise direction and set +// the attribute MF_MT_VIDEO_ROTATION as MFVideoRotationFormat_270 accordingly. +DEFINE_GUID(MF_MT_VIDEO_ROTATION, +0xc380465d, 0x2271, 0x428c, 0x9b, 0x83, 0xec, 0xea, 0x3b, 0x4a, 0x85, 0xc1); + +#if (NTDDI_VERSION >= NTDDI_WIN10_RS2) +DEFINE_GUID(MF_DEVICESTREAM_MULTIPLEXED_MANAGER, +0x6ea542b0, 0x281f, 0x4231, 0xa4, 0x64, 0xfe, 0x2f, 0x50, 0x22, 0x50, 0x1c); + +DEFINE_GUID(MF_MEDIATYPE_MULTIPLEXED_MANAGER, +0x13c78fb5, 0xf275, 0x4ea0, 0xbb, 0x5f, 0x2, 0x49, 0x83, 0x2b, 0xd, 0x6e); + +DEFINE_GUID(MFSampleExtension_MULTIPLEXED_MANAGER, +0x8dcdee79, 0x6b5a, 0x4c45, 0x8d, 0xb9, 0x20, 0xb3, 0x95, 0xf0, 0x2f, 0xcf); + + +STDAPI MFCreateMuxStreamAttributes( + _In_ IMFCollection *pAttributesToMux, + _COM_Outptr_ IMFAttributes**ppMuxAttribs +); + +STDAPI MFCreateMuxStreamMediaType( + _In_ IMFCollection *pMediaTypesToMux, + _COM_Outptr_ IMFMediaType**ppMuxMediaType +); + +STDAPI MFCreateMuxStreamSample( + _In_ IMFCollection *pSamplesToMux, + _COM_Outptr_ IMFSample**ppMuxSample +); +#endif + +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +// MF_MT_SECURE {c5acc4fd-0304-4ecf-809f-47bc97ff63bd } +// Type: UINT32 (BOOL) +// Description: MF_MT_SECURE attribute indicates that the content will be using +// secure D3D surfaces. These surfaces can only be accessed by trusted hardware. +DEFINE_GUID(MF_MT_SECURE, +0xc5acc4fd, 0x0304, 0x4ecf, 0x80, 0x9f, 0x47, 0xbc, 0x97, 0xff, 0x63, 0xbd); + + +// MF_DEVICESTREAM_ATTRIBUTE_FRAMESOURCE_TYPES {17145FD1-1B2B-423C-8001-2B6833ED3588} +// Type: UINT32 (enum type defined in MFFrameSourceTypes) +// Description: The value of this attribute is a enum value, describing the sensor types. +// For backward compatibility, when this attribute was not defined on in a media type, it is assumed to be MFFrameSourceTypes::Color. +DEFINE_GUID(MF_DEVICESTREAM_ATTRIBUTE_FRAMESOURCE_TYPES, +0x17145fd1, 0x1b2b, 0x423c, 0x80, 0x1, 0x2b, 0x68, 0x33, 0xed, 0x35, 0x88); + +// MF_MT_ALPHA_MODE {5D959B0D-4CBF-4D04-919F-3F5F7F284211} +// Type: UINT32 +// Description: To differentiate the usage of alpha channel in such video formats, a new attribute MF_MT_ALPHA_MODE is designed to describe this information. +// The value of this attribute can be cast to DXGI_ALPHA_MODE. +// If this attribute is not present, for backward compatibility, the value is DXGI_ALPHA_MODE_STRAIGHT for video format supporting alpha channel, +// such as ARGB32, or DXGI_ALPHA_MODE_IGNORE for video format without alpha channel, such as RGB32. +DEFINE_GUID(MF_MT_ALPHA_MODE, +0x5D959B0D, 0x4CBF, 0x4D04, 0x91, 0x9F, 0x3F, 0x5F, 0x7F, 0x28, 0x42, 0x11); + +typedef enum _MFDepthMeasurement +{ + DistanceToFocalPlane = 0, + DistanceToOpticalCenter = 1, +} MFDepthMeasurement; + +// MF_MT_DEPTH_MEASUREMENT {FD5AC489-0917-4BB6-9D54-3122BF70144B} +// Type : UINT32 (MFDepthMeasurement) +// Description: If this attribute is not present, by default it is DistanceToFocalPlane, illustrated by following diagram. +DEFINE_GUID(MF_MT_DEPTH_MEASUREMENT, +0xfd5ac489, 0x917, 0x4bb6, 0x9d, 0x54, 0x31, 0x22, 0xbf, 0x70, 0x14, 0x4b); + +// MF_MT_DEPTH_VALUE_UNIT {21a800f5-3189-4797-beba-f13cd9a31a5e} +// Type : UINT64 +// Description: MF_MT_DEPTH_VALUE_UNIT attribute indicates scale of the depth value in nanometers. +// For each pixel in depth frame, the actual depth measured in nanometers is the pixel value multiplied by this attribute. +DEFINE_GUID(MF_MT_DEPTH_VALUE_UNIT, +0x21a800f5, 0x3189, 0x4797, 0xbe, 0xba, 0xf1, 0x3c, 0xd9, 0xa3, 0x1a, 0x5e); + +#endif + +// MF_MT_VIDEO_NO_FRAME_ORDERING {3F5B106F-6BC2-4EE3-B7ED-8902C18F5351} +// Type: UINT32 +// Description: MF_MT_VIDEO_NO_FRAME_ORDERING set to non-zero (true) means external users/apps know +// that input video bitstream has no frame rerodering, +// that is, the output and display order is the same as the input and decoding order +// it will overwrite bitstream syntaxes even if bitstream syntaxes do not indicate +// that the output and display order is the same as the input and decoding order +// +// it is an attribute set on input media type +// +DEFINE_GUID(MF_MT_VIDEO_NO_FRAME_ORDERING, + 0x3f5b106f, 0x6bc2, 0x4ee3, 0xb7, 0xed, 0x89, 0x2, 0xc1, 0x8f, 0x53, 0x51); + + +// MF_MT_VIDEO_H264_NO_FMOASO {ED461CD6-EC9F-416A-A8A3-26D7D31018D7} +// Type: UINT32 +// Description: MF_MT_VIDEO_H264_NO_FMOASO set to non-zero (true) means external users/apps know +// that H.264 input video bitstream has no FMO/ASO enabled, +// that is, even if the bitstream has baseline profile and constraint_set1_flag equal to 0, +// the bitstream shall not have FMO/ASO +// then H.264 decoder uses DXVA decoding and doesn't fall back to software decoding +// it improves power consumption, memory usage, performance and user experiences +// (without unnecessary glitches on low end devices) +// +// it is an attribute set on input media type +// +DEFINE_GUID(MF_MT_VIDEO_H264_NO_FMOASO, + 0xed461cd6, 0xec9f, 0x416a, 0xa8, 0xa3, 0x26, 0xd7, 0xd3, 0x10, 0x18, 0xd7); + + +#endif // (WINVER >= _WIN32_WINNT_WIN8) + +// TODO: switch to NTDDI_WIN10_RS3 when _NT_TARGET_VERSION is updated to support RS3 +#if (NTDDI_VERSION >= NTDDI_WIN10_RS2) + +// +// Renderer Extensions +// + +// MFSampleExtension_ForwardedDecodeUnits {424C754C-97C8-48d6-8777-FC41F7B60879} +// Type: IUnknown +// This is an object of type IMFCollection containing IMFSample objects +// which contain NALU/SEI forwarded by a decoder. +// Contains all custom NALU/SEI since previous frame with emulation prevention bytes removed. +// see: MF_MT_FORWARD_CUSTOM_NALU, MF_MT_FORWARD_CUSTOM_SEI +DEFINE_GUID(MFSampleExtension_ForwardedDecodeUnits, +0x424c754c, 0x97c8, 0x48d6, 0x87, 0x77, 0xfc, 0x41, 0xf7, 0xb6, 0x8, 0x79); + +// MFSampleExtension_TargetGlobalLuminance {3F60EF36-31EF-4daf-8360-940397E41EF3} +// Type: UINT32 +// Value in Nits that specifies the targeted global backlight luminance for +// the associated video frame. +DEFINE_GUID(MFSampleExtension_TargetGlobalLuminance, +0x3f60ef36, 0x31ef, 0x4daf, 0x83, 0x60, 0x94, 0x3, 0x97, 0xe4, 0x1e, 0xf3); + +typedef enum _MF_CUSTOM_DECODE_UNIT_TYPE +{ + MF_DECODE_UNIT_NAL = 0, + MF_DECODE_UNIT_SEI = 1 +} MF_CUSTOM_DECODE_UNIT_TYPE; + +// MFSampleExtension_ForwardedDecodeUnitType {089E57C7-47D3-4a26-BF9C-4B64FAFB5D1E} +// Type: UINT32 (oneof MF_CUSTOM_DECODE_UNIT_TYPE) +// Attached to IMFSample objects in MFSampleExtension_ForwardedDecodeUnits, specifies +// what type of unit is attached: SEI or NAL +DEFINE_GUID(MFSampleExtension_ForwardedDecodeUnitType, +0x89e57c7, 0x47d3, 0x4a26, 0xbf, 0x9c, 0x4b, 0x64, 0xfa, 0xfb, 0x5d, 0x1e); + +// MF_MT_FORWARD_CUSTOM_NALU {ED336EFD-244F-428d-9153-28F399458890} +// Type: UINT32 +// Specifies the NAL unit type to forward on output samples of the decoder. +// If the decoder parses the specified NALU then it will not forwarded. +// See: MFSampleExtension_ForwardedDecodeUnits +DEFINE_GUID(MF_MT_FORWARD_CUSTOM_NALU, +0xed336efd, 0x244f, 0x428d, 0x91, 0x53, 0x28, 0xf3, 0x99, 0x45, 0x88, 0x90); + +// MF_MT_FORWARD_CUSTOM_SEI {E27362F1-B136-41d1-9594-3A7E4FEBF2D1} +// Type: UINT32 +// Specifies the SEI type to forward on output samples of the decoder +// If the decoder parses the specified SEI then it will not be forwarded. +// See: MFSampleExtension_ForwardedDecodeUnits +DEFINE_GUID(MF_MT_FORWARD_CUSTOM_SEI, +0xe27362f1, 0xb136, 0x41d1, 0x95, 0x94, 0x3a, 0x7e, 0x4f, 0xeb, 0xf2, 0xd1); + +// MF_MT_VIDEO_RENDERER_EXTENSION_PROFILE {8437D4B9-D448-4fcd-9B6B-839BF96C7798} +// Type: LPCWSTR +// Contains a string that matches an entry in a MediaRendererEffect Manifest's +// VideoRendererExtensionProfiles list to select which effect to load +DEFINE_GUID(MF_MT_VIDEO_RENDERER_EXTENSION_PROFILE, +0x8437d4b9, 0xd448, 0x4fcd, 0x9b, 0x6b, 0x83, 0x9b, 0xf9, 0x6c, 0x77, 0x98); + +#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS2) + +#if (NTDDI_VERSION >= NTDDI_WIN10_RS4) + +// MF_DECODER_FWD_CUSTOM_SEI_DECODE_ORDER {f13bbe3c-36d4-410a-b985-7a951a1e6294} +// Type: UINT32 +// Specifies that the SEI unit type to forward on output samples of the decoder +// shall be sent out in decode order (i.e. ahead of time) +// This is required for downstream apps to process the SEI in advance of receiving +// the frame it is meant to be attached to +DEFINE_GUID(MF_DECODER_FWD_CUSTOM_SEI_DECODE_ORDER, 0xf13bbe3c, 0x36d4, 0x410a, 0xb9, 0x85, 0x7a, 0x95, 0x1a, 0x1e, 0x62, 0x94); + +#endif /* (NTDDI_VERSION >= NTDDI_WIN10_RS4) */ + +// +// AUDIO data +// + +// {37e48bf5-645e-4c5b-89de-ada9e29b696a} MF_MT_AUDIO_NUM_CHANNELS {UINT32} +DEFINE_GUID(MF_MT_AUDIO_NUM_CHANNELS, +0x37e48bf5, 0x645e, 0x4c5b, 0x89, 0xde, 0xad, 0xa9, 0xe2, 0x9b, 0x69, 0x6a); + +// {5faeeae7-0290-4c31-9e8a-c534f68d9dba} MF_MT_AUDIO_SAMPLES_PER_SECOND {UINT32} +DEFINE_GUID(MF_MT_AUDIO_SAMPLES_PER_SECOND, +0x5faeeae7, 0x0290, 0x4c31, 0x9e, 0x8a, 0xc5, 0x34, 0xf6, 0x8d, 0x9d, 0xba); + +// {fb3b724a-cfb5-4319-aefe-6e42b2406132} MF_MT_AUDIO_FLOAT_SAMPLES_PER_SECOND {double} +DEFINE_GUID(MF_MT_AUDIO_FLOAT_SAMPLES_PER_SECOND, +0xfb3b724a, 0xcfb5, 0x4319, 0xae, 0xfe, 0x6e, 0x42, 0xb2, 0x40, 0x61, 0x32); + +// {1aab75c8-cfef-451c-ab95-ac034b8e1731} MF_MT_AUDIO_AVG_BYTES_PER_SECOND {UINT32} +DEFINE_GUID(MF_MT_AUDIO_AVG_BYTES_PER_SECOND, +0x1aab75c8, 0xcfef, 0x451c, 0xab, 0x95, 0xac, 0x03, 0x4b, 0x8e, 0x17, 0x31); + +// {322de230-9eeb-43bd-ab7a-ff412251541d} MF_MT_AUDIO_BLOCK_ALIGNMENT {UINT32} +DEFINE_GUID(MF_MT_AUDIO_BLOCK_ALIGNMENT, +0x322de230, 0x9eeb, 0x43bd, 0xab, 0x7a, 0xff, 0x41, 0x22, 0x51, 0x54, 0x1d); + +// {f2deb57f-40fa-4764-aa33-ed4f2d1ff669} MF_MT_AUDIO_BITS_PER_SAMPLE {UINT32} +DEFINE_GUID(MF_MT_AUDIO_BITS_PER_SAMPLE, +0xf2deb57f, 0x40fa, 0x4764, 0xaa, 0x33, 0xed, 0x4f, 0x2d, 0x1f, 0xf6, 0x69); + +// {d9bf8d6a-9530-4b7c-9ddf-ff6fd58bbd06} MF_MT_AUDIO_VALID_BITS_PER_SAMPLE {UINT32} +DEFINE_GUID(MF_MT_AUDIO_VALID_BITS_PER_SAMPLE, +0xd9bf8d6a, 0x9530, 0x4b7c, 0x9d, 0xdf, 0xff, 0x6f, 0xd5, 0x8b, 0xbd, 0x06); + +// {aab15aac-e13a-4995-9222-501ea15c6877} MF_MT_AUDIO_SAMPLES_PER_BLOCK {UINT32} +DEFINE_GUID(MF_MT_AUDIO_SAMPLES_PER_BLOCK, +0xaab15aac, 0xe13a, 0x4995, 0x92, 0x22, 0x50, 0x1e, 0xa1, 0x5c, 0x68, 0x77); + +// {55fb5765-644a-4caf-8479-938983bb1588}` MF_MT_AUDIO_CHANNEL_MASK {UINT32} +DEFINE_GUID(MF_MT_AUDIO_CHANNEL_MASK, +0x55fb5765, 0x644a, 0x4caf, 0x84, 0x79, 0x93, 0x89, 0x83, 0xbb, 0x15, 0x88); + +// +// MF_MT_AUDIO_FOLDDOWN_MATRIX stores folddown structure from multichannel to stereo +// +typedef struct _MFFOLDDOWN_MATRIX +{ + UINT32 cbSize; + UINT32 cSrcChannels; // number of source channels + UINT32 cDstChannels; // number of destination channels + UINT32 dwChannelMask; // mask + LONG Coeff[64]; +} MFFOLDDOWN_MATRIX; + +// {9d62927c-36be-4cf2-b5c4-a3926e3e8711}` MF_MT_AUDIO_FOLDDOWN_MATRIX {BLOB, MFFOLDDOWN_MATRIX} +DEFINE_GUID(MF_MT_AUDIO_FOLDDOWN_MATRIX, +0x9d62927c, 0x36be, 0x4cf2, 0xb5, 0xc4, 0xa3, 0x92, 0x6e, 0x3e, 0x87, 0x11); + +// {0x9d62927d-36be-4cf2-b5c4-a3926e3e8711}` MF_MT_AUDIO_WMADRC_PEAKREF {UINT32} +DEFINE_GUID(MF_MT_AUDIO_WMADRC_PEAKREF, +0x9d62927d, 0x36be, 0x4cf2, 0xb5, 0xc4, 0xa3, 0x92, 0x6e, 0x3e, 0x87, 0x11); + +// {0x9d62927e-36be-4cf2-b5c4-a3926e3e8711}` MF_MT_AUDIO_WMADRC_PEAKTARGET {UINT32} +DEFINE_GUID(MF_MT_AUDIO_WMADRC_PEAKTARGET, +0x9d62927e, 0x36be, 0x4cf2, 0xb5, 0xc4, 0xa3, 0x92, 0x6e, 0x3e, 0x87, 0x11); + + +// {0x9d62927f-36be-4cf2-b5c4-a3926e3e8711}` MF_MT_AUDIO_WMADRC_AVGREF {UINT32} +DEFINE_GUID(MF_MT_AUDIO_WMADRC_AVGREF, +0x9d62927f, 0x36be, 0x4cf2, 0xb5, 0xc4, 0xa3, 0x92, 0x6e, 0x3e, 0x87, 0x11); + +// {0x9d629280-36be-4cf2-b5c4-a3926e3e8711}` MF_MT_AUDIO_WMADRC_AVGTARGET {UINT32} +DEFINE_GUID(MF_MT_AUDIO_WMADRC_AVGTARGET, +0x9d629280, 0x36be, 0x4cf2, 0xb5, 0xc4, 0xa3, 0x92, 0x6e, 0x3e, 0x87, 0x11); + +// +// MF_MT_AUDIO_PREFER_WAVEFORMATEX tells the converter to prefer a plain WAVEFORMATEX rather than +// a WAVEFORMATEXTENSIBLE when converting to a legacy type. It is set by the WAVEFORMATEX->IMFMediaType +// conversion routines when the original format block is a non-extensible WAVEFORMATEX. +// +// This preference can be overridden and does not guarantee that the type can be correctly expressed +// by a non-extensible type. +// +// {a901aaba-e037-458a-bdf6-545be2074042} MF_MT_AUDIO_PREFER_WAVEFORMATEX {UINT32 (BOOL)} +DEFINE_GUID(MF_MT_AUDIO_PREFER_WAVEFORMATEX, +0xa901aaba, 0xe037, 0x458a, 0xbd, 0xf6, 0x54, 0x5b, 0xe2, 0x07, 0x40, 0x42); + +#if (WINVER >= _WIN32_WINNT_WIN7) +// +// AUDIO - AAC extra data +// + +// {BFBABE79-7434-4d1c-94F0-72A3B9E17188} MF_MT_AAC_PAYLOAD_TYPE {UINT32} +DEFINE_GUID(MF_MT_AAC_PAYLOAD_TYPE, +0xbfbabe79, 0x7434, 0x4d1c, 0x94, 0xf0, 0x72, 0xa3, 0xb9, 0xe1, 0x71, 0x88); + +// {7632F0E6-9538-4d61-ACDA-EA29C8C14456} MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION {UINT32} +DEFINE_GUID(MF_MT_AAC_AUDIO_PROFILE_LEVEL_INDICATION, +0x7632f0e6, 0x9538, 0x4d61, 0xac, 0xda, 0xea, 0x29, 0xc8, 0xc1, 0x44, 0x56); + +#endif // (WINVER >= _WIN32_WINNT_WIN7) + +#if (WINVER >= _WIN32_WINNT_WIN10) +// +// AUDIO - FLAC extra data +// + +// {8B81ADAE-4B5A-4D40-8022-F38D09CA3C5C} MF_MT_AUDIO_FLAC_MAX_BLOCK_SIZE {UINT32} +DEFINE_GUID(MF_MT_AUDIO_FLAC_MAX_BLOCK_SIZE, + 0x8b81adae, 0x4b5a, 0x4d40, 0x80, 0x22, 0xf3, 0x8d, 0x9, 0xca, 0x3c, 0x5c); + +#endif // (WINVER >= _WIN32_WINNT_WIN10) + + +#if (NTDDI_VERSION >= NTDDI_WIN10_RS2) +// +// AUDIO - Spatial Audio Sample extra data +// + +// {DCFBA24A-2609-4240-A721-3FAEA76A4DF9} MF_MT_SPATIAL_AUDIO_MAX_DYNAMIC_OBJECTS {UINT32} +DEFINE_GUID( MF_MT_SPATIAL_AUDIO_MAX_DYNAMIC_OBJECTS, + 0xdcfba24a, 0x2609, 0x4240, 0xa7, 0x21, 0x3f, 0xae, 0xa7, 0x6a, 0x4d, 0xf9 ); + +// {2AB71BC0-6223-4BA7-AD64-7B94B47AE792} MF_MT_SPATIAL_AUDIO_OBJECT_METADATA_FORMAT_ID {GUID} +DEFINE_GUID( MF_MT_SPATIAL_AUDIO_OBJECT_METADATA_FORMAT_ID, + 0x2ab71bc0, 0x6223, 0x4ba7, 0xad, 0x64, 0x7b, 0x94, 0xb4, 0x7a, 0xe7, 0x92 ); + +// {094BA8BE-D723-489F-92FA-766777B34726} MF_MT_SPATIAL_AUDIO_OBJECT_METADATA_LENGTH {UINT32} +DEFINE_GUID( MF_MT_SPATIAL_AUDIO_OBJECT_METADATA_LENGTH, + 0x94ba8be, 0xd723, 0x489f, 0x92, 0xfa, 0x76, 0x67, 0x77, 0xb3, 0x47, 0x26 ); + +// {11AA80B4-E0DA-47C6-8060-96C1259AE50D} MF_MT_SPATIAL_AUDIO_MAX_METADATA_ITEMS {UINT32} +DEFINE_GUID( MF_MT_SPATIAL_AUDIO_MAX_METADATA_ITEMS, + 0x11aa80b4, 0xe0da, 0x47c6, 0x80, 0x60, 0x96, 0xc1, 0x25, 0x9a, 0xe5, 0xd ); + +// {83E96EC9-1184-417E-8254-9F269158FC06} MF_MT_SPATIAL_AUDIO_MIN_METADATA_ITEM_OFFSET_SPACING {UINT32} +DEFINE_GUID( MF_MT_SPATIAL_AUDIO_MIN_METADATA_ITEM_OFFSET_SPACING, + 0x83e96ec9, 0x1184, 0x417e, 0x82, 0x54, 0x9f, 0x26, 0x91, 0x58, 0xfc, 0x6 ); + +// {6842F6E7-D43E-4EBB-9C9C-C96F41784863} MF_MT_SPATIAL_AUDIO_DATA_PRESENT {UINT32 (BOOL)} +DEFINE_GUID( MF_MT_SPATIAL_AUDIO_DATA_PRESENT, + 0x6842f6e7, 0xd43e, 0x4ebb, 0x9c, 0x9c, 0xc9, 0x6f, 0x41, 0x78, 0x48, 0x63 ); + +#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS2) + + +// +// VIDEO core data +// + +// {1652c33d-d6b2-4012-b834-72030849a37d} MF_MT_FRAME_SIZE {UINT64 (HI32(Width),LO32(Height))} +DEFINE_GUID(MF_MT_FRAME_SIZE, +0x1652c33d, 0xd6b2, 0x4012, 0xb8, 0x34, 0x72, 0x03, 0x08, 0x49, 0xa3, 0x7d); + +// {c459a2e8-3d2c-4e44-b132-fee5156c7bb0} MF_MT_FRAME_RATE {UINT64 (HI32(Numerator),LO32(Denominator))} +DEFINE_GUID(MF_MT_FRAME_RATE, +0xc459a2e8, 0x3d2c, 0x4e44, 0xb1, 0x32, 0xfe, 0xe5, 0x15, 0x6c, 0x7b, 0xb0); + +// {c6376a1e-8d0a-4027-be45-6d9a0ad39bb6} MF_MT_PIXEL_ASPECT_RATIO {UINT64 (HI32(Numerator),LO32(Denominator))} +DEFINE_GUID(MF_MT_PIXEL_ASPECT_RATIO, +0xc6376a1e, 0x8d0a, 0x4027, 0xbe, 0x45, 0x6d, 0x9a, 0x0a, 0xd3, 0x9b, 0xb6); + +// {8772f323-355a-4cc7-bb78-6d61a048ae82} MF_MT_DRM_FLAGS {UINT32 (anyof MFVideoDRMFlags)} +DEFINE_GUID(MF_MT_DRM_FLAGS, +0x8772f323, 0x355a, 0x4cc7, 0xbb, 0x78, 0x6d, 0x61, 0xa0, 0x48, 0xae, 0x82); + +#if (WINVER >= _WIN32_WINNT_WIN8) + +// {24974215-1B7B-41e4-8625-AC469F2DEDAA} MF_MT_TIMESTAMP_CAN_BE_DTS {UINT32 (BOOL)} +DEFINE_GUID(MF_MT_TIMESTAMP_CAN_BE_DTS, +0x24974215, 0x1b7b, 0x41e4, 0x86, 0x25, 0xac, 0x46, 0x9f, 0x2d, 0xed, 0xaa); + +#endif // (WINVER >= _WIN32_WINNT_WIN8) + +typedef enum _MFVideoDRMFlags { + MFVideoDRMFlag_None = 0, + MFVideoDRMFlag_AnalogProtected = 1, + MFVideoDRMFlag_DigitallyProtected = 2, +} MFVideoDRMFlags; + + +// {4d0e73e5-80ea-4354-a9d0-1176ceb028ea} MF_MT_PAD_CONTROL_FLAGS {UINT32 (oneof MFVideoPadFlags)} +DEFINE_GUID(MF_MT_PAD_CONTROL_FLAGS, +0x4d0e73e5, 0x80ea, 0x4354, 0xa9, 0xd0, 0x11, 0x76, 0xce, 0xb0, 0x28, 0xea); + +typedef enum _MFVideoPadFlags { + MFVideoPadFlag_PAD_TO_None = 0, + MFVideoPadFlag_PAD_TO_4x3 = 1, + MFVideoPadFlag_PAD_TO_16x9 = 2 +} MFVideoPadFlags; + +// {68aca3cc-22d0-44e6-85f8-28167197fa38} MF_MT_SOURCE_CONTENT_HINT {UINT32 (oneof MFVideoSrcContentHintFlags)} +DEFINE_GUID(MF_MT_SOURCE_CONTENT_HINT, +0x68aca3cc, 0x22d0, 0x44e6, 0x85, 0xf8, 0x28, 0x16, 0x71, 0x97, 0xfa, 0x38); + +typedef enum _MFVideoSrcContentHintFlags { + MFVideoSrcContentHintFlag_None = 0, + MFVideoSrcContentHintFlag_16x9 = 1, + MFVideoSrcContentHintFlag_235_1 = 2 +} MFVideoSrcContentHintFlags; + +// {65df2370-c773-4c33-aa64-843e068efb0c} MF_MT_CHROMA_SITING {UINT32 (anyof MFVideoChromaSubsampling)} +DEFINE_GUID(MF_MT_VIDEO_CHROMA_SITING, +0x65df2370, 0xc773, 0x4c33, 0xaa, 0x64, 0x84, 0x3e, 0x06, 0x8e, 0xfb, 0x0c); + +// {e2724bb8-e676-4806-b4b2-a8d6efb44ccd} MF_MT_INTERLACE_MODE {UINT32 (oneof MFVideoInterlaceMode)} +DEFINE_GUID(MF_MT_INTERLACE_MODE, +0xe2724bb8, 0xe676, 0x4806, 0xb4, 0xb2, 0xa8, 0xd6, 0xef, 0xb4, 0x4c, 0xcd); + +// {5fb0fce9-be5c-4935-a811-ec838f8eed93} MF_MT_TRANSFER_FUNCTION {UINT32 (oneof MFVideoTransferFunction)} +DEFINE_GUID(MF_MT_TRANSFER_FUNCTION, +0x5fb0fce9, 0xbe5c, 0x4935, 0xa8, 0x11, 0xec, 0x83, 0x8f, 0x8e, 0xed, 0x93); + +// {dbfbe4d7-0740-4ee0-8192-850ab0e21935} MF_MT_VIDEO_PRIMARIES {UINT32 (oneof MFVideoPrimaries)} +DEFINE_GUID(MF_MT_VIDEO_PRIMARIES, +0xdbfbe4d7, 0x0740, 0x4ee0, 0x81, 0x92, 0x85, 0x0a, 0xb0, 0xe2, 0x19, 0x35); + +// TODO: switch to RS define once it exists (see: 5312604) +#if (WINVER >= _WIN32_WINNT_WIN10) +// +// MF_MT_MAX_LUMINANCE_LEVEL specifies the maximum luminance level of the content in Nits. +// Has the same semantics as MaxCLL as defined in CEA-861.3 +// +// {50253128-C110-4de4-98AE-46A324FAE6DA} MF_MT_MAX_LUMINANCE_LEVEL {UINT32} +DEFINE_GUID(MF_MT_MAX_LUMINANCE_LEVEL, +0x50253128, 0xc110, 0x4de4, 0x98, 0xae, 0x46, 0xa3, 0x24, 0xfa, 0xe6, 0xda); + +// +// MF_MT_MAX_FRAME_AVERAGE_LUMINANCE_LEVEL specifies the maximum average per-frame +// luminance level of the content in Nits. +// Has the same semantics as MaxFALL as defined in CEA-861.3 +// +// {58D4BF57-6F52-4733-A195-A9E29ECF9E27} MF_MT_MAX_FRAME_AVERAGE_LUMINANCE_LEVEL {UINT32} +DEFINE_GUID(MF_MT_MAX_FRAME_AVERAGE_LUMINANCE_LEVEL, +0x58d4bf57, 0x6f52, 0x4733, 0xa1, 0x95, 0xa9, 0xe2, 0x9e, 0xcf, 0x9e, 0x27); + +// +// MF_MT_MAX_MASTERING_LUMINANCE specifies the maximum luminance of the display +// the content was authored on in Nits. +// Has the same semantics as max_display_mastering_luminance as defined in ST.2086 +// +// {D6C6B997-272F-4ca1-8D00-8042111A0FF6} MF_MT_MAX_MASTERING_LUMINANCE {UINT32} +DEFINE_GUID(MF_MT_MAX_MASTERING_LUMINANCE, +0xd6c6b997, 0x272f, 0x4ca1, 0x8d, 0x0, 0x80, 0x42, 0x11, 0x1a, 0xf, 0xf6); + +// +// MF_MT_MIN_MASTERING_LUMINANCE specifies the maximum luminance of the display +// the content was authored on in 0.0001 Nits. +// Has the same semantics as min_display_mastering_luminance as defined in ST.2086 +// +// {839A4460-4E7E-4b4f-AE79-CC08905C7B27} MF_MT_MIN_MASTERING_LUMINANCE {UINT32} +DEFINE_GUID(MF_MT_MIN_MASTERING_LUMINANCE, +0x839a4460, 0x4e7e, 0x4b4f, 0xae, 0x79, 0xcc, 0x8, 0x90, 0x5c, 0x7b, 0x27); + +// +// MF_MT_DECODER_USE_MAX_RESOLUTION hints the decoder should allocate worst +// case supported resolution whenever possible +// {4c547c24-af9a-4f38-96ad-978773cf53e7} MF_MT_DECODER_USE_MAX_RESOLUTION {UINT32 (BOOL)} +DEFINE_GUID(MF_MT_DECODER_USE_MAX_RESOLUTION, +0x4c547c24, 0xaf9a, 0x4f38, 0x96, 0xad, 0x97, 0x87, 0x73, 0xcf, 0x53, 0xe7); + +// +// MF_MT_DECODER_MAX_DPB_COUNT is a value that hints to the decoder that the current +// decoding session will never require more than the specified number of decode surfaces +// {67BE144C-88B7-4CA9-9628-C808D5262217} MF_MT_DECODER_MAX_DPB_COUNT {UINT32} +DEFINE_GUID(MF_MT_DECODER_MAX_DPB_COUNT, +0x67be144c, 0x88b7, 0x4ca9, 0x96, 0x28, 0xc8, 0x8, 0xd5, 0x26, 0x22, 0x17); + +#endif // (WINVER > _WIN32_WINNT_WIN10) + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +// {47537213-8cfb-4722-aa34-fbc9e24d77b8} MF_MT_CUSTOM_VIDEO_PRIMARIES {BLOB (MT_CUSTOM_VIDEO_PRIMARIES)} +DEFINE_GUID(MF_MT_CUSTOM_VIDEO_PRIMARIES, +0x47537213, 0x8cfb, 0x4722, 0xaa, 0x34, 0xfb, 0xc9, 0xe2, 0x4d, 0x77, 0xb8); + +typedef struct _MT_CUSTOM_VIDEO_PRIMARIES { + float fRx; + float fRy; + float fGx; + float fGy; + float fBx; + float fBy; + float fWx; + float fWy; +} MT_CUSTOM_VIDEO_PRIMARIES; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +// {3e23d450-2c75-4d25-a00e-b91670d12327} MF_MT_YUV_MATRIX {UINT32 (oneof MFVideoTransferMatrix)} +DEFINE_GUID(MF_MT_YUV_MATRIX, +0x3e23d450, 0x2c75, 0x4d25, 0xa0, 0x0e, 0xb9, 0x16, 0x70, 0xd1, 0x23, 0x27); + +// {53a0529c-890b-4216-8bf9-599367ad6d20} MF_MT_VIDEO_LIGHTING {UINT32 (oneof MFVideoLighting)} +DEFINE_GUID(MF_MT_VIDEO_LIGHTING, +0x53a0529c, 0x890b, 0x4216, 0x8b, 0xf9, 0x59, 0x93, 0x67, 0xad, 0x6d, 0x20); + +// {c21b8ee5-b956-4071-8daf-325edf5cab11} MF_MT_VIDEO_NOMINAL_RANGE {UINT32 (oneof MFNominalRange)} +DEFINE_GUID(MF_MT_VIDEO_NOMINAL_RANGE, +0xc21b8ee5, 0xb956, 0x4071, 0x8d, 0xaf, 0x32, 0x5e, 0xdf, 0x5c, 0xab, 0x11); + +// {66758743-7e5f-400d-980a-aa8596c85696} MF_MT_GEOMETRIC_APERTURE {BLOB (MFVideoArea)} +DEFINE_GUID(MF_MT_GEOMETRIC_APERTURE, +0x66758743, 0x7e5f, 0x400d, 0x98, 0x0a, 0xaa, 0x85, 0x96, 0xc8, 0x56, 0x96); + +// {d7388766-18fe-48c6-a177-ee894867c8c4} MF_MT_MINIMUM_DISPLAY_APERTURE {BLOB (MFVideoArea)} +DEFINE_GUID(MF_MT_MINIMUM_DISPLAY_APERTURE, +0xd7388766, 0x18fe, 0x48c6, 0xa1, 0x77, 0xee, 0x89, 0x48, 0x67, 0xc8, 0xc4); + +// {79614dde-9187-48fb-b8c7-4d52689de649} MF_MT_PAN_SCAN_APERTURE {BLOB (MFVideoArea)} +DEFINE_GUID(MF_MT_PAN_SCAN_APERTURE, +0x79614dde, 0x9187, 0x48fb, 0xb8, 0xc7, 0x4d, 0x52, 0x68, 0x9d, 0xe6, 0x49); + +// {4b7f6bc3-8b13-40b2-a993-abf630b8204e} MF_MT_PAN_SCAN_ENABLED {UINT32 (BOOL)} +DEFINE_GUID(MF_MT_PAN_SCAN_ENABLED, +0x4b7f6bc3, 0x8b13, 0x40b2, 0xa9, 0x93, 0xab, 0xf6, 0x30, 0xb8, 0x20, 0x4e); + +// {20332624-fb0d-4d9e-bd0d-cbf6786c102e} MF_MT_AVG_BITRATE {UINT32} +DEFINE_GUID(MF_MT_AVG_BITRATE, +0x20332624, 0xfb0d, 0x4d9e, 0xbd, 0x0d, 0xcb, 0xf6, 0x78, 0x6c, 0x10, 0x2e); + +// {799cabd6-3508-4db4-a3c7-569cd533deb1} MF_MT_AVG_BIT_ERROR_RATE {UINT32} +DEFINE_GUID(MF_MT_AVG_BIT_ERROR_RATE, +0x799cabd6, 0x3508, 0x4db4, 0xa3, 0xc7, 0x56, 0x9c, 0xd5, 0x33, 0xde, 0xb1); + +// {c16eb52b-73a1-476f-8d62-839d6a020652} MF_MT_MAX_KEYFRAME_SPACING {UINT32} +DEFINE_GUID(MF_MT_MAX_KEYFRAME_SPACING, +0xc16eb52b, 0x73a1, 0x476f, 0x8d, 0x62, 0x83, 0x9d, 0x6a, 0x02, 0x06, 0x52); + +// {b6bc765f-4c3b-40a4-bd51-2535b66fe09d} MF_MT_USER_DATA {BLOB} +DEFINE_GUID(MF_MT_USER_DATA, +0xb6bc765f, 0x4c3b, 0x40a4, 0xbd, 0x51, 0x25, 0x35, 0xb6, 0x6f, 0xe0, 0x9d); + +// {a505d3ac-f930-436e-8ede-93a509ce23b2} MF_MT_OUTPUT_BUFFER_NUM {UINT32} +DEFINE_GUID(MF_MT_OUTPUT_BUFFER_NUM, +0xa505d3ac, 0xf930, 0x436e, 0x8e, 0xde, 0x93, 0xa5, 0x09, 0xce, 0x23, 0xb2); + +// TODO: Fix when GovM has the right ifdef check +#if (WINVER >= _WIN32_WINNT_WIN10) +/// {0xbb12d222,0x2bdb,0x425e,0x91,0xec,0x23,0x08,0xe1,0x89,0xa5,0x8f} MF_MT_REALTIME_CONTENT UINT32 (0 or 1) +DEFINE_GUID(MF_MT_REALTIME_CONTENT, +0xbb12d222,0x2bdb,0x425e,0x91,0xec,0x23,0x08,0xe1,0x89,0xa5,0x8f); +#endif // (WINVER >= _WIN32_WINNT_WIN10 + +// +// VIDEO - uncompressed format data +// + +// {644b4e48-1e02-4516-b0eb-c01ca9d49ac6} MF_MT_DEFAULT_STRIDE {UINT32 (INT32)} // in bytes +DEFINE_GUID(MF_MT_DEFAULT_STRIDE, +0x644b4e48, 0x1e02, 0x4516, 0xb0, 0xeb, 0xc0, 0x1c, 0xa9, 0xd4, 0x9a, 0xc6); + +// {6d283f42-9846-4410-afd9-654d503b1a54} MF_MT_PALETTE {BLOB (array of MFPaletteEntry - usually 256)} +DEFINE_GUID(MF_MT_PALETTE, +0x6d283f42, 0x9846, 0x4410, 0xaf, 0xd9, 0x65, 0x4d, 0x50, 0x3b, 0x1a, 0x54); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +// +// the following is only used for legacy data that was stuck at the end of the format block when the type +// was converted from a VIDEOINFOHEADER or VIDEOINFOHEADER2 block in an AM_MEDIA_TYPE. +// + +// {73d1072d-1870-4174-a063-29ff4ff6c11e} +DEFINE_GUID(MF_MT_AM_FORMAT_TYPE, +0x73d1072d, 0x1870, 0x4174, 0xa0, 0x63, 0x29, 0xff, 0x4f, 0xf6, 0xc1, 0x1e); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +// +// VIDEO - Generic compressed video extra data +// + +// {ad76a80b-2d5c-4e0b-b375-64e520137036} MF_MT_VIDEO_PROFILE {UINT32} This is an alias of MF_MT_MPEG2_PROFILE +DEFINE_GUID(MF_MT_VIDEO_PROFILE, +0xad76a80b, 0x2d5c, 0x4e0b, 0xb3, 0x75, 0x64, 0xe5, 0x20, 0x13, 0x70, 0x36); + +// {96f66574-11c5-4015-8666-bff516436da7} MF_MT_VIDEO_LEVEL {UINT32} This is an alias of MF_MT_MPEG2_LEVEL +DEFINE_GUID(MF_MT_VIDEO_LEVEL, +0x96f66574, 0x11c5, 0x4015, 0x86, 0x66, 0xbf, 0xf5, 0x16, 0x43, 0x6d, 0xa7); + + +// +// VIDEO - MPEG1/2 extra data +// + +// {91f67885-4333-4280-97cd-bd5a6c03a06e} MF_MT_MPEG_START_TIME_CODE {UINT32} +DEFINE_GUID(MF_MT_MPEG_START_TIME_CODE, +0x91f67885, 0x4333, 0x4280, 0x97, 0xcd, 0xbd, 0x5a, 0x6c, 0x03, 0xa0, 0x6e); + +// {ad76a80b-2d5c-4e0b-b375-64e520137036} MF_MT_MPEG2_PROFILE {UINT32 (oneof AM_MPEG2Profile)} +DEFINE_GUID(MF_MT_MPEG2_PROFILE, +0xad76a80b, 0x2d5c, 0x4e0b, 0xb3, 0x75, 0x64, 0xe5, 0x20, 0x13, 0x70, 0x36); + +// {96f66574-11c5-4015-8666-bff516436da7} MF_MT_MPEG2_LEVEL {UINT32 (oneof AM_MPEG2Level)} +DEFINE_GUID(MF_MT_MPEG2_LEVEL, +0x96f66574, 0x11c5, 0x4015, 0x86, 0x66, 0xbf, 0xf5, 0x16, 0x43, 0x6d, 0xa7); + +// {31e3991d-f701-4b2f-b426-8ae3bda9e04b} MF_MT_MPEG2_FLAGS {UINT32 (anyof AMMPEG2_xxx flags)} +DEFINE_GUID(MF_MT_MPEG2_FLAGS, +0x31e3991d, 0xf701, 0x4b2f, 0xb4, 0x26, 0x8a, 0xe3, 0xbd, 0xa9, 0xe0, 0x4b); + +// {3c036de7-3ad0-4c9e-9216-ee6d6ac21cb3} MF_MT_MPEG_SEQUENCE_HEADER {BLOB} +DEFINE_GUID(MF_MT_MPEG_SEQUENCE_HEADER, +0x3c036de7, 0x3ad0, 0x4c9e, 0x92, 0x16, 0xee, 0x6d, 0x6a, 0xc2, 0x1c, 0xb3); + +// {A20AF9E8-928A-4B26-AAA9-F05C74CAC47C} MF_MT_MPEG2_STANDARD {UINT32 (0 for default MPEG2, 1 to use ATSC standard, 2 to use DVB standard, 3 to use ARIB standard)} +DEFINE_GUID(MF_MT_MPEG2_STANDARD, +0xa20af9e8, 0x928a, 0x4b26, 0xaa, 0xa9, 0xf0, 0x5c, 0x74, 0xca, 0xc4, 0x7c); + +// {5229BA10-E29D-4F80-A59C-DF4F180207D2} MF_MT_MPEG2_TIMECODE {UINT32 (0 for no timecode, 1 to append an 4 byte timecode to the front of each transport packet)} +DEFINE_GUID(MF_MT_MPEG2_TIMECODE, +0x5229ba10, 0xe29d, 0x4f80, 0xa5, 0x9c, 0xdf, 0x4f, 0x18, 0x2, 0x7, 0xd2); + +// {825D55E4-4F12-4197-9EB3-59B6E4710F06} MF_MT_MPEG2_CONTENT_PACKET {UINT32 (0 for no content packet, 1 to append a 14 byte Content Packet header according to the ARIB specification to the beginning a transport packet at 200-1000 ms intervals.)} +DEFINE_GUID(MF_MT_MPEG2_CONTENT_PACKET, +0x825d55e4, 0x4f12, 0x4197, 0x9e, 0xb3, 0x59, 0xb6, 0xe4, 0x71, 0xf, 0x6); + +// {91a49eb5-1d20-4b42-ace8-804269bf95ed} MF_MT_MPEG2_ONE_FRAME_PER_PACKET {UINT32 (BOOL) -- 0 for default behavior of splitting large video frames into multiple PES packets, 1 for always putting a full frame inside a PES packet, even if that requires setting the PES packet size to undefined (0)} +DEFINE_GUID(MF_MT_MPEG2_ONE_FRAME_PER_PACKET, +0x91a49eb5, 0x1d20, 0x4b42, 0xac, 0xe8, 0x80, 0x42, 0x69, 0xbf, 0x95, 0xed); + +// {168f1b4a-3e91-450f-aea7-e4baeadae5ba} MF_MT_MPEG2_HDCP {UINT32 (BOOL) -- 0 for default behavior of clear MPEG2 stream, 1 for adding the HDCP descriptor to the PMT +DEFINE_GUID(MF_MT_MPEG2_HDCP, +0x168f1b4a, 0x3e91, 0x450f, 0xae, 0xa7, 0xe4, 0xba, 0xea, 0xda, 0xe5, 0xba); + +// +// VIDEO - H264 extra data +// + +// {F5929986-4C45-4FBB-BB49-6CC534D05B9B} {UINT32, UVC 1.5 H.264 format descriptor: bMaxCodecConfigDelay} +DEFINE_GUID(MF_MT_H264_MAX_CODEC_CONFIG_DELAY, +0xf5929986, 0x4c45, 0x4fbb, 0xbb, 0x49, 0x6c, 0xc5, 0x34, 0xd0, 0x5b, 0x9b); + +// {C8BE1937-4D64-4549-8343-A8086C0BFDA5} {UINT32, UVC 1.5 H.264 format descriptor: bmSupportedSliceModes} +DEFINE_GUID(MF_MT_H264_SUPPORTED_SLICE_MODES, +0xc8be1937, 0x4d64, 0x4549, 0x83, 0x43, 0xa8, 0x8, 0x6c, 0xb, 0xfd, 0xa5); + +// {89A52C01-F282-48D2-B522-22E6AE633199} {UINT32, UVC 1.5 H.264 format descriptor: bmSupportedSyncFrameTypes} +DEFINE_GUID(MF_MT_H264_SUPPORTED_SYNC_FRAME_TYPES, +0x89a52c01, 0xf282, 0x48d2, 0xb5, 0x22, 0x22, 0xe6, 0xae, 0x63, 0x31, 0x99); + +// {E3854272-F715-4757-BA90-1B696C773457} {UINT32, UVC 1.5 H.264 format descriptor: bResolutionScaling} +DEFINE_GUID(MF_MT_H264_RESOLUTION_SCALING, +0xe3854272, 0xf715, 0x4757, 0xba, 0x90, 0x1b, 0x69, 0x6c, 0x77, 0x34, 0x57); + +// {9EA2D63D-53F0-4A34-B94E-9DE49A078CB3} {UINT32, UVC 1.5 H.264 format descriptor: bSimulcastSupport} +DEFINE_GUID(MF_MT_H264_SIMULCAST_SUPPORT, +0x9ea2d63d, 0x53f0, 0x4a34, 0xb9, 0x4e, 0x9d, 0xe4, 0x9a, 0x7, 0x8c, 0xb3); + +// {6A8AC47E-519C-4F18-9BB3-7EEAAEA5594D} {UINT32, UVC 1.5 H.264 format descriptor: bmSupportedRateControlModes} +DEFINE_GUID(MF_MT_H264_SUPPORTED_RATE_CONTROL_MODES, +0x6a8ac47e, 0x519c, 0x4f18, 0x9b, 0xb3, 0x7e, 0xea, 0xae, 0xa5, 0x59, 0x4d); + +// {45256D30-7215-4576-9336-B0F1BCD59BB2} {Blob of size 20 * sizeof(WORD), UVC 1.5 H.264 format descriptor: wMaxMBperSec*} +DEFINE_GUID(MF_MT_H264_MAX_MB_PER_SEC, +0x45256d30, 0x7215, 0x4576, 0x93, 0x36, 0xb0, 0xf1, 0xbc, 0xd5, 0x9b, 0xb2); + +// {60B1A998-DC01-40CE-9736-ABA845A2DBDC} {UINT32, UVC 1.5 H.264 frame descriptor: bmSupportedUsages} +DEFINE_GUID(MF_MT_H264_SUPPORTED_USAGES, +0x60b1a998, 0xdc01, 0x40ce, 0x97, 0x36, 0xab, 0xa8, 0x45, 0xa2, 0xdb, 0xdc); + +// {BB3BD508-490A-11E0-99E4-1316DFD72085} {UINT32, UVC 1.5 H.264 frame descriptor: bmCapabilities} +DEFINE_GUID(MF_MT_H264_CAPABILITIES, +0xbb3bd508, 0x490a, 0x11e0, 0x99, 0xe4, 0x13, 0x16, 0xdf, 0xd7, 0x20, 0x85); + +// {F8993ABE-D937-4A8F-BBCA-6966FE9E1152} {UINT32, UVC 1.5 H.264 frame descriptor: bmSVCCapabilities} +DEFINE_GUID(MF_MT_H264_SVC_CAPABILITIES, +0xf8993abe, 0xd937, 0x4a8f, 0xbb, 0xca, 0x69, 0x66, 0xfe, 0x9e, 0x11, 0x52); + +// {359CE3A5-AF00-49CA-A2F4-2AC94CA82B61} {UINT32, UVC 1.5 H.264 Probe/Commit Control: bUsage} +DEFINE_GUID(MF_MT_H264_USAGE, +0x359ce3a5, 0xaf00, 0x49ca, 0xa2, 0xf4, 0x2a, 0xc9, 0x4c, 0xa8, 0x2b, 0x61); + +//{705177D8-45CB-11E0-AC7D-B91CE0D72085} {UINT32, UVC 1.5 H.264 Probe/Commit Control: bmRateControlModes} +DEFINE_GUID(MF_MT_H264_RATE_CONTROL_MODES, +0x705177d8, 0x45cb, 0x11e0, 0xac, 0x7d, 0xb9, 0x1c, 0xe0, 0xd7, 0x20, 0x85); + +//{85E299B2-90E3-4FE8-B2F5-C067E0BFE57A} {UINT64, UVC 1.5 H.264 Probe/Commit Control: bmLayoutPerStream} +DEFINE_GUID(MF_MT_H264_LAYOUT_PER_STREAM, +0x85e299b2, 0x90e3, 0x4fe8, 0xb2, 0xf5, 0xc0, 0x67, 0xe0, 0xbf, 0xe5, 0x7a); + +// According to Mpeg4 spec, SPS and PPS of H.264/HEVC codec could appear in sample data. +// description box. Mpeg4 sink filters out the SPS and PPS NALU and do not support in band SPS and PPS NALU. +// This attribute enables support for in band SPS and PPS to appear in the elementary stream. +// HEVC will have in-band parameter set by default with MP4 recording for broad support. H.264 will have out - of - band parameter set by default for historical reason. +// {75DA5090-910B-4A03-896C-7B898FEEA5AF} +DEFINE_GUID(MF_MT_IN_BAND_PARAMETER_SET, +0x75da5090, 0x910b, 0x4a03, 0x89, 0x6c, 0x7b, 0x89, 0x8f, 0xee, 0xa5, 0xaf); + +//{54F486DD-9327-4F6D-80AB-6F709EBB4CCE} {UINT32, FourCC of the track type in MPEG-4 used for binary streams} +DEFINE_GUID(MF_MT_MPEG4_TRACK_TYPE, + 0x54f486dd, 0x9327, 0x4f6d, 0x80, 0xab, 0x6f, 0x70, 0x9e, 0xbb, 0x4c, 0xce); + +// +// INTERLEAVED - DV extra data +// +// {84bd5d88-0fb8-4ac8-be4b-a8848bef98f3} MF_MT_DV_AAUX_SRC_PACK_0 {UINT32} +DEFINE_GUID(MF_MT_DV_AAUX_SRC_PACK_0, +0x84bd5d88, 0x0fb8, 0x4ac8, 0xbe, 0x4b, 0xa8, 0x84, 0x8b, 0xef, 0x98, 0xf3); + +// {f731004e-1dd1-4515-aabe-f0c06aa536ac} MF_MT_DV_AAUX_CTRL_PACK_0 {UINT32} +DEFINE_GUID(MF_MT_DV_AAUX_CTRL_PACK_0, +0xf731004e, 0x1dd1, 0x4515, 0xaa, 0xbe, 0xf0, 0xc0, 0x6a, 0xa5, 0x36, 0xac); + +// {720e6544-0225-4003-a651-0196563a958e} MF_MT_DV_AAUX_SRC_PACK_1 {UINT32} +DEFINE_GUID(MF_MT_DV_AAUX_SRC_PACK_1, +0x720e6544, 0x0225, 0x4003, 0xa6, 0x51, 0x01, 0x96, 0x56, 0x3a, 0x95, 0x8e); + +// {cd1f470d-1f04-4fe0-bfb9-d07ae0386ad8} MF_MT_DV_AAUX_CTRL_PACK_1 {UINT32} +DEFINE_GUID(MF_MT_DV_AAUX_CTRL_PACK_1, +0xcd1f470d, 0x1f04, 0x4fe0, 0xbf, 0xb9, 0xd0, 0x7a, 0xe0, 0x38, 0x6a, 0xd8); + +// {41402d9d-7b57-43c6-b129-2cb997f15009} MF_MT_DV_VAUX_SRC_PACK {UINT32} +DEFINE_GUID(MF_MT_DV_VAUX_SRC_PACK, +0x41402d9d, 0x7b57, 0x43c6, 0xb1, 0x29, 0x2c, 0xb9, 0x97, 0xf1, 0x50, 0x09); + +// {2f84e1c4-0da1-4788-938e-0dfbfbb34b48} MF_MT_DV_VAUX_CTRL_PACK {UINT32} +DEFINE_GUID(MF_MT_DV_VAUX_CTRL_PACK, +0x2f84e1c4, 0x0da1, 0x4788, 0x93, 0x8e, 0x0d, 0xfb, 0xfb, 0xb3, 0x4b, 0x48); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#if (WINVER >= _WIN32_WINNT_WIN7) + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +// +// ARBITRARY +// + +// +// MT_ARBITRARY_HEADER stores information about the format of an arbitrary media type +// +typedef struct _MT_ARBITRARY_HEADER +{ + GUID majortype; + GUID subtype; + BOOL bFixedSizeSamples; + BOOL bTemporalCompression; + ULONG lSampleSize; + GUID formattype; +} +MT_ARBITRARY_HEADER; + +// {9E6BD6F5-0109-4f95-84AC-9309153A19FC} MF_MT_ARBITRARY_HEADER {MT_ARBITRARY_HEADER} +DEFINE_GUID(MF_MT_ARBITRARY_HEADER, +0x9e6bd6f5, 0x109, 0x4f95, 0x84, 0xac, 0x93, 0x9, 0x15, 0x3a, 0x19, 0xfc ); + +// {5A75B249-0D7D-49a1-A1C3-E0D87F0CADE5} MF_MT_ARBITRARY_FORMAT {Blob} +DEFINE_GUID(MF_MT_ARBITRARY_FORMAT, +0x5a75b249, 0xd7d, 0x49a1, 0xa1, 0xc3, 0xe0, 0xd8, 0x7f, 0xc, 0xad, 0xe5); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +// +// IMAGE +// +// {ED062CF4-E34E-4922-BE99-934032133D7C} MF_MT_IMAGE_LOSS_TOLERANT {UINT32 (BOOL)} +DEFINE_GUID(MF_MT_IMAGE_LOSS_TOLERANT, +0xed062cf4, 0xe34e, 0x4922, 0xbe, 0x99, 0x93, 0x40, 0x32, 0x13, 0x3d, 0x7c); + + +// +// MPEG-4 Media Type Attributes +// +// {261E9D83-9529-4B8F-A111-8B9C950A81A9} MF_MT_MPEG4_SAMPLE_DESCRIPTION {BLOB} +DEFINE_GUID(MF_MT_MPEG4_SAMPLE_DESCRIPTION, +0x261e9d83, 0x9529, 0x4b8f, 0xa1, 0x11, 0x8b, 0x9c, 0x95, 0x0a, 0x81, 0xa9); + +// {9aa7e155-b64a-4c1d-a500-455d600b6560} MF_MT_MPEG4_CURRENT_SAMPLE_ENTRY {UINT32} +DEFINE_GUID(MF_MT_MPEG4_CURRENT_SAMPLE_ENTRY, +0x9aa7e155, 0xb64a, 0x4c1d, 0xa5, 0x00, 0x45, 0x5d, 0x60, 0x0b, 0x65, 0x60); + +#if (NTDDI_VERSION >= NTDDI_WIN10_RS4) +// +// Ambisonics Stream Attribute +// The value of this blob must be AMBISONICS_PARAMS structure defined in AudioClient.h +// +// {F715CF3E-A964-4C3F-94AE-9D6BA7264641} MF_SD_AMBISONICS_SAMPLE3D_DESCRIPTION {BLOB} +DEFINE_GUID(MF_SD_AMBISONICS_SAMPLE3D_DESCRIPTION, +0xf715cf3e, 0xa964, 0x4c3f, 0x94, 0xae, 0x9d, 0x6b, 0xa7, 0x26, 0x46, 0x41); + +#endif + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +// +// Save original format information for AVI and WAV files +// +// {d7be3fe0-2bc7-492d-b843-61a1919b70c3} MF_MT_ORIGINAL_4CC (UINT32) +DEFINE_GUID(MF_MT_ORIGINAL_4CC, +0xd7be3fe0, 0x2bc7, 0x492d, 0xb8, 0x43, 0x61, 0xa1, 0x91, 0x9b, 0x70, 0xc3); + +// {8cbbc843-9fd9-49c2-882f-a72586c408ad} MF_MT_ORIGINAL_WAVE_FORMAT_TAG (UINT32) +DEFINE_GUID(MF_MT_ORIGINAL_WAVE_FORMAT_TAG, +0x8cbbc843, 0x9fd9, 0x49c2, 0x88, 0x2f, 0xa7, 0x25, 0x86, 0xc4, 0x08, 0xad); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +// +// Video Capture Media Type Attributes +// + +// {D2E7558C-DC1F-403f-9A72-D28BB1EB3B5E} MF_MT_FRAME_RATE_RANGE_MIN {UINT64 (HI32(Numerator),LO32(Denominator))} +DEFINE_GUID(MF_MT_FRAME_RATE_RANGE_MIN, +0xd2e7558c, 0xdc1f, 0x403f, 0x9a, 0x72, 0xd2, 0x8b, 0xb1, 0xeb, 0x3b, 0x5e); + +// {E3371D41-B4CF-4a05-BD4E-20B88BB2C4D6} MF_MT_FRAME_RATE_RANGE_MAX {UINT64 (HI32(Numerator),LO32(Denominator))} +DEFINE_GUID(MF_MT_FRAME_RATE_RANGE_MAX, +0xe3371d41, 0xb4cf, 0x4a05, 0xbd, 0x4e, 0x20, 0xb8, 0x8b, 0xb2, 0xc4, 0xd6); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#endif // (WINVER >= _WIN32_WINNT_WIN7) + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +#if (WINVER >= _WIN32_WINNT_WIN8) +// {9C27891A-ED7A-40e1-88E8-B22727A024EE} MF_LOW_LATENCY {UINT32 (BOOL)} +// Same GUID as CODECAPI_AVLowLatencyMode +DEFINE_GUID(MF_LOW_LATENCY, +0x9c27891a, 0xed7a, 0x40e1, 0x88, 0xe8, 0xb2, 0x27, 0x27, 0xa0, 0x24, 0xee); + +// {E3F2E203-D445-4B8C-9211-AE390D3BA017} {UINT32} Maximum macroblocks per second that can be handled by MFT +DEFINE_GUID(MF_VIDEO_MAX_MB_PER_SEC, +0xe3f2e203, 0xd445, 0x4b8c, 0x92, 0x11, 0xae, 0x39, 0xd, 0x3b, 0xa0, 0x17); + +// {7086E16C-49C5-4201-882A-8538F38CF13A} {UINT32 (BOOL)} Enables(0, default)/disables(1) the DXVA decode status queries in decoders. When disabled decoder won't provide MFSampleExtension_FrameCorruption +DEFINE_GUID(MF_DISABLE_FRAME_CORRUPTION_INFO, + 0x7086e16c, 0x49c5, 0x4201, 0x88, 0x2a, 0x85, 0x38, 0xf3, 0x8c, 0xf1, 0x3a); + +#endif // (WINVER >= _WIN32_WINNT_WIN8) + +//////////////////////////////////////////////////////////////////////////////// +// Camera Extrinsics +//////////////////////////////////////////////////////////////////////////////// + +typedef struct _MF_FLOAT2 +{ + FLOAT x; + FLOAT y; +} MF_FLOAT2; + +typedef struct _MF_FLOAT3 +{ + FLOAT x; + FLOAT y; + FLOAT z; +} MF_FLOAT3; + +typedef struct _MF_QUATERNION +{ + FLOAT x; + FLOAT y; + FLOAT z; + FLOAT w; +} MF_QUATERNION; + +typedef struct _MFCameraExtrinsic_CalibratedTransform +{ + GUID CalibrationId; + MF_FLOAT3 Position; + MF_QUATERNION Orientation; +} MFCameraExtrinsic_CalibratedTransform; + +typedef struct _MFCameraExtrinsics +{ + UINT32 TransformCount; + MFCameraExtrinsic_CalibratedTransform CalibratedTransforms[1]; +} MFCameraExtrinsics; + +// +// MFStreamExtension_CameraExtrinsics {686196D0-13E2-41D9-9638-EF032C272A52} +// Value type: Blob (MFCameraExtrinsics) +// Stores camera extrinsics data on the stream's attribute store +// +DEFINE_GUID(MFStreamExtension_CameraExtrinsics, + 0x686196d0, 0x13e2, 0x41d9, 0x96, 0x38, 0xef, 0x3, 0x2c, 0x27, 0x2a, 0x52); + +// +// MFSampleExtension_CameraExtrinsics {6B761658-B7EC-4C3B-8225-8623CABEC31D} +// Value type: Blob (MFCameraExtrinsics) +// Stores camera extrinsics data on the sample's (a.k.a frame) attribute store +// +DEFINE_GUID(MFSampleExtension_CameraExtrinsics, + 0x6b761658, 0xb7ec, 0x4c3b, 0x82, 0x25, 0x86, 0x23, 0xca, 0xbe, 0xc3, 0x1d); + +//////////////////////////////////////////////////////////////////////////////// +// Camera Intrinsics +//////////////////////////////////////////////////////////////////////////////// + +typedef struct _MFCameraIntrinsic_PinholeCameraModel +{ + MF_FLOAT2 FocalLength; + MF_FLOAT2 PrincipalPoint; +} MFCameraIntrinsic_PinholeCameraModel; + +typedef struct _MFCameraIntrinsic_DistortionModel +{ + FLOAT Radial_k1; + FLOAT Radial_k2; + FLOAT Radial_k3; + FLOAT Tangential_p1; + FLOAT Tangential_p2; +} MFCameraIntrinsic_DistortionModel; + +typedef struct _MFPinholeCameraIntrinsic_IntrinsicModel +{ + UINT32 Width; + UINT32 Height; + MFCameraIntrinsic_PinholeCameraModel CameraModel; + MFCameraIntrinsic_DistortionModel DistortionModel; +} MFPinholeCameraIntrinsic_IntrinsicModel; + +typedef struct _MFPinholeCameraIntrinsics +{ + UINT32 IntrinsicModelCount; + MFPinholeCameraIntrinsic_IntrinsicModel IntrinsicModels[1]; +} MFPinholeCameraIntrinsics; + +// MFStreamExtension_PinholeCameraIntrinsics {DBAC0455-0EC8-4AEF-9C32-7A3EE3456F53} +// Value type: Blob (MFPinholeCameraIntrinsics) +// Stores camera intrinsics data on stream attribute store +DEFINE_GUID(MFStreamExtension_PinholeCameraIntrinsics, + 0xdbac0455, 0xec8, 0x4aef, 0x9c, 0x32, 0x7a, 0x3e, 0xe3, 0x45, 0x6f, 0x53); + +// MFSampleExtension_PinholeCameraIntrinsics {4EE3B6C5-6A15-4E72-9761-70C1DB8B9FE3} +// Value type: Blob (MFPinholeCameraIntrinsics) +// Stores camera intrinsics data on the sample's (a.k.a frame) attribute store +DEFINE_GUID(MFSampleExtension_PinholeCameraIntrinsics, + 0x4ee3b6c5, 0x6a15, 0x4e72, 0x97, 0x61, 0x70, 0xc1, 0xdb, 0x8b, 0x9f, 0xe3); + + +//////////////////////////////////////////////////////////////////////////////// +/////////////////////////////// Media Type GUIDs ////////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + + +// +// Major types +// +DEFINE_GUID(MFMediaType_Default, +0x81A412E6, 0x8103, 0x4B06, 0x85, 0x7F, 0x18, 0x62, 0x78, 0x10, 0x24, 0xAC); +DEFINE_GUID(MFMediaType_Audio, +0x73647561, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); +DEFINE_GUID(MFMediaType_Video, +0x73646976, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); +DEFINE_GUID(MFMediaType_Protected, +0x7b4b6fe6, 0x9d04, 0x4494, 0xbe, 0x14, 0x7e, 0x0b, 0xd0, 0x76, 0xc8, 0xe4); +DEFINE_GUID(MFMediaType_SAMI, +0xe69669a0, 0x3dcd, 0x40cb, 0x9e, 0x2e, 0x37, 0x08, 0x38, 0x7c, 0x06, 0x16); +DEFINE_GUID(MFMediaType_Script, +0x72178C22, 0xE45B, 0x11D5, 0xBC, 0x2A, 0x00, 0xB0, 0xD0, 0xF3, 0xF4, 0xAB); +DEFINE_GUID(MFMediaType_Image, +0x72178C23, 0xE45B, 0x11D5, 0xBC, 0x2A, 0x00, 0xB0, 0xD0, 0xF3, 0xF4, 0xAB); +DEFINE_GUID(MFMediaType_HTML, +0x72178C24, 0xE45B, 0x11D5, 0xBC, 0x2A, 0x00, 0xB0, 0xD0, 0xF3, 0xF4, 0xAB); +DEFINE_GUID(MFMediaType_Binary, +0x72178C25, 0xE45B, 0x11D5, 0xBC, 0x2A, 0x00, 0xB0, 0xD0, 0xF3, 0xF4, 0xAB); +DEFINE_GUID(MFMediaType_FileTransfer, +0x72178C26, 0xE45B, 0x11D5, 0xBC, 0x2A, 0x00, 0xB0, 0xD0, 0xF3, 0xF4, 0xAB); +DEFINE_GUID(MFMediaType_Stream, +0xe436eb83, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); +DEFINE_GUID(MFMediaType_MultiplexedFrames, +0x6ea542b0, 0x281f, 0x4231, 0xa4, 0x64, 0xfe, 0x2f, 0x50, 0x22, 0x50, 0x1c); +DEFINE_GUID(MFMediaType_Subtitle, +0xa6d13581, 0xed50, 0x4e65, 0xae, 0x08, 0x26, 0x06, 0x55, 0x76, 0xaa, 0xcc); + +// TODO: switch to RS define once it exists (see: 5312604) +#if (WINVER >= _WIN32_WINNT_WIN10) +DEFINE_GUID(MFMediaType_Perception, +0x597ff6f9, 0x6ea2, 0x4670, 0x85, 0xb4, 0xea, 0x84, 0x7, 0x3f, 0xe9, 0x40); +#endif // (WINVER >= _WIN32_WINNT_WIN10) + +// +// Image subtypes (MFMediaType_Image major type) +// +// JPEG subtype: same as GUID_ContainerFormatJpeg +DEFINE_GUID(MFImageFormat_JPEG, +0x19e4a5aa, 0x5662, 0x4fc5, 0xa0, 0xc0, 0x17, 0x58, 0x02, 0x8e, 0x10, 0x57); + +// RGB32 subtype: same as MFVideoFormat_RGB32 +DEFINE_GUID(MFImageFormat_RGB32, +0x00000016, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + +// +// MPEG2 Stream subtypes (MFMediaType_Stream major type) +// +DEFINE_GUID(MFStreamFormat_MPEG2Transport, +0xe06d8023, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea); +DEFINE_GUID(MFStreamFormat_MPEG2Program, +0x263067d1, 0xd330, 0x45dc, 0xb6, 0x69, 0x34, 0xd9, 0x86, 0xe4, 0xe3, 0xe1); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +// +// Representations +// +DEFINE_GUID(AM_MEDIA_TYPE_REPRESENTATION, +0xe2e42ad2, 0x132c, 0x491e, 0xa2, 0x68, 0x3c, 0x7c, 0x2d, 0xca, 0x18, 0x1f); +DEFINE_GUID(FORMAT_MFVideoFormat, +0xaed4ab2d, 0x7326, 0x43cb, 0x94, 0x64, 0xc8, 0x79, 0xca, 0xb9, 0xc4, 0x3d); + + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////// Media Type functions ////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + +// +// Forward declaration +// +struct tagVIDEOINFOHEADER; +typedef struct tagVIDEOINFOHEADER VIDEOINFOHEADER; +struct tagVIDEOINFOHEADER2; +typedef struct tagVIDEOINFOHEADER2 VIDEOINFOHEADER2; +struct tagMPEG1VIDEOINFO; +typedef struct tagMPEG1VIDEOINFO MPEG1VIDEOINFO; +struct tagMPEG2VIDEOINFO; +typedef struct tagMPEG2VIDEOINFO MPEG2VIDEOINFO; +struct _AMMediaType; +typedef struct _AMMediaType AM_MEDIA_TYPE; + +STDAPI +MFValidateMediaTypeSize( + _In_ GUID FormatType, + _In_reads_bytes_opt_(cbSize) UINT8* pBlock, + _In_ UINT32 cbSize + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI +MFCreateMediaType( + _Outptr_ IMFMediaType** ppMFType + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +STDAPI +MFCreateMFVideoFormatFromMFMediaType( + _In_ IMFMediaType* pMFType, + _Out_ MFVIDEOFORMAT** ppMFVF, // must be deleted with CoTaskMemFree + _Out_opt_ UINT32* pcbSize + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +typedef enum _MFWaveFormatExConvertFlags { + MFWaveFormatExConvertFlag_Normal = 0, + MFWaveFormatExConvertFlag_ForceExtensible = 1 +} MFWaveFormatExConvertFlags; +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#ifdef __cplusplus + +// +// declarations with default parameters +// + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +STDAPI +MFCreateWaveFormatExFromMFMediaType( + _In_ IMFMediaType* pMFType, + _Out_ WAVEFORMATEX** ppWF, + _Out_opt_ UINT32* pcbSize, + _In_ UINT32 Flags = MFWaveFormatExConvertFlag_Normal + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +STDAPI +MFInitMediaTypeFromVideoInfoHeader( + _In_ IMFMediaType* pMFType, + _In_reads_bytes_(cbBufSize) const VIDEOINFOHEADER* pVIH, + _In_ UINT32 cbBufSize, + _In_opt_ const GUID* pSubtype = NULL + ); + +STDAPI +MFInitMediaTypeFromVideoInfoHeader2( + _In_ IMFMediaType* pMFType, + _In_reads_bytes_(cbBufSize) const VIDEOINFOHEADER2* pVIH2, + _In_ UINT32 cbBufSize, + _In_opt_ const GUID* pSubtype = NULL + ); + +STDAPI +MFInitMediaTypeFromMPEG1VideoInfo( + _In_ IMFMediaType* pMFType, + _In_reads_bytes_(cbBufSize) const MPEG1VIDEOINFO* pMP1VI, + _In_ UINT32 cbBufSize, + _In_opt_ const GUID* pSubtype = NULL + ); + +STDAPI +MFInitMediaTypeFromMPEG2VideoInfo( + _In_ IMFMediaType* pMFType, + _In_reads_bytes_(cbBufSize) const MPEG2VIDEOINFO* pMP2VI, + _In_ UINT32 cbBufSize, + _In_opt_ const GUID* pSubtype = NULL + ); + +STDAPI +MFCalculateBitmapImageSize( + _In_reads_bytes_(cbBufSize) const BITMAPINFOHEADER* pBMIH, + _In_ UINT32 cbBufSize, + _Out_ UINT32* pcbImageSize, + _Out_opt_ BOOL* pbKnown = NULL + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#else /* cplusplus */ + +// +// same declarations without default parameters +// + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI +MFCreateWaveFormatExFromMFMediaType( + _In_ IMFMediaType* pMFType, + _Out_ WAVEFORMATEX** ppWF, + _Out_opt_ UINT32* pcbSize, + _In_ UINT32 Flags + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +STDAPI +MFInitMediaTypeFromVideoInfoHeader( + _In_ IMFMediaType* pMFType, + _In_reads_bytes_(cbBufSize) const VIDEOINFOHEADER* pVIH, + _In_ UINT32 cbBufSize, + _In_opt_ const GUID* pSubtype + ); + +STDAPI +MFInitMediaTypeFromVideoInfoHeader2( + _In_ IMFMediaType* pMFType, + _In_reads_bytes_(cbBufSize) const VIDEOINFOHEADER2* pVIH2, + _In_ UINT32 cbBufSize, + _In_opt_ const GUID* pSubtype + ); + +STDAPI +MFInitMediaTypeFromMPEG1VideoInfo( + _In_ IMFMediaType* pMFType, + _In_reads_bytes_(cbBufSize) const MPEG1VIDEOINFO* pMP1VI, + _In_ UINT32 cbBufSize, + _In_opt_ const GUID* pSubtype + ); + +STDAPI +MFInitMediaTypeFromMPEG2VideoInfo( + _In_ IMFMediaType* pMFType, + _In_reads_bytes_(cbBufSize) const MPEG2VIDEOINFO* pMP2VI, + _In_ UINT32 cbBufSize, + _In_opt_ const GUID* pSubtype + ); + +STDAPI +MFCalculateBitmapImageSize( + _In_reads_bytes_(cbBufSize) const BITMAPINFOHEADER* pBMIH, + _In_ UINT32 cbBufSize, + _Out_ UINT32* pcbImageSize, + _Out_opt_ BOOL* pbKnown + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#endif /* cplusplus */ + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +STDAPI +MFCalculateImageSize( + _In_ REFGUID guidSubtype, + _In_ UINT32 unWidth, + _In_ UINT32 unHeight, + _Out_ UINT32* pcbImageSize + ); + +STDAPI +MFFrameRateToAverageTimePerFrame( + _In_ UINT32 unNumerator, + _In_ UINT32 unDenominator, + _Out_ UINT64* punAverageTimePerFrame + ); + +STDAPI +MFAverageTimePerFrameToFrameRate( + _In_ UINT64 unAverageTimePerFrame, + _Out_ UINT32* punNumerator, + _Out_ UINT32* punDenominator + ); + +STDAPI +MFInitMediaTypeFromMFVideoFormat( + _In_ IMFMediaType* pMFType, + _In_reads_bytes_(cbBufSize) const MFVIDEOFORMAT* pMFVF, + _In_ UINT32 cbBufSize + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +STDAPI +MFInitMediaTypeFromWaveFormatEx( + _In_ IMFMediaType* pMFType, + _In_reads_bytes_(cbBufSize) const WAVEFORMATEX* pWaveFormat, + _In_ UINT32 cbBufSize + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +STDAPI +MFInitMediaTypeFromAMMediaType( + _In_ IMFMediaType* pMFType, + _In_ const AM_MEDIA_TYPE* pAMType + ); + +STDAPI +MFInitAMMediaTypeFromMFMediaType( + _In_ IMFMediaType* pMFType, + _In_ GUID guidFormatBlockType, + _Inout_ AM_MEDIA_TYPE* pAMType + ); + +STDAPI +MFCreateAMMediaTypeFromMFMediaType( + _In_ IMFMediaType* pMFType, + _In_ GUID guidFormatBlockType, + _Inout_ AM_MEDIA_TYPE** ppAMType // delete with DeleteMediaType + ); + + +// +// This function compares a full media type to a partial media type. +// +// A "partial" media type is one that is given out by a component as a possible +// media type it could accept. Many attributes may be unset, which represents +// a "don't care" status for that attribute. +// +// For example, a video effect may report that it supports YV12, +// but not want to specify a particular size. It simply creates a media type and sets +// the major type to MFMediaType_Video and the subtype to MEDIASUBTYPE_YV12. +// +// The comparison function succeeds if the partial type contains at least a major type, +// and all of the attributes in the partial type exist in the full type and are set to +// the same value. +// +STDAPI_(BOOL) +MFCompareFullToPartialMediaType( + _In_ IMFMediaType* pMFTypeFull, + _In_ IMFMediaType* pMFTypePartial + ); + + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +STDAPI +MFWrapMediaType( + _In_ IMFMediaType* pOrig, + _In_ REFGUID MajorType, + _In_ REFGUID SubType, + _Out_ IMFMediaType ** ppWrap + ); + + + +STDAPI +MFUnwrapMediaType( + _In_ IMFMediaType* pWrap, + _Out_ IMFMediaType ** ppOrig + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +// +// MFCreateVideoMediaType +// + +#ifdef _KSMEDIA_ +STDAPI MFCreateVideoMediaTypeFromVideoInfoHeader( + _In_ const KS_VIDEOINFOHEADER* pVideoInfoHeader, + DWORD cbVideoInfoHeader, + DWORD dwPixelAspectRatioX, + DWORD dwPixelAspectRatioY, + MFVideoInterlaceMode InterlaceMode, + QWORD VideoFlags, + _In_opt_ const GUID * pSubtype, + _Out_ IMFVideoMediaType** ppIVideoMediaType + ); + +STDAPI MFCreateVideoMediaTypeFromVideoInfoHeader2( + _In_ const KS_VIDEOINFOHEADER2* pVideoInfoHeader, + DWORD cbVideoInfoHeader, + QWORD AdditionalVideoFlags, + _In_opt_ const GUID * pSubtype, + _Out_ IMFVideoMediaType** ppIVideoMediaType + ); + +#endif + +STDAPI MFCreateVideoMediaType( + _In_ const MFVIDEOFORMAT* pVideoFormat, + _Out_ IMFVideoMediaType** ppIVideoMediaType + ); + +STDAPI MFCreateVideoMediaTypeFromSubtype( + _In_ const GUID * pAMSubtype, + _Out_ IMFVideoMediaType **ppIVideoMediaType + ); + +STDAPI_(BOOL) +MFIsFormatYUV( + DWORD Format + ); + +// +// These depend on BITMAPINFOHEADER being defined +// +STDAPI MFCreateVideoMediaTypeFromBitMapInfoHeader( + _In_ const BITMAPINFOHEADER* pbmihBitMapInfoHeader, + DWORD dwPixelAspectRatioX, + DWORD dwPixelAspectRatioY, + MFVideoInterlaceMode InterlaceMode, + QWORD VideoFlags, + QWORD qwFramesPerSecondNumerator, + QWORD qwFramesPerSecondDenominator, + DWORD dwMaxBitRate, + _Out_ IMFVideoMediaType** ppIVideoMediaType + ); + +STDAPI MFGetStrideForBitmapInfoHeader( + DWORD format, + DWORD dwWidth, + _Out_ LONG* pStride + ); + +STDAPI MFGetPlaneSize( + DWORD format, + DWORD dwWidth, + DWORD dwHeight, + _Out_ DWORD* pdwPlaneSize + ); + +#if (WINVER >= _WIN32_WINNT_WIN7) +// +// MFCreateVideoMediaTypeFromBitMapInfoHeaderEx +// + +STDAPI MFCreateVideoMediaTypeFromBitMapInfoHeaderEx( + _In_reads_bytes_(cbBitMapInfoHeader) const BITMAPINFOHEADER* pbmihBitMapInfoHeader, + _In_ UINT32 cbBitMapInfoHeader, + DWORD dwPixelAspectRatioX, + DWORD dwPixelAspectRatioY, + MFVideoInterlaceMode InterlaceMode, + QWORD VideoFlags, + DWORD dwFramesPerSecondNumerator, + DWORD dwFramesPerSecondDenominator, + DWORD dwMaxBitRate, + _Out_ IMFVideoMediaType** ppIVideoMediaType + ); +#endif // (WINVER >= _WIN32_WINNT_WIN7) + +// +// MFCreateMediaTypeFromRepresentation +// + +STDAPI MFCreateMediaTypeFromRepresentation( + GUID guidRepresentation, + _In_ LPVOID pvRepresentation, + _Out_ IMFMediaType** ppIMediaType + ); + + +// +// MFCreateAudioMediaType +// + + +STDAPI +MFCreateAudioMediaType( + _In_ const WAVEFORMATEX* pAudioFormat, + _Out_ IMFAudioMediaType** ppIAudioMediaType + ); + +DWORD +STDMETHODCALLTYPE +MFGetUncompressedVideoFormat( + _In_ const MFVIDEOFORMAT* pVideoFormat + ); + +STDAPI +MFInitVideoFormat( + _In_ MFVIDEOFORMAT* pVideoFormat, + _In_ MFStandardVideoFormat type + ); + +STDAPI +MFInitVideoFormat_RGB( + _In_ MFVIDEOFORMAT* pVideoFormat, + _In_ DWORD dwWidth, + _In_ DWORD dwHeight, + _In_ DWORD D3Dfmt /* 0 indicates sRGB */ + ); + +STDAPI +MFConvertColorInfoToDXVA( + _Out_ DWORD* pdwToDXVA, + _In_ const MFVIDEOFORMAT* pFromFormat + ); +STDAPI +MFConvertColorInfoFromDXVA( + _Inout_ MFVIDEOFORMAT* pToFormat, + _In_ DWORD dwFromDXVA + ); + +// +// Optimized stride copy function +// +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFCopyImage( + _Out_writes_bytes_(_Inexpressible_(abs(lDestStride) * dwLines)) BYTE* pDest, + LONG lDestStride, + _In_reads_bytes_(_Inexpressible_(abs(lSrcStride) * dwLines)) const BYTE* pSrc, + LONG lSrcStride, + _Out_range_(<=, _Inexpressible_(min(abs(lSrcStride), abs(lDestStride)))) DWORD dwWidthInBytes, + DWORD dwLines + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +STDAPI MFConvertFromFP16Array( + _Out_writes_(dwCount) float* pDest, + _In_reads_(dwCount) const WORD* pSrc, + DWORD dwCount + ); + +STDAPI MFConvertToFP16Array( + _Out_writes_(dwCount) WORD* pDest, + _In_reads_(dwCount) const float* pSrc, + DWORD dwCount + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +STDAPI MFCreate2DMediaBuffer( + _In_ DWORD dwWidth, + _In_ DWORD dwHeight, + _In_ DWORD dwFourCC, + _In_ BOOL fBottomUp, + _Out_ IMFMediaBuffer** ppBuffer + ); + + +// +// Creates an optimal system memory media buffer from a media type +// +STDAPI MFCreateMediaBufferFromMediaType( + _In_ IMFMediaType* pMediaType, + _In_ LONGLONG llDuration, // Sample Duration, needed for audio + _In_ DWORD dwMinLength, // 0 means optimized default + _In_ DWORD dwMinAlignment, // 0 means optimized default + _Outptr_ IMFMediaBuffer** ppBuffer + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +/////////////////////////////////////////////////////////////////////////////////////////////////////////////// Attributes Utility functions //////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + + +#ifdef __cplusplus + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +// +// IMFAttributes inline UTILITY FUNCTIONS - used for IMFMediaType as well +// +inline +UINT32 +HI32(UINT64 unPacked) +{ + return (UINT32)(unPacked >> 32); +} + +inline +UINT32 +LO32(UINT64 unPacked) +{ + return (UINT32)unPacked; +} + +inline +UINT64 +Pack2UINT32AsUINT64(UINT32 unHigh, UINT32 unLow) +{ + return ((UINT64)unHigh << 32) | unLow; +} + +inline +void +Unpack2UINT32AsUINT64(UINT64 unPacked, _Out_ UINT32* punHigh, _Out_ UINT32* punLow) +{ + *punHigh = HI32(unPacked); + *punLow = LO32(unPacked); +} + +inline +UINT64 +PackSize(UINT32 unWidth, UINT32 unHeight) +{ + return Pack2UINT32AsUINT64(unWidth, unHeight); +} + +inline +void +UnpackSize(UINT64 unPacked, _Out_ UINT32* punWidth, _Out_ UINT32* punHeight) +{ + Unpack2UINT32AsUINT64(unPacked, punWidth, punHeight); +} + +inline +UINT64 +PackRatio(INT32 nNumerator, UINT32 unDenominator) +{ + return Pack2UINT32AsUINT64((UINT32)nNumerator, unDenominator); +} + +inline +void +UnpackRatio(UINT64 unPacked, _Out_ INT32* pnNumerator, _Out_ UINT32* punDenominator) +{ + Unpack2UINT32AsUINT64(unPacked, (UINT32*)pnNumerator, punDenominator); +} + + +// +// "failsafe" inline get methods - return the stored value or return a default +// +inline +UINT32 +MFGetAttributeUINT32( + IMFAttributes* pAttributes, + REFGUID guidKey, + UINT32 unDefault + ) +{ + UINT32 unRet; + if (FAILED(pAttributes->GetUINT32(guidKey, &unRet))) { + unRet = unDefault; + } + return unRet; +} + +inline +UINT64 +MFGetAttributeUINT64( + IMFAttributes* pAttributes, + REFGUID guidKey, + UINT64 unDefault + ) +{ + UINT64 unRet; + if (FAILED(pAttributes->GetUINT64(guidKey, &unRet))) { + unRet = unDefault; + } + return unRet; +} + +inline +double +MFGetAttributeDouble( + IMFAttributes* pAttributes, + REFGUID guidKey, + double fDefault + ) +{ + double fRet; + if (FAILED(pAttributes->GetDouble(guidKey, &fRet))) { + fRet = fDefault; + } + return fRet; +} + +// +// helpers for getting/setting ratios and sizes +// + +inline +HRESULT +MFGetAttribute2UINT32asUINT64( + IMFAttributes* pAttributes, + REFGUID guidKey, + _Out_ UINT32* punHigh32, + _Out_ UINT32* punLow32 + ) +{ + UINT64 unPacked; + HRESULT hr = S_OK; + + hr = pAttributes->GetUINT64(guidKey, &unPacked); + if (FAILED(hr)) { + return hr; + } + Unpack2UINT32AsUINT64(unPacked, punHigh32, punLow32); + + return hr; +} + +inline +HRESULT +MFSetAttribute2UINT32asUINT64( + IMFAttributes* pAttributes, + REFGUID guidKey, + UINT32 unHigh32, + UINT32 unLow32 + ) +{ + return pAttributes->SetUINT64(guidKey, Pack2UINT32AsUINT64(unHigh32, unLow32)); +} + +inline +HRESULT +MFGetAttributeRatio( + IMFAttributes* pAttributes, + REFGUID guidKey, + _Out_ UINT32* punNumerator, + _Out_ UINT32* punDenominator + ) +{ + return MFGetAttribute2UINT32asUINT64(pAttributes, guidKey, punNumerator, punDenominator); +} + +inline +HRESULT +MFGetAttributeSize( + IMFAttributes* pAttributes, + REFGUID guidKey, + _Out_ UINT32* punWidth, + _Out_ UINT32* punHeight + ) +{ + return MFGetAttribute2UINT32asUINT64(pAttributes, guidKey, punWidth, punHeight); +} + +inline +HRESULT +MFSetAttributeRatio( + IMFAttributes* pAttributes, + REFGUID guidKey, + UINT32 unNumerator, + UINT32 unDenominator + ) +{ + return MFSetAttribute2UINT32asUINT64(pAttributes, guidKey, unNumerator, unDenominator); +} + +inline +HRESULT +MFSetAttributeSize( + IMFAttributes* pAttributes, + REFGUID guidKey, + UINT32 unWidth, + UINT32 unHeight + ) +{ + return MFSetAttribute2UINT32asUINT64(pAttributes, guidKey, unWidth, unHeight); +} + +#ifdef _INTSAFE_H_INCLUDED_ +inline +HRESULT +MFGetAttributeString( + IMFAttributes* pAttributes, + REFGUID guidKey, + _Outptr_ PWSTR *ppsz + ) +{ + UINT32 length; + PWSTR psz = NULL; + *ppsz = NULL; + HRESULT hr = pAttributes->GetStringLength(guidKey, &length); + // add NULL to length + if (SUCCEEDED(hr)) { + hr = UIntAdd(length, 1, &length); + } + if (SUCCEEDED(hr)) { + size_t cb; + hr = SizeTMult(length, sizeof(WCHAR), &cb); + if( SUCCEEDED( hr ) ) + { + psz = PWSTR( CoTaskMemAlloc( cb ) ); + if( !psz ) + { + hr = E_OUTOFMEMORY; + } + } + } + if (SUCCEEDED(hr)) { + hr = pAttributes->GetString(guidKey, psz, length, &length); + } + if (SUCCEEDED(hr)) { + *ppsz = psz; + } else { + CoTaskMemFree(psz); + } + return hr; +} + +#endif // _INTSAFE_H_INCLUDED_ + +/////////////////////////////// Collection //////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + +// +// Instantiates the MF-provided IMFCollection implementation +// +STDAPI MFCreateCollection( + _Out_ IMFCollection **ppIMFCollection ); + + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#endif + +//////////////////////////////////////////////////////////////////////////////// +//////////////////////////////// Memory Management //////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +// +// Heap alloc/free +// +typedef enum _EAllocationType +{ + eAllocationTypeDynamic, + eAllocationTypeRT, + eAllocationTypePageable, + eAllocationTypeIgnore +} EAllocationType; + +EXTERN_C void* WINAPI MFHeapAlloc( size_t nSize, + ULONG dwFlags, + _In_opt_ char *pszFile, + int line, + EAllocationType eat); +EXTERN_C void WINAPI MFHeapFree( void * pv ); + +////////////////////////// SourceResolver //////////////////////////// +//////////////////////////////////////////////////////////////////////////////// +DEFINE_GUID(CLSID_MFSourceResolver, + 0x90eab60f, + 0xe43a, + 0x4188, + 0xbc, 0xc4, 0xe4, 0x7f, 0xdf, 0x04, 0x86, 0x8c); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#if (WINVER >= _WIN32_WINNT_WIN7) +// Return (a * b + d) / c +// Returns _I64_MAX or LLONG_MIN on failure or _I64_MAX if mplat.dll is not available + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +LONGLONG WINAPI MFllMulDiv(LONGLONG a, LONGLONG b, LONGLONG c, LONGLONG d); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + +#endif // (WINVER >= _WIN32_WINNT_WIN7) + + +////////////////////////// Content Protection //////////////////////////// +//////////////////////////////////////////////////////////////////////////////// + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + +STDAPI MFGetContentProtectionSystemCLSID( + _In_ REFGUID guidProtectionSystemID, + _Out_ CLSID *pclsid ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +// MF_DEVICESTREAM_ATTRIBUTE_FACEAUTH_CAPABILITY +// Data type: UINT64 +// Represents the Capability field of the KSCAMERA_EXTENDEDPROP_HEADER corresponding to the +// KSPROPERTY_CAMERACONTROL_EXTENDED_FACEAUTH_MODE extended property control. If this control +// is not supported, this attribute will not be present on the stream. +// The capability advertised will only contain the bitwise OR of the available +// supported modes defined by the Face Auth DDI in ksmedia.h: +// +// KSCAMERA_EXTENDEDPROP_FACEAUTH_MODE_DISABLED +// KSCAMERA_EXTENDEDPROP_FACEAUTH_MODE_ALTERNATIVE_FRAME_ILLUMINATION +// KSCAMERA_EXTENDEDPROP_FACEAUTH_MODE_BACKGROUND_SUBTRACTION +DEFINE_GUID(MF_DEVICESTREAM_ATTRIBUTE_FACEAUTH_CAPABILITY, +0xCB6FD12A, 0x2248, 0x4E41, 0xAD, 0x46, 0xE7, 0x8B, 0xB9, 0x0A, 0xB9, 0xFC); + +// MF_DEVICESTREAM_ATTRIBUTE_SECURE_CAPABILITY +// Data type: UINT64 +// Represents the Capability field of the KSCAMERA_EXTENDEDPROP_HEADER corresponding to the +// KSPROPERTY_CAMERACONTROL_EXTENDED_SECURE_MODE extended property control. If this control +// is not supported, this attribute will not be present on the stream. +// The capability advertised will only contain the bitwise OR of the available +// supported modes defined by the Secure DDI in ksmedia.h: +// +// KSCAMERA_EXTENDEDPROP_SECURE_MODE_DISABLED +// KSCAMERA_EXTENDEDPROP_SECURE_MODE_ENABLED +DEFINE_GUID(MF_DEVICESTREAM_ATTRIBUTE_SECURE_CAPABILITY, +0x940FD626, 0xEA6E, 0x4684, 0x98, 0x40, 0x36, 0xBD, 0x6E, 0xC9, 0xFB, 0xEF); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + + +#if defined(__cplusplus) +} +#endif + +#endif //#if !defined(__MFAPI_H__) + diff --git a/util/test/demos/dx/official/mfidl.h b/util/test/demos/dx/official/mfidl.h new file mode 100644 index 000000000..8d44897e2 --- /dev/null +++ b/util/test/demos/dx/official/mfidl.h @@ -0,0 +1,21182 @@ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0622 */ +/* @@MIDL_FILE_HEADING( ) */ + + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCSAL_H_VERSION__ +#define __REQUIRED_RPCSAL_H_VERSION__ 100 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + +#ifndef COM_NO_WINDOWS_H +#include "windows.h" +#include "ole2.h" +#endif /*COM_NO_WINDOWS_H*/ + +#ifndef __mfidl_h__ +#define __mfidl_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +/* Forward Declarations */ + +#ifndef __IMFMediaSession_FWD_DEFINED__ +#define __IMFMediaSession_FWD_DEFINED__ +typedef interface IMFMediaSession IMFMediaSession; + +#endif /* __IMFMediaSession_FWD_DEFINED__ */ + + +#ifndef __IMFSourceResolver_FWD_DEFINED__ +#define __IMFSourceResolver_FWD_DEFINED__ +typedef interface IMFSourceResolver IMFSourceResolver; + +#endif /* __IMFSourceResolver_FWD_DEFINED__ */ + + +#ifndef __IMFMediaSource_FWD_DEFINED__ +#define __IMFMediaSource_FWD_DEFINED__ +typedef interface IMFMediaSource IMFMediaSource; + +#endif /* __IMFMediaSource_FWD_DEFINED__ */ + + +#ifndef __IMFMediaSourceEx_FWD_DEFINED__ +#define __IMFMediaSourceEx_FWD_DEFINED__ +typedef interface IMFMediaSourceEx IMFMediaSourceEx; + +#endif /* __IMFMediaSourceEx_FWD_DEFINED__ */ + + +#ifndef __IMFClockConsumer_FWD_DEFINED__ +#define __IMFClockConsumer_FWD_DEFINED__ +typedef interface IMFClockConsumer IMFClockConsumer; + +#endif /* __IMFClockConsumer_FWD_DEFINED__ */ + + +#ifndef __IMFMediaStream_FWD_DEFINED__ +#define __IMFMediaStream_FWD_DEFINED__ +typedef interface IMFMediaStream IMFMediaStream; + +#endif /* __IMFMediaStream_FWD_DEFINED__ */ + + +#ifndef __IMFMediaSink_FWD_DEFINED__ +#define __IMFMediaSink_FWD_DEFINED__ +typedef interface IMFMediaSink IMFMediaSink; + +#endif /* __IMFMediaSink_FWD_DEFINED__ */ + + +#ifndef __IMFStreamSink_FWD_DEFINED__ +#define __IMFStreamSink_FWD_DEFINED__ +typedef interface IMFStreamSink IMFStreamSink; + +#endif /* __IMFStreamSink_FWD_DEFINED__ */ + + +#ifndef __IMFVideoSampleAllocator_FWD_DEFINED__ +#define __IMFVideoSampleAllocator_FWD_DEFINED__ +typedef interface IMFVideoSampleAllocator IMFVideoSampleAllocator; + +#endif /* __IMFVideoSampleAllocator_FWD_DEFINED__ */ + + +#ifndef __IMFVideoSampleAllocatorNotify_FWD_DEFINED__ +#define __IMFVideoSampleAllocatorNotify_FWD_DEFINED__ +typedef interface IMFVideoSampleAllocatorNotify IMFVideoSampleAllocatorNotify; + +#endif /* __IMFVideoSampleAllocatorNotify_FWD_DEFINED__ */ + + +#ifndef __IMFVideoSampleAllocatorNotifyEx_FWD_DEFINED__ +#define __IMFVideoSampleAllocatorNotifyEx_FWD_DEFINED__ +typedef interface IMFVideoSampleAllocatorNotifyEx IMFVideoSampleAllocatorNotifyEx; + +#endif /* __IMFVideoSampleAllocatorNotifyEx_FWD_DEFINED__ */ + + +#ifndef __IMFVideoSampleAllocatorCallback_FWD_DEFINED__ +#define __IMFVideoSampleAllocatorCallback_FWD_DEFINED__ +typedef interface IMFVideoSampleAllocatorCallback IMFVideoSampleAllocatorCallback; + +#endif /* __IMFVideoSampleAllocatorCallback_FWD_DEFINED__ */ + + +#ifndef __IMFVideoSampleAllocatorEx_FWD_DEFINED__ +#define __IMFVideoSampleAllocatorEx_FWD_DEFINED__ +typedef interface IMFVideoSampleAllocatorEx IMFVideoSampleAllocatorEx; + +#endif /* __IMFVideoSampleAllocatorEx_FWD_DEFINED__ */ + + +#ifndef __IMFDXGIDeviceManagerSource_FWD_DEFINED__ +#define __IMFDXGIDeviceManagerSource_FWD_DEFINED__ +typedef interface IMFDXGIDeviceManagerSource IMFDXGIDeviceManagerSource; + +#endif /* __IMFDXGIDeviceManagerSource_FWD_DEFINED__ */ + + +#ifndef __IMFVideoProcessorControl_FWD_DEFINED__ +#define __IMFVideoProcessorControl_FWD_DEFINED__ +typedef interface IMFVideoProcessorControl IMFVideoProcessorControl; + +#endif /* __IMFVideoProcessorControl_FWD_DEFINED__ */ + + +#ifndef __IMFVideoProcessorControl2_FWD_DEFINED__ +#define __IMFVideoProcessorControl2_FWD_DEFINED__ +typedef interface IMFVideoProcessorControl2 IMFVideoProcessorControl2; + +#endif /* __IMFVideoProcessorControl2_FWD_DEFINED__ */ + + +#ifndef __IMFVideoProcessorControl3_FWD_DEFINED__ +#define __IMFVideoProcessorControl3_FWD_DEFINED__ +typedef interface IMFVideoProcessorControl3 IMFVideoProcessorControl3; + +#endif /* __IMFVideoProcessorControl3_FWD_DEFINED__ */ + + +#ifndef __IMFTopology_FWD_DEFINED__ +#define __IMFTopology_FWD_DEFINED__ +typedef interface IMFTopology IMFTopology; + +#endif /* __IMFTopology_FWD_DEFINED__ */ + + +#ifndef __IMFTopologyNode_FWD_DEFINED__ +#define __IMFTopologyNode_FWD_DEFINED__ +typedef interface IMFTopologyNode IMFTopologyNode; + +#endif /* __IMFTopologyNode_FWD_DEFINED__ */ + + +#ifndef __IMFGetService_FWD_DEFINED__ +#define __IMFGetService_FWD_DEFINED__ +typedef interface IMFGetService IMFGetService; + +#endif /* __IMFGetService_FWD_DEFINED__ */ + + +#ifndef __IMFClock_FWD_DEFINED__ +#define __IMFClock_FWD_DEFINED__ +typedef interface IMFClock IMFClock; + +#endif /* __IMFClock_FWD_DEFINED__ */ + + +#ifndef __IMFPresentationClock_FWD_DEFINED__ +#define __IMFPresentationClock_FWD_DEFINED__ +typedef interface IMFPresentationClock IMFPresentationClock; + +#endif /* __IMFPresentationClock_FWD_DEFINED__ */ + + +#ifndef __IMFPresentationTimeSource_FWD_DEFINED__ +#define __IMFPresentationTimeSource_FWD_DEFINED__ +typedef interface IMFPresentationTimeSource IMFPresentationTimeSource; + +#endif /* __IMFPresentationTimeSource_FWD_DEFINED__ */ + + +#ifndef __IMFClockStateSink_FWD_DEFINED__ +#define __IMFClockStateSink_FWD_DEFINED__ +typedef interface IMFClockStateSink IMFClockStateSink; + +#endif /* __IMFClockStateSink_FWD_DEFINED__ */ + + +#ifndef __IMFPresentationDescriptor_FWD_DEFINED__ +#define __IMFPresentationDescriptor_FWD_DEFINED__ +typedef interface IMFPresentationDescriptor IMFPresentationDescriptor; + +#endif /* __IMFPresentationDescriptor_FWD_DEFINED__ */ + + +#ifndef __IMFStreamDescriptor_FWD_DEFINED__ +#define __IMFStreamDescriptor_FWD_DEFINED__ +typedef interface IMFStreamDescriptor IMFStreamDescriptor; + +#endif /* __IMFStreamDescriptor_FWD_DEFINED__ */ + + +#ifndef __IMFMediaTypeHandler_FWD_DEFINED__ +#define __IMFMediaTypeHandler_FWD_DEFINED__ +typedef interface IMFMediaTypeHandler IMFMediaTypeHandler; + +#endif /* __IMFMediaTypeHandler_FWD_DEFINED__ */ + + +#ifndef __IMFTimer_FWD_DEFINED__ +#define __IMFTimer_FWD_DEFINED__ +typedef interface IMFTimer IMFTimer; + +#endif /* __IMFTimer_FWD_DEFINED__ */ + + +#ifndef __IMFShutdown_FWD_DEFINED__ +#define __IMFShutdown_FWD_DEFINED__ +typedef interface IMFShutdown IMFShutdown; + +#endif /* __IMFShutdown_FWD_DEFINED__ */ + + +#ifndef __IMFTopoLoader_FWD_DEFINED__ +#define __IMFTopoLoader_FWD_DEFINED__ +typedef interface IMFTopoLoader IMFTopoLoader; + +#endif /* __IMFTopoLoader_FWD_DEFINED__ */ + + +#ifndef __IMFContentProtectionManager_FWD_DEFINED__ +#define __IMFContentProtectionManager_FWD_DEFINED__ +typedef interface IMFContentProtectionManager IMFContentProtectionManager; + +#endif /* __IMFContentProtectionManager_FWD_DEFINED__ */ + + +#ifndef __IMFContentEnabler_FWD_DEFINED__ +#define __IMFContentEnabler_FWD_DEFINED__ +typedef interface IMFContentEnabler IMFContentEnabler; + +#endif /* __IMFContentEnabler_FWD_DEFINED__ */ + + +#ifndef __IMFMetadata_FWD_DEFINED__ +#define __IMFMetadata_FWD_DEFINED__ +typedef interface IMFMetadata IMFMetadata; + +#endif /* __IMFMetadata_FWD_DEFINED__ */ + + +#ifndef __IMFMetadataProvider_FWD_DEFINED__ +#define __IMFMetadataProvider_FWD_DEFINED__ +typedef interface IMFMetadataProvider IMFMetadataProvider; + +#endif /* __IMFMetadataProvider_FWD_DEFINED__ */ + + +#ifndef __IMFRateSupport_FWD_DEFINED__ +#define __IMFRateSupport_FWD_DEFINED__ +typedef interface IMFRateSupport IMFRateSupport; + +#endif /* __IMFRateSupport_FWD_DEFINED__ */ + + +#ifndef __IMFRateControl_FWD_DEFINED__ +#define __IMFRateControl_FWD_DEFINED__ +typedef interface IMFRateControl IMFRateControl; + +#endif /* __IMFRateControl_FWD_DEFINED__ */ + + +#ifndef __IMFTimecodeTranslate_FWD_DEFINED__ +#define __IMFTimecodeTranslate_FWD_DEFINED__ +typedef interface IMFTimecodeTranslate IMFTimecodeTranslate; + +#endif /* __IMFTimecodeTranslate_FWD_DEFINED__ */ + + +#ifndef __IMFSeekInfo_FWD_DEFINED__ +#define __IMFSeekInfo_FWD_DEFINED__ +typedef interface IMFSeekInfo IMFSeekInfo; + +#endif /* __IMFSeekInfo_FWD_DEFINED__ */ + + +#ifndef __IMFSimpleAudioVolume_FWD_DEFINED__ +#define __IMFSimpleAudioVolume_FWD_DEFINED__ +typedef interface IMFSimpleAudioVolume IMFSimpleAudioVolume; + +#endif /* __IMFSimpleAudioVolume_FWD_DEFINED__ */ + + +#ifndef __IMFAudioStreamVolume_FWD_DEFINED__ +#define __IMFAudioStreamVolume_FWD_DEFINED__ +typedef interface IMFAudioStreamVolume IMFAudioStreamVolume; + +#endif /* __IMFAudioStreamVolume_FWD_DEFINED__ */ + + +#ifndef __IMFAudioPolicy_FWD_DEFINED__ +#define __IMFAudioPolicy_FWD_DEFINED__ +typedef interface IMFAudioPolicy IMFAudioPolicy; + +#endif /* __IMFAudioPolicy_FWD_DEFINED__ */ + + +#ifndef __IMFSampleGrabberSinkCallback_FWD_DEFINED__ +#define __IMFSampleGrabberSinkCallback_FWD_DEFINED__ +typedef interface IMFSampleGrabberSinkCallback IMFSampleGrabberSinkCallback; + +#endif /* __IMFSampleGrabberSinkCallback_FWD_DEFINED__ */ + + +#ifndef __IMFSampleGrabberSinkCallback2_FWD_DEFINED__ +#define __IMFSampleGrabberSinkCallback2_FWD_DEFINED__ +typedef interface IMFSampleGrabberSinkCallback2 IMFSampleGrabberSinkCallback2; + +#endif /* __IMFSampleGrabberSinkCallback2_FWD_DEFINED__ */ + + +#ifndef __IMFWorkQueueServices_FWD_DEFINED__ +#define __IMFWorkQueueServices_FWD_DEFINED__ +typedef interface IMFWorkQueueServices IMFWorkQueueServices; + +#endif /* __IMFWorkQueueServices_FWD_DEFINED__ */ + + +#ifndef __IMFWorkQueueServicesEx_FWD_DEFINED__ +#define __IMFWorkQueueServicesEx_FWD_DEFINED__ +typedef interface IMFWorkQueueServicesEx IMFWorkQueueServicesEx; + +#endif /* __IMFWorkQueueServicesEx_FWD_DEFINED__ */ + + +#ifndef __IMFQualityManager_FWD_DEFINED__ +#define __IMFQualityManager_FWD_DEFINED__ +typedef interface IMFQualityManager IMFQualityManager; + +#endif /* __IMFQualityManager_FWD_DEFINED__ */ + + +#ifndef __IMFQualityAdvise_FWD_DEFINED__ +#define __IMFQualityAdvise_FWD_DEFINED__ +typedef interface IMFQualityAdvise IMFQualityAdvise; + +#endif /* __IMFQualityAdvise_FWD_DEFINED__ */ + + +#ifndef __IMFQualityAdvise2_FWD_DEFINED__ +#define __IMFQualityAdvise2_FWD_DEFINED__ +typedef interface IMFQualityAdvise2 IMFQualityAdvise2; + +#endif /* __IMFQualityAdvise2_FWD_DEFINED__ */ + + +#ifndef __IMFQualityAdviseLimits_FWD_DEFINED__ +#define __IMFQualityAdviseLimits_FWD_DEFINED__ +typedef interface IMFQualityAdviseLimits IMFQualityAdviseLimits; + +#endif /* __IMFQualityAdviseLimits_FWD_DEFINED__ */ + + +#ifndef __IMFRealTimeClient_FWD_DEFINED__ +#define __IMFRealTimeClient_FWD_DEFINED__ +typedef interface IMFRealTimeClient IMFRealTimeClient; + +#endif /* __IMFRealTimeClient_FWD_DEFINED__ */ + + +#ifndef __IMFRealTimeClientEx_FWD_DEFINED__ +#define __IMFRealTimeClientEx_FWD_DEFINED__ +typedef interface IMFRealTimeClientEx IMFRealTimeClientEx; + +#endif /* __IMFRealTimeClientEx_FWD_DEFINED__ */ + + +#ifndef __IMFSequencerSource_FWD_DEFINED__ +#define __IMFSequencerSource_FWD_DEFINED__ +typedef interface IMFSequencerSource IMFSequencerSource; + +#endif /* __IMFSequencerSource_FWD_DEFINED__ */ + + +#ifndef __IMFMediaSourceTopologyProvider_FWD_DEFINED__ +#define __IMFMediaSourceTopologyProvider_FWD_DEFINED__ +typedef interface IMFMediaSourceTopologyProvider IMFMediaSourceTopologyProvider; + +#endif /* __IMFMediaSourceTopologyProvider_FWD_DEFINED__ */ + + +#ifndef __IMFMediaSourcePresentationProvider_FWD_DEFINED__ +#define __IMFMediaSourcePresentationProvider_FWD_DEFINED__ +typedef interface IMFMediaSourcePresentationProvider IMFMediaSourcePresentationProvider; + +#endif /* __IMFMediaSourcePresentationProvider_FWD_DEFINED__ */ + + +#ifndef __IMFTopologyNodeAttributeEditor_FWD_DEFINED__ +#define __IMFTopologyNodeAttributeEditor_FWD_DEFINED__ +typedef interface IMFTopologyNodeAttributeEditor IMFTopologyNodeAttributeEditor; + +#endif /* __IMFTopologyNodeAttributeEditor_FWD_DEFINED__ */ + + +#ifndef __IMFByteStreamBuffering_FWD_DEFINED__ +#define __IMFByteStreamBuffering_FWD_DEFINED__ +typedef interface IMFByteStreamBuffering IMFByteStreamBuffering; + +#endif /* __IMFByteStreamBuffering_FWD_DEFINED__ */ + + +#ifndef __IMFByteStreamCacheControl_FWD_DEFINED__ +#define __IMFByteStreamCacheControl_FWD_DEFINED__ +typedef interface IMFByteStreamCacheControl IMFByteStreamCacheControl; + +#endif /* __IMFByteStreamCacheControl_FWD_DEFINED__ */ + + +#ifndef __IMFByteStreamTimeSeek_FWD_DEFINED__ +#define __IMFByteStreamTimeSeek_FWD_DEFINED__ +typedef interface IMFByteStreamTimeSeek IMFByteStreamTimeSeek; + +#endif /* __IMFByteStreamTimeSeek_FWD_DEFINED__ */ + + +#ifndef __IMFByteStreamCacheControl2_FWD_DEFINED__ +#define __IMFByteStreamCacheControl2_FWD_DEFINED__ +typedef interface IMFByteStreamCacheControl2 IMFByteStreamCacheControl2; + +#endif /* __IMFByteStreamCacheControl2_FWD_DEFINED__ */ + + +#ifndef __IMFNetCredential_FWD_DEFINED__ +#define __IMFNetCredential_FWD_DEFINED__ +typedef interface IMFNetCredential IMFNetCredential; + +#endif /* __IMFNetCredential_FWD_DEFINED__ */ + + +#ifndef __IMFNetCredentialManager_FWD_DEFINED__ +#define __IMFNetCredentialManager_FWD_DEFINED__ +typedef interface IMFNetCredentialManager IMFNetCredentialManager; + +#endif /* __IMFNetCredentialManager_FWD_DEFINED__ */ + + +#ifndef __IMFNetCredentialCache_FWD_DEFINED__ +#define __IMFNetCredentialCache_FWD_DEFINED__ +typedef interface IMFNetCredentialCache IMFNetCredentialCache; + +#endif /* __IMFNetCredentialCache_FWD_DEFINED__ */ + + +#ifndef __IMFSSLCertificateManager_FWD_DEFINED__ +#define __IMFSSLCertificateManager_FWD_DEFINED__ +typedef interface IMFSSLCertificateManager IMFSSLCertificateManager; + +#endif /* __IMFSSLCertificateManager_FWD_DEFINED__ */ + + +#ifndef __IMFNetResourceFilter_FWD_DEFINED__ +#define __IMFNetResourceFilter_FWD_DEFINED__ +typedef interface IMFNetResourceFilter IMFNetResourceFilter; + +#endif /* __IMFNetResourceFilter_FWD_DEFINED__ */ + + +#ifndef __IMFSourceOpenMonitor_FWD_DEFINED__ +#define __IMFSourceOpenMonitor_FWD_DEFINED__ +typedef interface IMFSourceOpenMonitor IMFSourceOpenMonitor; + +#endif /* __IMFSourceOpenMonitor_FWD_DEFINED__ */ + + +#ifndef __IMFNetProxyLocator_FWD_DEFINED__ +#define __IMFNetProxyLocator_FWD_DEFINED__ +typedef interface IMFNetProxyLocator IMFNetProxyLocator; + +#endif /* __IMFNetProxyLocator_FWD_DEFINED__ */ + + +#ifndef __IMFNetProxyLocatorFactory_FWD_DEFINED__ +#define __IMFNetProxyLocatorFactory_FWD_DEFINED__ +typedef interface IMFNetProxyLocatorFactory IMFNetProxyLocatorFactory; + +#endif /* __IMFNetProxyLocatorFactory_FWD_DEFINED__ */ + + +#ifndef __IMFSaveJob_FWD_DEFINED__ +#define __IMFSaveJob_FWD_DEFINED__ +typedef interface IMFSaveJob IMFSaveJob; + +#endif /* __IMFSaveJob_FWD_DEFINED__ */ + + +#ifndef __IMFNetSchemeHandlerConfig_FWD_DEFINED__ +#define __IMFNetSchemeHandlerConfig_FWD_DEFINED__ +typedef interface IMFNetSchemeHandlerConfig IMFNetSchemeHandlerConfig; + +#endif /* __IMFNetSchemeHandlerConfig_FWD_DEFINED__ */ + + +#ifndef __IMFSchemeHandler_FWD_DEFINED__ +#define __IMFSchemeHandler_FWD_DEFINED__ +typedef interface IMFSchemeHandler IMFSchemeHandler; + +#endif /* __IMFSchemeHandler_FWD_DEFINED__ */ + + +#ifndef __IMFByteStreamHandler_FWD_DEFINED__ +#define __IMFByteStreamHandler_FWD_DEFINED__ +typedef interface IMFByteStreamHandler IMFByteStreamHandler; + +#endif /* __IMFByteStreamHandler_FWD_DEFINED__ */ + + +#ifndef __IMFTrustedInput_FWD_DEFINED__ +#define __IMFTrustedInput_FWD_DEFINED__ +typedef interface IMFTrustedInput IMFTrustedInput; + +#endif /* __IMFTrustedInput_FWD_DEFINED__ */ + + +#ifndef __IMFInputTrustAuthority_FWD_DEFINED__ +#define __IMFInputTrustAuthority_FWD_DEFINED__ +typedef interface IMFInputTrustAuthority IMFInputTrustAuthority; + +#endif /* __IMFInputTrustAuthority_FWD_DEFINED__ */ + + +#ifndef __IMFTrustedOutput_FWD_DEFINED__ +#define __IMFTrustedOutput_FWD_DEFINED__ +typedef interface IMFTrustedOutput IMFTrustedOutput; + +#endif /* __IMFTrustedOutput_FWD_DEFINED__ */ + + +#ifndef __IMFOutputTrustAuthority_FWD_DEFINED__ +#define __IMFOutputTrustAuthority_FWD_DEFINED__ +typedef interface IMFOutputTrustAuthority IMFOutputTrustAuthority; + +#endif /* __IMFOutputTrustAuthority_FWD_DEFINED__ */ + + +#ifndef __IMFOutputPolicy_FWD_DEFINED__ +#define __IMFOutputPolicy_FWD_DEFINED__ +typedef interface IMFOutputPolicy IMFOutputPolicy; + +#endif /* __IMFOutputPolicy_FWD_DEFINED__ */ + + +#ifndef __IMFOutputSchema_FWD_DEFINED__ +#define __IMFOutputSchema_FWD_DEFINED__ +typedef interface IMFOutputSchema IMFOutputSchema; + +#endif /* __IMFOutputSchema_FWD_DEFINED__ */ + + +#ifndef __IMFSecureChannel_FWD_DEFINED__ +#define __IMFSecureChannel_FWD_DEFINED__ +typedef interface IMFSecureChannel IMFSecureChannel; + +#endif /* __IMFSecureChannel_FWD_DEFINED__ */ + + +#ifndef __IMFSampleProtection_FWD_DEFINED__ +#define __IMFSampleProtection_FWD_DEFINED__ +typedef interface IMFSampleProtection IMFSampleProtection; + +#endif /* __IMFSampleProtection_FWD_DEFINED__ */ + + +#ifndef __IMFMediaSinkPreroll_FWD_DEFINED__ +#define __IMFMediaSinkPreroll_FWD_DEFINED__ +typedef interface IMFMediaSinkPreroll IMFMediaSinkPreroll; + +#endif /* __IMFMediaSinkPreroll_FWD_DEFINED__ */ + + +#ifndef __IMFFinalizableMediaSink_FWD_DEFINED__ +#define __IMFFinalizableMediaSink_FWD_DEFINED__ +typedef interface IMFFinalizableMediaSink IMFFinalizableMediaSink; + +#endif /* __IMFFinalizableMediaSink_FWD_DEFINED__ */ + + +#ifndef __IMFStreamingSinkConfig_FWD_DEFINED__ +#define __IMFStreamingSinkConfig_FWD_DEFINED__ +typedef interface IMFStreamingSinkConfig IMFStreamingSinkConfig; + +#endif /* __IMFStreamingSinkConfig_FWD_DEFINED__ */ + + +#ifndef __IMFRemoteProxy_FWD_DEFINED__ +#define __IMFRemoteProxy_FWD_DEFINED__ +typedef interface IMFRemoteProxy IMFRemoteProxy; + +#endif /* __IMFRemoteProxy_FWD_DEFINED__ */ + + +#ifndef __IMFObjectReferenceStream_FWD_DEFINED__ +#define __IMFObjectReferenceStream_FWD_DEFINED__ +typedef interface IMFObjectReferenceStream IMFObjectReferenceStream; + +#endif /* __IMFObjectReferenceStream_FWD_DEFINED__ */ + + +#ifndef __IMFPMPHost_FWD_DEFINED__ +#define __IMFPMPHost_FWD_DEFINED__ +typedef interface IMFPMPHost IMFPMPHost; + +#endif /* __IMFPMPHost_FWD_DEFINED__ */ + + +#ifndef __IMFPMPClient_FWD_DEFINED__ +#define __IMFPMPClient_FWD_DEFINED__ +typedef interface IMFPMPClient IMFPMPClient; + +#endif /* __IMFPMPClient_FWD_DEFINED__ */ + + +#ifndef __IMFPMPServer_FWD_DEFINED__ +#define __IMFPMPServer_FWD_DEFINED__ +typedef interface IMFPMPServer IMFPMPServer; + +#endif /* __IMFPMPServer_FWD_DEFINED__ */ + + +#ifndef __IMFRemoteDesktopPlugin_FWD_DEFINED__ +#define __IMFRemoteDesktopPlugin_FWD_DEFINED__ +typedef interface IMFRemoteDesktopPlugin IMFRemoteDesktopPlugin; + +#endif /* __IMFRemoteDesktopPlugin_FWD_DEFINED__ */ + + +#ifndef __IMFSAMIStyle_FWD_DEFINED__ +#define __IMFSAMIStyle_FWD_DEFINED__ +typedef interface IMFSAMIStyle IMFSAMIStyle; + +#endif /* __IMFSAMIStyle_FWD_DEFINED__ */ + + +#ifndef __IMFTranscodeProfile_FWD_DEFINED__ +#define __IMFTranscodeProfile_FWD_DEFINED__ +typedef interface IMFTranscodeProfile IMFTranscodeProfile; + +#endif /* __IMFTranscodeProfile_FWD_DEFINED__ */ + + +#ifndef __IMFTranscodeSinkInfoProvider_FWD_DEFINED__ +#define __IMFTranscodeSinkInfoProvider_FWD_DEFINED__ +typedef interface IMFTranscodeSinkInfoProvider IMFTranscodeSinkInfoProvider; + +#endif /* __IMFTranscodeSinkInfoProvider_FWD_DEFINED__ */ + + +#ifndef __IMFFieldOfUseMFTUnlock_FWD_DEFINED__ +#define __IMFFieldOfUseMFTUnlock_FWD_DEFINED__ +typedef interface IMFFieldOfUseMFTUnlock IMFFieldOfUseMFTUnlock; + +#endif /* __IMFFieldOfUseMFTUnlock_FWD_DEFINED__ */ + + +#ifndef __IMFLocalMFTRegistration_FWD_DEFINED__ +#define __IMFLocalMFTRegistration_FWD_DEFINED__ +typedef interface IMFLocalMFTRegistration IMFLocalMFTRegistration; + +#endif /* __IMFLocalMFTRegistration_FWD_DEFINED__ */ + + +#ifndef __IMFCapturePhotoConfirmation_FWD_DEFINED__ +#define __IMFCapturePhotoConfirmation_FWD_DEFINED__ +typedef interface IMFCapturePhotoConfirmation IMFCapturePhotoConfirmation; + +#endif /* __IMFCapturePhotoConfirmation_FWD_DEFINED__ */ + + +#ifndef __IMFPMPHostApp_FWD_DEFINED__ +#define __IMFPMPHostApp_FWD_DEFINED__ +typedef interface IMFPMPHostApp IMFPMPHostApp; + +#endif /* __IMFPMPHostApp_FWD_DEFINED__ */ + + +#ifndef __IMFPMPClientApp_FWD_DEFINED__ +#define __IMFPMPClientApp_FWD_DEFINED__ +typedef interface IMFPMPClientApp IMFPMPClientApp; + +#endif /* __IMFPMPClientApp_FWD_DEFINED__ */ + + +#ifndef __IMFMediaStreamSourceSampleRequest_FWD_DEFINED__ +#define __IMFMediaStreamSourceSampleRequest_FWD_DEFINED__ +typedef interface IMFMediaStreamSourceSampleRequest IMFMediaStreamSourceSampleRequest; + +#endif /* __IMFMediaStreamSourceSampleRequest_FWD_DEFINED__ */ + + +#ifndef __IMFTrackedSample_FWD_DEFINED__ +#define __IMFTrackedSample_FWD_DEFINED__ +typedef interface IMFTrackedSample IMFTrackedSample; + +#endif /* __IMFTrackedSample_FWD_DEFINED__ */ + + +#ifndef __IMFProtectedEnvironmentAccess_FWD_DEFINED__ +#define __IMFProtectedEnvironmentAccess_FWD_DEFINED__ +typedef interface IMFProtectedEnvironmentAccess IMFProtectedEnvironmentAccess; + +#endif /* __IMFProtectedEnvironmentAccess_FWD_DEFINED__ */ + + +#ifndef __IMFSignedLibrary_FWD_DEFINED__ +#define __IMFSignedLibrary_FWD_DEFINED__ +typedef interface IMFSignedLibrary IMFSignedLibrary; + +#endif /* __IMFSignedLibrary_FWD_DEFINED__ */ + + +#ifndef __IMFSystemId_FWD_DEFINED__ +#define __IMFSystemId_FWD_DEFINED__ +typedef interface IMFSystemId IMFSystemId; + +#endif /* __IMFSystemId_FWD_DEFINED__ */ + + +#ifndef __IMFContentProtectionDevice_FWD_DEFINED__ +#define __IMFContentProtectionDevice_FWD_DEFINED__ +typedef interface IMFContentProtectionDevice IMFContentProtectionDevice; + +#endif /* __IMFContentProtectionDevice_FWD_DEFINED__ */ + + +#ifndef __IMFContentDecryptorContext_FWD_DEFINED__ +#define __IMFContentDecryptorContext_FWD_DEFINED__ +typedef interface IMFContentDecryptorContext IMFContentDecryptorContext; + +#endif /* __IMFContentDecryptorContext_FWD_DEFINED__ */ + + +#ifndef __IMFNetCrossOriginSupport_FWD_DEFINED__ +#define __IMFNetCrossOriginSupport_FWD_DEFINED__ +typedef interface IMFNetCrossOriginSupport IMFNetCrossOriginSupport; + +#endif /* __IMFNetCrossOriginSupport_FWD_DEFINED__ */ + + +#ifndef __IMFHttpDownloadRequest_FWD_DEFINED__ +#define __IMFHttpDownloadRequest_FWD_DEFINED__ +typedef interface IMFHttpDownloadRequest IMFHttpDownloadRequest; + +#endif /* __IMFHttpDownloadRequest_FWD_DEFINED__ */ + + +#ifndef __IMFHttpDownloadSession_FWD_DEFINED__ +#define __IMFHttpDownloadSession_FWD_DEFINED__ +typedef interface IMFHttpDownloadSession IMFHttpDownloadSession; + +#endif /* __IMFHttpDownloadSession_FWD_DEFINED__ */ + + +#ifndef __IMFHttpDownloadSessionProvider_FWD_DEFINED__ +#define __IMFHttpDownloadSessionProvider_FWD_DEFINED__ +typedef interface IMFHttpDownloadSessionProvider IMFHttpDownloadSessionProvider; + +#endif /* __IMFHttpDownloadSessionProvider_FWD_DEFINED__ */ + + +#ifndef __IMFMediaSource2_FWD_DEFINED__ +#define __IMFMediaSource2_FWD_DEFINED__ +typedef interface IMFMediaSource2 IMFMediaSource2; + +#endif /* __IMFMediaSource2_FWD_DEFINED__ */ + + +#ifndef __IMFMediaStream2_FWD_DEFINED__ +#define __IMFMediaStream2_FWD_DEFINED__ +typedef interface IMFMediaStream2 IMFMediaStream2; + +#endif /* __IMFMediaStream2_FWD_DEFINED__ */ + + +#ifndef __IMFSensorDevice_FWD_DEFINED__ +#define __IMFSensorDevice_FWD_DEFINED__ +typedef interface IMFSensorDevice IMFSensorDevice; + +#endif /* __IMFSensorDevice_FWD_DEFINED__ */ + + +#ifndef __IMFSensorGroup_FWD_DEFINED__ +#define __IMFSensorGroup_FWD_DEFINED__ +typedef interface IMFSensorGroup IMFSensorGroup; + +#endif /* __IMFSensorGroup_FWD_DEFINED__ */ + + +#ifndef __IMFSensorStream_FWD_DEFINED__ +#define __IMFSensorStream_FWD_DEFINED__ +typedef interface IMFSensorStream IMFSensorStream; + +#endif /* __IMFSensorStream_FWD_DEFINED__ */ + + +#ifndef __IMFSensorTransformFactory_FWD_DEFINED__ +#define __IMFSensorTransformFactory_FWD_DEFINED__ +typedef interface IMFSensorTransformFactory IMFSensorTransformFactory; + +#endif /* __IMFSensorTransformFactory_FWD_DEFINED__ */ + + +#ifndef __IMFSensorProfile_FWD_DEFINED__ +#define __IMFSensorProfile_FWD_DEFINED__ +typedef interface IMFSensorProfile IMFSensorProfile; + +#endif /* __IMFSensorProfile_FWD_DEFINED__ */ + + +#ifndef __IMFSensorProfileCollection_FWD_DEFINED__ +#define __IMFSensorProfileCollection_FWD_DEFINED__ +typedef interface IMFSensorProfileCollection IMFSensorProfileCollection; + +#endif /* __IMFSensorProfileCollection_FWD_DEFINED__ */ + + +#ifndef __IMFSensorProcessActivity_FWD_DEFINED__ +#define __IMFSensorProcessActivity_FWD_DEFINED__ +typedef interface IMFSensorProcessActivity IMFSensorProcessActivity; + +#endif /* __IMFSensorProcessActivity_FWD_DEFINED__ */ + + +#ifndef __IMFSensorActivityReport_FWD_DEFINED__ +#define __IMFSensorActivityReport_FWD_DEFINED__ +typedef interface IMFSensorActivityReport IMFSensorActivityReport; + +#endif /* __IMFSensorActivityReport_FWD_DEFINED__ */ + + +#ifndef __IMFSensorActivitiesReport_FWD_DEFINED__ +#define __IMFSensorActivitiesReport_FWD_DEFINED__ +typedef interface IMFSensorActivitiesReport IMFSensorActivitiesReport; + +#endif /* __IMFSensorActivitiesReport_FWD_DEFINED__ */ + + +#ifndef __IMFSensorActivitiesReportCallback_FWD_DEFINED__ +#define __IMFSensorActivitiesReportCallback_FWD_DEFINED__ +typedef interface IMFSensorActivitiesReportCallback IMFSensorActivitiesReportCallback; + +#endif /* __IMFSensorActivitiesReportCallback_FWD_DEFINED__ */ + + +#ifndef __IMFSensorActivityMonitor_FWD_DEFINED__ +#define __IMFSensorActivityMonitor_FWD_DEFINED__ +typedef interface IMFSensorActivityMonitor IMFSensorActivityMonitor; + +#endif /* __IMFSensorActivityMonitor_FWD_DEFINED__ */ + + +#ifndef __IMFExtendedCameraIntrinsicModel_FWD_DEFINED__ +#define __IMFExtendedCameraIntrinsicModel_FWD_DEFINED__ +typedef interface IMFExtendedCameraIntrinsicModel IMFExtendedCameraIntrinsicModel; + +#endif /* __IMFExtendedCameraIntrinsicModel_FWD_DEFINED__ */ + + +#ifndef __IMFExtendedCameraIntrinsicsDistortionModel6KT_FWD_DEFINED__ +#define __IMFExtendedCameraIntrinsicsDistortionModel6KT_FWD_DEFINED__ +typedef interface IMFExtendedCameraIntrinsicsDistortionModel6KT IMFExtendedCameraIntrinsicsDistortionModel6KT; + +#endif /* __IMFExtendedCameraIntrinsicsDistortionModel6KT_FWD_DEFINED__ */ + + +#ifndef __IMFExtendedCameraIntrinsicsDistortionModelArcTan_FWD_DEFINED__ +#define __IMFExtendedCameraIntrinsicsDistortionModelArcTan_FWD_DEFINED__ +typedef interface IMFExtendedCameraIntrinsicsDistortionModelArcTan IMFExtendedCameraIntrinsicsDistortionModelArcTan; + +#endif /* __IMFExtendedCameraIntrinsicsDistortionModelArcTan_FWD_DEFINED__ */ + + +#ifndef __IMFExtendedCameraIntrinsics_FWD_DEFINED__ +#define __IMFExtendedCameraIntrinsics_FWD_DEFINED__ +typedef interface IMFExtendedCameraIntrinsics IMFExtendedCameraIntrinsics; + +#endif /* __IMFExtendedCameraIntrinsics_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "mfobjects.h" +#include "mftransform.h" + +#ifdef __cplusplus +extern "C"{ +#endif + + +/* interface __MIDL_itf_mfidl_0000_0000 */ +/* [local] */ + +#include "winapifamily.h" +//#include +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +typedef +enum MFSESSION_SETTOPOLOGY_FLAGS + { + MFSESSION_SETTOPOLOGY_IMMEDIATE = 0x1, + MFSESSION_SETTOPOLOGY_NORESOLUTION = 0x2, + MFSESSION_SETTOPOLOGY_CLEAR_CURRENT = 0x4 + } MFSESSION_SETTOPOLOGY_FLAGS; + +typedef +enum MFSESSION_GETFULLTOPOLOGY_FLAGS + { + MFSESSION_GETFULLTOPOLOGY_CURRENT = 0x1 + } MFSESSION_GETFULLTOPOLOGY_FLAGS; + +typedef +enum MFPMPSESSION_CREATION_FLAGS + { + MFPMPSESSION_UNPROTECTED_PROCESS = 0x1, + MFPMPSESSION_IN_PROCESS = 0x2 + } MFPMPSESSION_CREATION_FLAGS; + +typedef unsigned __int64 TOPOID; + + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +EXTERN_GUID( MF_WVC1_PROG_SINGLE_SLICE_CONTENT, 0x67EC2559, 0x0F2F, 0x4420, 0xA4, 0xDD, 0x2F, 0x8E, 0xE7, 0xA5, 0x73, 0x8B); +EXTERN_GUID( MF_PROGRESSIVE_CODING_CONTENT, 0x8F020EEA, 0x1508, 0x471F, 0x9D, 0xA6, 0x50, 0x7D, 0x7C, 0xFA, 0x40, 0xDB); +EXTERN_GUID( MF_NALU_LENGTH_SET, 0xA7911D53, 0x12A4, 0x4965, 0xAE, 0x70, 0x6E, 0xAD, 0xD6, 0xFF, 0x05, 0x51); +EXTERN_GUID( MF_NALU_LENGTH_INFORMATION, 0x19124E7C, 0xAD4B, 0x465F, 0xBB, 0x18, 0x20, 0x18, 0x62, 0x87, 0xB6, 0xAF); +EXTERN_GUID( MF_USER_DATA_PAYLOAD, 0xd1d4985d, 0xdc92, 0x457a, 0xb3, 0xa0, 0x65, 0x1a, 0x33, 0xa3, 0x10, 0x47); +EXTERN_GUID( MF_MPEG4SINK_SPSPPS_PASSTHROUGH, 0x5601a134, 0x2005, 0x4ad2, 0xb3, 0x7d, 0x22, 0xa6, 0xc5, 0x54, 0xde, 0xb2); +EXTERN_GUID( MF_MPEG4SINK_MOOV_BEFORE_MDAT, 0xf672e3ac, 0xe1e6, 0x4f10, 0xb5, 0xec, 0x5f, 0x3b, 0x30, 0x82, 0x88, 0x16); +EXTERN_GUID( MF_MPEG4SINK_MINIMUM_PROPERTIES_SIZE, 0xdca1ed52, 0x450e, 0x4a22, 0x8c, 0x62, 0x4e, 0xd4, 0x52, 0xf7, 0xa1, 0x87); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0000_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0000_v0_0_s_ifspec; + +#ifndef __IMFMediaSession_INTERFACE_DEFINED__ +#define __IMFMediaSession_INTERFACE_DEFINED__ + +/* interface IMFMediaSession */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaSession; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("90377834-21D0-4dee-8214-BA2E3E6C1127") + IMFMediaSession : public IMFMediaEventGenerator + { + public: + virtual HRESULT STDMETHODCALLTYPE SetTopology( + /* [in] */ DWORD dwSetTopologyFlags, + /* [in] */ __RPC__in_opt IMFTopology *pTopology) = 0; + + virtual HRESULT STDMETHODCALLTYPE ClearTopologies( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Start( + /* [unique][in] */ __RPC__in_opt const GUID *pguidTimeFormat, + /* [unique][in] */ __RPC__in_opt const PROPVARIANT *pvarStartPosition) = 0; + + virtual HRESULT STDMETHODCALLTYPE Pause( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Stop( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Shutdown( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetClock( + /* [out] */ __RPC__deref_out_opt IMFClock **ppClock) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSessionCapabilities( + /* [out] */ __RPC__out DWORD *pdwCaps) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFullTopology( + /* [in] */ DWORD dwGetFullTopologyFlags, + /* [in] */ TOPOID TopoId, + /* [out] */ __RPC__deref_out_opt IMFTopology **ppFullTopology) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaSessionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaSession * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaSession * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaSession * This); + + HRESULT ( STDMETHODCALLTYPE *GetEvent )( + __RPC__in IMFMediaSession * This, + /* [in] */ DWORD dwFlags, + /* [out] */ __RPC__deref_out_opt IMFMediaEvent **ppEvent); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginGetEvent )( + IMFMediaSession * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndGetEvent )( + IMFMediaSession * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent); + + HRESULT ( STDMETHODCALLTYPE *QueueEvent )( + __RPC__in IMFMediaSession * This, + /* [in] */ MediaEventType met, + /* [in] */ __RPC__in REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ __RPC__in_opt const PROPVARIANT *pvValue); + + HRESULT ( STDMETHODCALLTYPE *SetTopology )( + __RPC__in IMFMediaSession * This, + /* [in] */ DWORD dwSetTopologyFlags, + /* [in] */ __RPC__in_opt IMFTopology *pTopology); + + HRESULT ( STDMETHODCALLTYPE *ClearTopologies )( + __RPC__in IMFMediaSession * This); + + HRESULT ( STDMETHODCALLTYPE *Start )( + __RPC__in IMFMediaSession * This, + /* [unique][in] */ __RPC__in_opt const GUID *pguidTimeFormat, + /* [unique][in] */ __RPC__in_opt const PROPVARIANT *pvarStartPosition); + + HRESULT ( STDMETHODCALLTYPE *Pause )( + __RPC__in IMFMediaSession * This); + + HRESULT ( STDMETHODCALLTYPE *Stop )( + __RPC__in IMFMediaSession * This); + + HRESULT ( STDMETHODCALLTYPE *Close )( + __RPC__in IMFMediaSession * This); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + __RPC__in IMFMediaSession * This); + + HRESULT ( STDMETHODCALLTYPE *GetClock )( + __RPC__in IMFMediaSession * This, + /* [out] */ __RPC__deref_out_opt IMFClock **ppClock); + + HRESULT ( STDMETHODCALLTYPE *GetSessionCapabilities )( + __RPC__in IMFMediaSession * This, + /* [out] */ __RPC__out DWORD *pdwCaps); + + HRESULT ( STDMETHODCALLTYPE *GetFullTopology )( + __RPC__in IMFMediaSession * This, + /* [in] */ DWORD dwGetFullTopologyFlags, + /* [in] */ TOPOID TopoId, + /* [out] */ __RPC__deref_out_opt IMFTopology **ppFullTopology); + + END_INTERFACE + } IMFMediaSessionVtbl; + + interface IMFMediaSession + { + CONST_VTBL struct IMFMediaSessionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaSession_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaSession_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaSession_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaSession_GetEvent(This,dwFlags,ppEvent) \ + ( (This)->lpVtbl -> GetEvent(This,dwFlags,ppEvent) ) + +#define IMFMediaSession_BeginGetEvent(This,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginGetEvent(This,pCallback,punkState) ) + +#define IMFMediaSession_EndGetEvent(This,pResult,ppEvent) \ + ( (This)->lpVtbl -> EndGetEvent(This,pResult,ppEvent) ) + +#define IMFMediaSession_QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) \ + ( (This)->lpVtbl -> QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) ) + + +#define IMFMediaSession_SetTopology(This,dwSetTopologyFlags,pTopology) \ + ( (This)->lpVtbl -> SetTopology(This,dwSetTopologyFlags,pTopology) ) + +#define IMFMediaSession_ClearTopologies(This) \ + ( (This)->lpVtbl -> ClearTopologies(This) ) + +#define IMFMediaSession_Start(This,pguidTimeFormat,pvarStartPosition) \ + ( (This)->lpVtbl -> Start(This,pguidTimeFormat,pvarStartPosition) ) + +#define IMFMediaSession_Pause(This) \ + ( (This)->lpVtbl -> Pause(This) ) + +#define IMFMediaSession_Stop(This) \ + ( (This)->lpVtbl -> Stop(This) ) + +#define IMFMediaSession_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#define IMFMediaSession_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + +#define IMFMediaSession_GetClock(This,ppClock) \ + ( (This)->lpVtbl -> GetClock(This,ppClock) ) + +#define IMFMediaSession_GetSessionCapabilities(This,pdwCaps) \ + ( (This)->lpVtbl -> GetSessionCapabilities(This,pdwCaps) ) + +#define IMFMediaSession_GetFullTopology(This,dwGetFullTopologyFlags,TopoId,ppFullTopology) \ + ( (This)->lpVtbl -> GetFullTopology(This,dwGetFullTopologyFlags,TopoId,ppFullTopology) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaSession_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0001 */ +/* [local] */ + +EXTERN_GUID( MF_SESSION_TOPOLOADER, 0x1e83d482, 0x1f1c, 0x4571, 0x84, 0x5, 0x88, 0xf4, 0xb2, 0x18, 0x1f, 0x71); +EXTERN_GUID( MF_SESSION_GLOBAL_TIME, 0x1e83d482, 0x1f1c, 0x4571, 0x84, 0x5, 0x88, 0xf4, 0xb2, 0x18, 0x1f, 0x72); +EXTERN_GUID( MF_SESSION_QUALITY_MANAGER, 0x1e83d482, 0x1f1c, 0x4571, 0x84, 0x5, 0x88, 0xf4, 0xb2, 0x18, 0x1f, 0x73); +EXTERN_GUID( MF_SESSION_CONTENT_PROTECTION_MANAGER, 0x1e83d482, 0x1f1c, 0x4571, 0x84, 0x5, 0x88, 0xf4, 0xb2, 0x18, 0x1f, 0x74); +EXTERN_GUID( MF_SESSION_SERVER_CONTEXT, 0xafe5b291, 0x50fa, 0x46e8, 0xb9, 0xbe, 0xc, 0xc, 0x3c, 0xe4, 0xb3, 0xa5); +EXTERN_GUID( MF_SESSION_REMOTE_SOURCE_MODE, 0xf4033ef4, 0x9bb3, 0x4378, 0x94, 0x1f, 0x85, 0xa0, 0x85, 0x6b, 0xc2, 0x44); +EXTERN_GUID( MF_SESSION_APPROX_EVENT_OCCURRENCE_TIME, 0x190e852f, 0x6238, 0x42d1, 0xb5, 0xaf, 0x69, 0xea, 0x33, 0x8e, 0xf8, 0x50); +EXTERN_GUID( MF_PMP_SERVER_CONTEXT, 0x2f00c910, 0xd2cf, 0x4278, 0x8b, 0x6a, 0xd0, 0x77, 0xfa, 0xc3, 0xa2, 0x5f); +STDAPI MFCreateMediaSession( + IMFAttributes* pConfiguration, + _Outptr_ IMFMediaSession** ppMediaSession + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region PC Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP) +STDAPI MFCreatePMPMediaSession( + DWORD dwCreationFlags, + IMFAttributes *pConfiguration, + _Outptr_ IMFMediaSession** ppMediaSession, + _Outptr_opt_ IMFActivate **ppEnablerActivate + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef +enum MF_OBJECT_TYPE + { + MF_OBJECT_MEDIASOURCE = 0, + MF_OBJECT_BYTESTREAM = ( MF_OBJECT_MEDIASOURCE + 1 ) , + MF_OBJECT_INVALID = ( MF_OBJECT_BYTESTREAM + 1 ) + } MF_OBJECT_TYPE; + + +enum __MIDL___MIDL_itf_mfidl_0000_0001_0001 + { + MF_RESOLUTION_MEDIASOURCE = 0x1, + MF_RESOLUTION_BYTESTREAM = 0x2, + MF_RESOLUTION_CONTENT_DOES_NOT_HAVE_TO_MATCH_EXTENSION_OR_MIME_TYPE = 0x10, + MF_RESOLUTION_KEEP_BYTE_STREAM_ALIVE_ON_FAIL = 0x20, + MF_RESOLUTION_DISABLE_LOCAL_PLUGINS = 0x40, + MF_RESOLUTION_PLUGIN_CONTROL_POLICY_APPROVED_ONLY = 0x80, + MF_RESOLUTION_PLUGIN_CONTROL_POLICY_WEB_ONLY = 0x100, + MF_RESOLUTION_PLUGIN_CONTROL_POLICY_WEB_ONLY_EDGEMODE = 0x200, + MF_RESOLUTION_ENABLE_STORE_PLUGINS = 0x400, + MF_RESOLUTION_READ = 0x10000, + MF_RESOLUTION_WRITE = 0x20000 + } ; +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +typedef +enum _MF_CONNECT_METHOD + { + MF_CONNECT_DIRECT = 0, + MF_CONNECT_ALLOW_CONVERTER = 0x1, + MF_CONNECT_ALLOW_DECODER = 0x3, + MF_CONNECT_RESOLVE_INDEPENDENT_OUTPUTTYPES = 0x4, + MF_CONNECT_AS_OPTIONAL = 0x10000, + MF_CONNECT_AS_OPTIONAL_BRANCH = 0x20000 + } MF_CONNECT_METHOD; + +typedef +enum _MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS + { + MF_TOPOLOGY_RESOLUTION_SUCCEEDED = 0, + MF_OPTIONAL_NODE_REJECTED_MEDIA_TYPE = 0x1, + MF_OPTIONAL_NODE_REJECTED_PROTECTED_PROCESS = 0x2 + } MF_TOPOLOGY_RESOLUTION_STATUS_FLAGS; + + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0001_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0001_v0_0_s_ifspec; + +#ifndef __IMFSourceResolver_INTERFACE_DEFINED__ +#define __IMFSourceResolver_INTERFACE_DEFINED__ + +/* interface IMFSourceResolver */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFSourceResolver; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("FBE5A32D-A497-4b61-BB85-97B1A848A6E3") + IMFSourceResolver : public IUnknown + { + public: + virtual /* [local] */ HRESULT STDMETHODCALLTYPE CreateObjectFromURL( + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE CreateObjectFromByteStream( + /* [in] */ IMFByteStream *pByteStream, + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE BeginCreateObjectFromURL( + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Outptr_opt_ IUnknown **ppIUnknownCancelCookie, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE EndCreateObjectFromURL( + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE BeginCreateObjectFromByteStream( + /* [in] */ IMFByteStream *pByteStream, + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Outptr_opt_ IUnknown **ppIUnknownCancelCookie, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE EndCreateObjectFromByteStream( + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE CancelObjectCreation( + /* [in] */ IUnknown *pIUnknownCancelCookie) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSourceResolverVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFSourceResolver * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFSourceResolver * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFSourceResolver * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *CreateObjectFromURL )( + IMFSourceResolver * This, + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *CreateObjectFromByteStream )( + IMFSourceResolver * This, + /* [in] */ IMFByteStream *pByteStream, + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginCreateObjectFromURL )( + IMFSourceResolver * This, + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Outptr_opt_ IUnknown **ppIUnknownCancelCookie, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndCreateObjectFromURL )( + IMFSourceResolver * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginCreateObjectFromByteStream )( + IMFSourceResolver * This, + /* [in] */ IMFByteStream *pByteStream, + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Outptr_opt_ IUnknown **ppIUnknownCancelCookie, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndCreateObjectFromByteStream )( + IMFSourceResolver * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *CancelObjectCreation )( + IMFSourceResolver * This, + /* [in] */ IUnknown *pIUnknownCancelCookie); + + END_INTERFACE + } IMFSourceResolverVtbl; + + interface IMFSourceResolver + { + CONST_VTBL struct IMFSourceResolverVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSourceResolver_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSourceResolver_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSourceResolver_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSourceResolver_CreateObjectFromURL(This,pwszURL,dwFlags,pProps,pObjectType,ppObject) \ + ( (This)->lpVtbl -> CreateObjectFromURL(This,pwszURL,dwFlags,pProps,pObjectType,ppObject) ) + +#define IMFSourceResolver_CreateObjectFromByteStream(This,pByteStream,pwszURL,dwFlags,pProps,pObjectType,ppObject) \ + ( (This)->lpVtbl -> CreateObjectFromByteStream(This,pByteStream,pwszURL,dwFlags,pProps,pObjectType,ppObject) ) + +#define IMFSourceResolver_BeginCreateObjectFromURL(This,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginCreateObjectFromURL(This,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState) ) + +#define IMFSourceResolver_EndCreateObjectFromURL(This,pResult,pObjectType,ppObject) \ + ( (This)->lpVtbl -> EndCreateObjectFromURL(This,pResult,pObjectType,ppObject) ) + +#define IMFSourceResolver_BeginCreateObjectFromByteStream(This,pByteStream,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginCreateObjectFromByteStream(This,pByteStream,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState) ) + +#define IMFSourceResolver_EndCreateObjectFromByteStream(This,pResult,pObjectType,ppObject) \ + ( (This)->lpVtbl -> EndCreateObjectFromByteStream(This,pResult,pObjectType,ppObject) ) + +#define IMFSourceResolver_CancelObjectCreation(This,pIUnknownCancelCookie) \ + ( (This)->lpVtbl -> CancelObjectCreation(This,pIUnknownCancelCookie) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFSourceResolver_RemoteBeginCreateObjectFromURL_Proxy( + __RPC__in IMFSourceResolver * This, + /* [string][in] */ __RPC__in_string LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ __RPC__in_opt IPropertyStore *pProps, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + + +void __RPC_STUB IMFSourceResolver_RemoteBeginCreateObjectFromURL_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFSourceResolver_RemoteEndCreateObjectFromURL_Proxy( + __RPC__in IMFSourceResolver * This, + /* [in] */ __RPC__in_opt IUnknown *pResult, + /* [out] */ __RPC__out MF_OBJECT_TYPE *pObjectType, + /* [out] */ __RPC__deref_out_opt IUnknown **ppObject); + + +void __RPC_STUB IMFSourceResolver_RemoteEndCreateObjectFromURL_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFSourceResolver_RemoteBeginCreateObjectFromByteStream_Proxy( + __RPC__in IMFSourceResolver * This, + /* [in] */ __RPC__in_opt IMFByteStream *pByteStream, + /* [unique][in] */ __RPC__in_opt LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [unique][in] */ __RPC__in_opt IPropertyStore *pProps, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + + +void __RPC_STUB IMFSourceResolver_RemoteBeginCreateObjectFromByteStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFSourceResolver_RemoteEndCreateObjectFromByteStream_Proxy( + __RPC__in IMFSourceResolver * This, + /* [in] */ __RPC__in_opt IUnknown *pResult, + /* [out] */ __RPC__out MF_OBJECT_TYPE *pObjectType, + /* [out] */ __RPC__deref_out_opt IUnknown **ppObject); + + +void __RPC_STUB IMFSourceResolver_RemoteEndCreateObjectFromByteStream_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMFSourceResolver_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0002 */ +/* [local] */ + +STDAPI MFCreateSourceResolver( + /* out */ _Outptr_ IMFSourceResolver **ppISourceResolver); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +STDAPI CreatePropertyStore( + /* out */ _Outptr_ IPropertyStore **ppStore); +STDAPI MFGetSupportedSchemes( + _Out_ PROPVARIANT* pPropVarSchemeArray ); +STDAPI MFGetSupportedMimeTypes( + _Out_ PROPVARIANT* pPropVarMimeTypeArray ); +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_SourceOpenMonitor = { { 0x074d4637, 0xb5ae, 0x465d, 0xaf, 0x17, 0x1a, 0x53, 0x8d, 0x28, 0x59, 0xdd}, 0x02 }; +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_ASFMediaSource_ApproxSeek = { { 0xb4cd270f, 0x244d, 0x4969, 0xbb, 0x92, 0x3f, 0x0f, 0xb8, 0x31, 0x6f, 0x10}, 0x01 }; +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_ASFMediaSource_IterativeSeekIfNoIndex = { { 0x170b65dc, 0x4a4e, 0x407a, 0xac, 0x22, 0x57, 0x7f, 0x50, 0xe4, 0xa3, 0x7c }, 0x01 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_ASFMediaSource_IterativeSeek_Max_Count = { { 0x170b65dc, 0x4a4e, 0x407a, 0xac, 0x22, 0x57, 0x7f, 0x50, 0xe4, 0xa3, 0x7c }, 0x02 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_ASFMediaSource_IterativeSeek_Tolerance_In_MilliSecond = { { 0x170b65dc, 0x4a4e, 0x407a, 0xac, 0x22, 0x57, 0x7f, 0x50, 0xe4, 0xa3, 0x7c }, 0x03 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_Content_DLNA_Profile_ID = { { 0xcfa31b45, 0x525d, 0x4998, 0xbb, 0x44, 0x3f, 0x7d, 0x81, 0x54, 0x2f, 0xa4 }, 0x01 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_MediaSource_DisableReadAhead = { { 0x26366c14, 0xc5bf, 0x4c76, 0x88, 0x7b, 0x9f, 0x17, 0x54, 0xdb, 0x5f, 0x9}, 0x01 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_SBESourceMode = { { 0x3fae10bb, 0xf859, 0x4192, 0xb5, 0x62, 0x18, 0x68, 0xd3, 0xda, 0x3a, 0x02}, 0x01 }; +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#if (WINVER >= _WIN32_WINNT_WIN8) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_PMP_Creation_Callback = { { 0x28bb4de2, 0x26a2, 0x4870, 0xb7, 0x20, 0xd2, 0x6b, 0xbe, 0xb1, 0x49, 0x42}, 0x01 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_HTTP_ByteStream_Enable_Urlmon = { { 0xeda8afdf, 0xc171, 0x417f, 0x8d, 0x17, 0x2e, 0x09, 0x18, 0x30, 0x32, 0x92}, 0x01 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_HTTP_ByteStream_Urlmon_Bind_Flags = { { 0xeda8afdf, 0xc171, 0x417f, 0x8d, 0x17, 0x2e, 0x09, 0x18, 0x30, 0x32, 0x92}, 0x02 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_HTTP_ByteStream_Urlmon_Security_Id = { { 0xeda8afdf, 0xc171, 0x417f, 0x8d, 0x17, 0x2e, 0x09, 0x18, 0x30, 0x32, 0x92}, 0x03 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_HTTP_ByteStream_Urlmon_Window = { { 0xeda8afdf, 0xc171, 0x417f, 0x8d, 0x17, 0x2e, 0x09, 0x18, 0x30, 0x32, 0x92}, 0x04 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_HTTP_ByteStream_Urlmon_Callback_QueryService = { { 0xeda8afdf, 0xc171, 0x417f, 0x8d, 0x17, 0x2e, 0x09, 0x18, 0x30, 0x32, 0x92}, 0x05 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_MediaProtectionSystemId = { { 0x636b271d, 0xddc7, 0x49e9, 0xa6, 0xc6, 0x47, 0x38, 0x59, 0x62, 0xe5, 0xbd}, 0x01 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_MediaProtectionSystemContext = { { 0x636b271d, 0xddc7, 0x49e9, 0xa6, 0xc6, 0x47, 0x38, 0x59, 0x62, 0xe5, 0xbd}, 0x02 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_MediaProtectionSystemIdMapping = { { 0x636b271d, 0xddc7, 0x49e9, 0xa6, 0xc6, 0x47, 0x38, 0x59, 0x62, 0xe5, 0xbd}, 0x03 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_MediaProtectionContainerGuid = { { 0x42af3d7c, 0xcf, 0x4a0f, 0x81, 0xf0, 0xad, 0xf5, 0x24, 0xa5, 0xa5, 0xb5}, 0x1 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_MediaProtectionSystemContextsPerTrack = { { 0x4454b092, 0xd3da, 0x49b0, 0x84, 0x52, 0x68, 0x50, 0xc7, 0xdb, 0x76, 0x4d }, 0x03 }; +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_HTTP_ByteStream_Download_Mode = { { 0x817f11b7, 0xa982, 0x46ec, 0xa4, 0x49, 0xef, 0x58, 0xae, 0xd5, 0x3c, 0xa8 }, 0x01 }; +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_HTTP_ByteStream_Caching_Mode = { { 0x86a2403e, 0xc78b, 0x44d7, 0x8b, 0xc8, 0xff, 0x72, 0x58, 0x11, 0x75, 0x08}, 0x01 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_HTTP_ByteStream_Cache_Limit = { { 0x86a2403e, 0xc78b, 0x44d7, 0x8b, 0xc8, 0xff, 0x72, 0x58, 0x11, 0x75, 0x08}, 0x02 }; +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef +enum _MFMEDIASOURCE_CHARACTERISTICS + { + MFMEDIASOURCE_IS_LIVE = 0x1, + MFMEDIASOURCE_CAN_SEEK = 0x2, + MFMEDIASOURCE_CAN_PAUSE = 0x4, + MFMEDIASOURCE_HAS_SLOW_SEEK = 0x8, + MFMEDIASOURCE_HAS_MULTIPLE_PRESENTATIONS = 0x10, + MFMEDIASOURCE_CAN_SKIPFORWARD = 0x20, + MFMEDIASOURCE_CAN_SKIPBACKWARD = 0x40, + MFMEDIASOURCE_DOES_NOT_USE_NETWORK = 0x80 + } MFMEDIASOURCE_CHARACTERISTICS; + +#if (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_GUID( MF_TIME_FORMAT_ENTRY_RELATIVE, 0x4399f178, 0x46d3, 0x4504, 0xaf, 0xda, 0x20, 0xd3, 0x2e, 0x9b, 0xa3, 0x60 ); +#endif // (WINVER >= _WIN32_WINNT_WIN7) + + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0002_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0002_v0_0_s_ifspec; + +#ifndef __IMFMediaSource_INTERFACE_DEFINED__ +#define __IMFMediaSource_INTERFACE_DEFINED__ + +/* interface IMFMediaSource */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaSource; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("279a808d-aec7-40c8-9c6b-a6b492c78a66") + IMFMediaSource : public IMFMediaEventGenerator + { + public: + virtual HRESULT STDMETHODCALLTYPE GetCharacteristics( + /* [out] */ __RPC__out DWORD *pdwCharacteristics) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE CreatePresentationDescriptor( + /* [annotation][out] */ + _Outptr_ IMFPresentationDescriptor **ppPresentationDescriptor) = 0; + + virtual HRESULT STDMETHODCALLTYPE Start( + /* [in] */ __RPC__in_opt IMFPresentationDescriptor *pPresentationDescriptor, + /* [unique][in] */ __RPC__in_opt const GUID *pguidTimeFormat, + /* [unique][in] */ __RPC__in_opt const PROPVARIANT *pvarStartPosition) = 0; + + virtual HRESULT STDMETHODCALLTYPE Stop( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Pause( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Shutdown( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaSourceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaSource * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaSource * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaSource * This); + + HRESULT ( STDMETHODCALLTYPE *GetEvent )( + __RPC__in IMFMediaSource * This, + /* [in] */ DWORD dwFlags, + /* [out] */ __RPC__deref_out_opt IMFMediaEvent **ppEvent); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginGetEvent )( + IMFMediaSource * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndGetEvent )( + IMFMediaSource * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent); + + HRESULT ( STDMETHODCALLTYPE *QueueEvent )( + __RPC__in IMFMediaSource * This, + /* [in] */ MediaEventType met, + /* [in] */ __RPC__in REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ __RPC__in_opt const PROPVARIANT *pvValue); + + HRESULT ( STDMETHODCALLTYPE *GetCharacteristics )( + __RPC__in IMFMediaSource * This, + /* [out] */ __RPC__out DWORD *pdwCharacteristics); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *CreatePresentationDescriptor )( + IMFMediaSource * This, + /* [annotation][out] */ + _Outptr_ IMFPresentationDescriptor **ppPresentationDescriptor); + + HRESULT ( STDMETHODCALLTYPE *Start )( + __RPC__in IMFMediaSource * This, + /* [in] */ __RPC__in_opt IMFPresentationDescriptor *pPresentationDescriptor, + /* [unique][in] */ __RPC__in_opt const GUID *pguidTimeFormat, + /* [unique][in] */ __RPC__in_opt const PROPVARIANT *pvarStartPosition); + + HRESULT ( STDMETHODCALLTYPE *Stop )( + __RPC__in IMFMediaSource * This); + + HRESULT ( STDMETHODCALLTYPE *Pause )( + __RPC__in IMFMediaSource * This); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + __RPC__in IMFMediaSource * This); + + END_INTERFACE + } IMFMediaSourceVtbl; + + interface IMFMediaSource + { + CONST_VTBL struct IMFMediaSourceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaSource_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaSource_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaSource_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaSource_GetEvent(This,dwFlags,ppEvent) \ + ( (This)->lpVtbl -> GetEvent(This,dwFlags,ppEvent) ) + +#define IMFMediaSource_BeginGetEvent(This,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginGetEvent(This,pCallback,punkState) ) + +#define IMFMediaSource_EndGetEvent(This,pResult,ppEvent) \ + ( (This)->lpVtbl -> EndGetEvent(This,pResult,ppEvent) ) + +#define IMFMediaSource_QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) \ + ( (This)->lpVtbl -> QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) ) + + +#define IMFMediaSource_GetCharacteristics(This,pdwCharacteristics) \ + ( (This)->lpVtbl -> GetCharacteristics(This,pdwCharacteristics) ) + +#define IMFMediaSource_CreatePresentationDescriptor(This,ppPresentationDescriptor) \ + ( (This)->lpVtbl -> CreatePresentationDescriptor(This,ppPresentationDescriptor) ) + +#define IMFMediaSource_Start(This,pPresentationDescriptor,pguidTimeFormat,pvarStartPosition) \ + ( (This)->lpVtbl -> Start(This,pPresentationDescriptor,pguidTimeFormat,pvarStartPosition) ) + +#define IMFMediaSource_Stop(This) \ + ( (This)->lpVtbl -> Stop(This) ) + +#define IMFMediaSource_Pause(This) \ + ( (This)->lpVtbl -> Pause(This) ) + +#define IMFMediaSource_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaSource_RemoteCreatePresentationDescriptor_Proxy( + __RPC__in IMFMediaSource * This, + /* [out] */ __RPC__out DWORD *pcbPD, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbPD) BYTE **pbPD, + /* [out] */ __RPC__deref_out_opt IMFPresentationDescriptor **ppRemotePD); + + +void __RPC_STUB IMFMediaSource_RemoteCreatePresentationDescriptor_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMFMediaSource_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0003 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WIN8) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0003_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0003_v0_0_s_ifspec; + +#ifndef __IMFMediaSourceEx_INTERFACE_DEFINED__ +#define __IMFMediaSourceEx_INTERFACE_DEFINED__ + +/* interface IMFMediaSourceEx */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaSourceEx; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3C9B2EB9-86D5-4514-A394-F56664F9F0D8") + IMFMediaSourceEx : public IMFMediaSource + { + public: + virtual HRESULT STDMETHODCALLTYPE GetSourceAttributes( + /* [out] */ __RPC__deref_out_opt IMFAttributes **ppAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamAttributes( + /* [in] */ DWORD dwStreamIdentifier, + /* [out] */ __RPC__deref_out_opt IMFAttributes **ppAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetD3DManager( + /* [in] */ __RPC__in_opt IUnknown *pManager) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaSourceExVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaSourceEx * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaSourceEx * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaSourceEx * This); + + HRESULT ( STDMETHODCALLTYPE *GetEvent )( + __RPC__in IMFMediaSourceEx * This, + /* [in] */ DWORD dwFlags, + /* [out] */ __RPC__deref_out_opt IMFMediaEvent **ppEvent); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginGetEvent )( + IMFMediaSourceEx * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndGetEvent )( + IMFMediaSourceEx * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent); + + HRESULT ( STDMETHODCALLTYPE *QueueEvent )( + __RPC__in IMFMediaSourceEx * This, + /* [in] */ MediaEventType met, + /* [in] */ __RPC__in REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ __RPC__in_opt const PROPVARIANT *pvValue); + + HRESULT ( STDMETHODCALLTYPE *GetCharacteristics )( + __RPC__in IMFMediaSourceEx * This, + /* [out] */ __RPC__out DWORD *pdwCharacteristics); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *CreatePresentationDescriptor )( + IMFMediaSourceEx * This, + /* [annotation][out] */ + _Outptr_ IMFPresentationDescriptor **ppPresentationDescriptor); + + HRESULT ( STDMETHODCALLTYPE *Start )( + __RPC__in IMFMediaSourceEx * This, + /* [in] */ __RPC__in_opt IMFPresentationDescriptor *pPresentationDescriptor, + /* [unique][in] */ __RPC__in_opt const GUID *pguidTimeFormat, + /* [unique][in] */ __RPC__in_opt const PROPVARIANT *pvarStartPosition); + + HRESULT ( STDMETHODCALLTYPE *Stop )( + __RPC__in IMFMediaSourceEx * This); + + HRESULT ( STDMETHODCALLTYPE *Pause )( + __RPC__in IMFMediaSourceEx * This); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + __RPC__in IMFMediaSourceEx * This); + + HRESULT ( STDMETHODCALLTYPE *GetSourceAttributes )( + __RPC__in IMFMediaSourceEx * This, + /* [out] */ __RPC__deref_out_opt IMFAttributes **ppAttributes); + + HRESULT ( STDMETHODCALLTYPE *GetStreamAttributes )( + __RPC__in IMFMediaSourceEx * This, + /* [in] */ DWORD dwStreamIdentifier, + /* [out] */ __RPC__deref_out_opt IMFAttributes **ppAttributes); + + HRESULT ( STDMETHODCALLTYPE *SetD3DManager )( + __RPC__in IMFMediaSourceEx * This, + /* [in] */ __RPC__in_opt IUnknown *pManager); + + END_INTERFACE + } IMFMediaSourceExVtbl; + + interface IMFMediaSourceEx + { + CONST_VTBL struct IMFMediaSourceExVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaSourceEx_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaSourceEx_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaSourceEx_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaSourceEx_GetEvent(This,dwFlags,ppEvent) \ + ( (This)->lpVtbl -> GetEvent(This,dwFlags,ppEvent) ) + +#define IMFMediaSourceEx_BeginGetEvent(This,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginGetEvent(This,pCallback,punkState) ) + +#define IMFMediaSourceEx_EndGetEvent(This,pResult,ppEvent) \ + ( (This)->lpVtbl -> EndGetEvent(This,pResult,ppEvent) ) + +#define IMFMediaSourceEx_QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) \ + ( (This)->lpVtbl -> QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) ) + + +#define IMFMediaSourceEx_GetCharacteristics(This,pdwCharacteristics) \ + ( (This)->lpVtbl -> GetCharacteristics(This,pdwCharacteristics) ) + +#define IMFMediaSourceEx_CreatePresentationDescriptor(This,ppPresentationDescriptor) \ + ( (This)->lpVtbl -> CreatePresentationDescriptor(This,ppPresentationDescriptor) ) + +#define IMFMediaSourceEx_Start(This,pPresentationDescriptor,pguidTimeFormat,pvarStartPosition) \ + ( (This)->lpVtbl -> Start(This,pPresentationDescriptor,pguidTimeFormat,pvarStartPosition) ) + +#define IMFMediaSourceEx_Stop(This) \ + ( (This)->lpVtbl -> Stop(This) ) + +#define IMFMediaSourceEx_Pause(This) \ + ( (This)->lpVtbl -> Pause(This) ) + +#define IMFMediaSourceEx_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + + +#define IMFMediaSourceEx_GetSourceAttributes(This,ppAttributes) \ + ( (This)->lpVtbl -> GetSourceAttributes(This,ppAttributes) ) + +#define IMFMediaSourceEx_GetStreamAttributes(This,dwStreamIdentifier,ppAttributes) \ + ( (This)->lpVtbl -> GetStreamAttributes(This,dwStreamIdentifier,ppAttributes) ) + +#define IMFMediaSourceEx_SetD3DManager(This,pManager) \ + ( (This)->lpVtbl -> SetD3DManager(This,pManager) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaSourceEx_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0004 */ +/* [local] */ + +EXTERN_GUID( MF_SOURCE_STREAM_SUPPORTS_HW_CONNECTION, 0xa38253aa, 0x6314, 0x42fd, 0xa3, 0xce, 0xbb, 0x27, 0xb6, 0x85, 0x99, 0x46); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN8) + +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0004_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0004_v0_0_s_ifspec; + +#ifndef __IMFClockConsumer_INTERFACE_DEFINED__ +#define __IMFClockConsumer_INTERFACE_DEFINED__ + +/* interface IMFClockConsumer */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFClockConsumer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6ef2a662-47c0-4666-b13d-cbb717f2fa2c") + IMFClockConsumer : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetPresentationClock( + /* [in] */ __RPC__in_opt IMFPresentationClock *pPresentationClock) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPresentationClock( + /* [out] */ __RPC__deref_out_opt IMFPresentationClock **ppPresentationClock) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFClockConsumerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFClockConsumer * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFClockConsumer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFClockConsumer * This); + + HRESULT ( STDMETHODCALLTYPE *SetPresentationClock )( + __RPC__in IMFClockConsumer * This, + /* [in] */ __RPC__in_opt IMFPresentationClock *pPresentationClock); + + HRESULT ( STDMETHODCALLTYPE *GetPresentationClock )( + __RPC__in IMFClockConsumer * This, + /* [out] */ __RPC__deref_out_opt IMFPresentationClock **ppPresentationClock); + + END_INTERFACE + } IMFClockConsumerVtbl; + + interface IMFClockConsumer + { + CONST_VTBL struct IMFClockConsumerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFClockConsumer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFClockConsumer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFClockConsumer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFClockConsumer_SetPresentationClock(This,pPresentationClock) \ + ( (This)->lpVtbl -> SetPresentationClock(This,pPresentationClock) ) + +#define IMFClockConsumer_GetPresentationClock(This,ppPresentationClock) \ + ( (This)->lpVtbl -> GetPresentationClock(This,ppPresentationClock) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFClockConsumer_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0005 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0005_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0005_v0_0_s_ifspec; + +#ifndef __IMFMediaStream_INTERFACE_DEFINED__ +#define __IMFMediaStream_INTERFACE_DEFINED__ + +/* interface IMFMediaStream */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("D182108F-4EC6-443f-AA42-A71106EC825F") + IMFMediaStream : public IMFMediaEventGenerator + { + public: + virtual HRESULT STDMETHODCALLTYPE GetMediaSource( + /* [out] */ __RPC__deref_out_opt IMFMediaSource **ppMediaSource) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamDescriptor( + /* [out] */ __RPC__deref_out_opt IMFStreamDescriptor **ppStreamDescriptor) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE RequestSample( + /* [in] */ IUnknown *pToken) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaStream * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaStream * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaStream * This); + + HRESULT ( STDMETHODCALLTYPE *GetEvent )( + __RPC__in IMFMediaStream * This, + /* [in] */ DWORD dwFlags, + /* [out] */ __RPC__deref_out_opt IMFMediaEvent **ppEvent); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginGetEvent )( + IMFMediaStream * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndGetEvent )( + IMFMediaStream * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent); + + HRESULT ( STDMETHODCALLTYPE *QueueEvent )( + __RPC__in IMFMediaStream * This, + /* [in] */ MediaEventType met, + /* [in] */ __RPC__in REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ __RPC__in_opt const PROPVARIANT *pvValue); + + HRESULT ( STDMETHODCALLTYPE *GetMediaSource )( + __RPC__in IMFMediaStream * This, + /* [out] */ __RPC__deref_out_opt IMFMediaSource **ppMediaSource); + + HRESULT ( STDMETHODCALLTYPE *GetStreamDescriptor )( + __RPC__in IMFMediaStream * This, + /* [out] */ __RPC__deref_out_opt IMFStreamDescriptor **ppStreamDescriptor); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *RequestSample )( + IMFMediaStream * This, + /* [in] */ IUnknown *pToken); + + END_INTERFACE + } IMFMediaStreamVtbl; + + interface IMFMediaStream + { + CONST_VTBL struct IMFMediaStreamVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaStream_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaStream_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaStream_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaStream_GetEvent(This,dwFlags,ppEvent) \ + ( (This)->lpVtbl -> GetEvent(This,dwFlags,ppEvent) ) + +#define IMFMediaStream_BeginGetEvent(This,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginGetEvent(This,pCallback,punkState) ) + +#define IMFMediaStream_EndGetEvent(This,pResult,ppEvent) \ + ( (This)->lpVtbl -> EndGetEvent(This,pResult,ppEvent) ) + +#define IMFMediaStream_QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) \ + ( (This)->lpVtbl -> QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) ) + + +#define IMFMediaStream_GetMediaSource(This,ppMediaSource) \ + ( (This)->lpVtbl -> GetMediaSource(This,ppMediaSource) ) + +#define IMFMediaStream_GetStreamDescriptor(This,ppStreamDescriptor) \ + ( (This)->lpVtbl -> GetStreamDescriptor(This,ppStreamDescriptor) ) + +#define IMFMediaStream_RequestSample(This,pToken) \ + ( (This)->lpVtbl -> RequestSample(This,pToken) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaStream_RemoteRequestSample_Proxy( + __RPC__in IMFMediaStream * This); + + +void __RPC_STUB IMFMediaStream_RemoteRequestSample_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMFMediaStream_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0006 */ +/* [local] */ + +#if (WINVER >= _WIN32_WINNT_WIN8) +EXTERN_GUID( MF_STREAM_SINK_SUPPORTS_HW_CONNECTION, 0x9b465cbf, 0x597, 0x4f9e, 0x9f, 0x3c, 0xb9, 0x7e, 0xee, 0xf9, 0x3, 0x59); +EXTERN_GUID( MF_STREAM_SINK_SUPPORTS_ROTATION, 0xb3e96280, 0xbd05, 0x41a5, 0x97, 0xad, 0x8a, 0x7f, 0xee, 0x24, 0xb9, 0x12); +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#define MEDIASINK_FIXED_STREAMS 0x00000001 +#define MEDIASINK_CANNOT_MATCH_CLOCK 0x00000002 +#define MEDIASINK_RATELESS 0x00000004 +#define MEDIASINK_CLOCK_REQUIRED 0x00000008 +#define MEDIASINK_CAN_PREROLL 0x00000010 +#define MEDIASINK_REQUIRE_REFERENCE_MEDIATYPE 0x00000020 +typedef +enum MF_TRANSFER_VIDEO_FRAME_FLAGS + { + MF_TRANSFER_VIDEO_FRAME_DEFAULT = 0, + MF_TRANSFER_VIDEO_FRAME_STRETCH = 1, + MF_TRANSFER_VIDEO_FRAME_IGNORE_PAR = 2 + } MF_TRANSFER_VIDEO_FRAME_FLAGS; + +EXTERN_GUID( MF_SINK_VIDEO_PTS, 0x2162bde7, 0x421e, 0x4b90, 0x9b, 0x33, 0xe5, 0x8f, 0xbf, 0x1d, 0x58, 0xb6); +EXTERN_GUID( MF_SINK_VIDEO_NATIVE_WIDTH, 0xe6d6a707, 0x1505, 0x4747, 0x9b, 0x10, 0x72, 0xd2, 0xd1, 0x58, 0xcb, 0x3a); +EXTERN_GUID( MF_SINK_VIDEO_NATIVE_HEIGHT, 0xf0ca6705, 0x490c, 0x43e8, 0x94, 0x1c, 0xc0, 0xb3, 0x20, 0x6b, 0x9a, 0x65); +EXTERN_GUID( MF_SINK_VIDEO_DISPLAY_ASPECT_RATIO_NUMERATOR, 0xd0f33b22, 0xb78a, 0x4879, 0xb4, 0x55, 0xf0, 0x3e, 0xf3, 0xfa, 0x82, 0xcd); +EXTERN_GUID( MF_SINK_VIDEO_DISPLAY_ASPECT_RATIO_DENOMINATOR, 0x6ea1eb97, 0x1fe0, 0x4f10, 0xa6, 0xe4, 0x1f, 0x4f, 0x66, 0x15, 0x64, 0xe0); +EXTERN_GUID( MF_BD_MVC_PLANE_OFFSET_METADATA, 0x62a654e4, 0xb76c, 0x4901, 0x98, 0x23, 0x2c, 0xb6, 0x15, 0xd4, 0x73, 0x18); +EXTERN_GUID( MF_LUMA_KEY_ENABLE, 0x7369820f, 0x76de, 0x43ca, 0x92, 0x84, 0x47, 0xb8, 0xf3, 0x7e, 0x06, 0x49); +EXTERN_GUID( MF_LUMA_KEY_LOWER, 0x93d7b8d5, 0x0b81, 0x4715, 0xae, 0xa0, 0x87, 0x25, 0x87, 0x16, 0x21, 0xe9); +EXTERN_GUID( MF_LUMA_KEY_UPPER, 0xd09f39bb, 0x4602, 0x4c31, 0xa7, 0x06, 0xa1, 0x21, 0x71, 0xa5, 0x11, 0x0a); +EXTERN_GUID( MF_USER_EXTENDED_ATTRIBUTES, 0xc02abac6, 0xfeb2, 0x4541, 0x92, 0x2f, 0x92, 0x0b, 0x43, 0x70, 0x27, 0x22); +EXTERN_GUID( MF_INDEPENDENT_STILL_IMAGE, 0xea12af41, 0x0710, 0x42c9, 0xa1, 0x27, 0xda, 0xa3, 0xe7, 0x84, 0x83, 0xa5); + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0006_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0006_v0_0_s_ifspec; + +#ifndef __IMFMediaSink_INTERFACE_DEFINED__ +#define __IMFMediaSink_INTERFACE_DEFINED__ + +/* interface IMFMediaSink */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaSink; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6ef2a660-47c0-4666-b13d-cbb717f2fa2c") + IMFMediaSink : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetCharacteristics( + /* [out] */ __RPC__out DWORD *pdwCharacteristics) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddStreamSink( + /* [in] */ DWORD dwStreamSinkIdentifier, + /* [in] */ __RPC__in_opt IMFMediaType *pMediaType, + /* [out] */ __RPC__deref_out_opt IMFStreamSink **ppStreamSink) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveStreamSink( + /* [in] */ DWORD dwStreamSinkIdentifier) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamSinkCount( + /* [out] */ __RPC__out DWORD *pcStreamSinkCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamSinkByIndex( + /* [in] */ DWORD dwIndex, + /* [out] */ __RPC__deref_out_opt IMFStreamSink **ppStreamSink) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamSinkById( + /* [in] */ DWORD dwStreamSinkIdentifier, + /* [out] */ __RPC__deref_out_opt IMFStreamSink **ppStreamSink) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPresentationClock( + /* [in] */ __RPC__in_opt IMFPresentationClock *pPresentationClock) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPresentationClock( + /* [out] */ __RPC__deref_out_opt IMFPresentationClock **ppPresentationClock) = 0; + + virtual HRESULT STDMETHODCALLTYPE Shutdown( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaSinkVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaSink * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaSink * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaSink * This); + + HRESULT ( STDMETHODCALLTYPE *GetCharacteristics )( + __RPC__in IMFMediaSink * This, + /* [out] */ __RPC__out DWORD *pdwCharacteristics); + + HRESULT ( STDMETHODCALLTYPE *AddStreamSink )( + __RPC__in IMFMediaSink * This, + /* [in] */ DWORD dwStreamSinkIdentifier, + /* [in] */ __RPC__in_opt IMFMediaType *pMediaType, + /* [out] */ __RPC__deref_out_opt IMFStreamSink **ppStreamSink); + + HRESULT ( STDMETHODCALLTYPE *RemoveStreamSink )( + __RPC__in IMFMediaSink * This, + /* [in] */ DWORD dwStreamSinkIdentifier); + + HRESULT ( STDMETHODCALLTYPE *GetStreamSinkCount )( + __RPC__in IMFMediaSink * This, + /* [out] */ __RPC__out DWORD *pcStreamSinkCount); + + HRESULT ( STDMETHODCALLTYPE *GetStreamSinkByIndex )( + __RPC__in IMFMediaSink * This, + /* [in] */ DWORD dwIndex, + /* [out] */ __RPC__deref_out_opt IMFStreamSink **ppStreamSink); + + HRESULT ( STDMETHODCALLTYPE *GetStreamSinkById )( + __RPC__in IMFMediaSink * This, + /* [in] */ DWORD dwStreamSinkIdentifier, + /* [out] */ __RPC__deref_out_opt IMFStreamSink **ppStreamSink); + + HRESULT ( STDMETHODCALLTYPE *SetPresentationClock )( + __RPC__in IMFMediaSink * This, + /* [in] */ __RPC__in_opt IMFPresentationClock *pPresentationClock); + + HRESULT ( STDMETHODCALLTYPE *GetPresentationClock )( + __RPC__in IMFMediaSink * This, + /* [out] */ __RPC__deref_out_opt IMFPresentationClock **ppPresentationClock); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + __RPC__in IMFMediaSink * This); + + END_INTERFACE + } IMFMediaSinkVtbl; + + interface IMFMediaSink + { + CONST_VTBL struct IMFMediaSinkVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaSink_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaSink_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaSink_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaSink_GetCharacteristics(This,pdwCharacteristics) \ + ( (This)->lpVtbl -> GetCharacteristics(This,pdwCharacteristics) ) + +#define IMFMediaSink_AddStreamSink(This,dwStreamSinkIdentifier,pMediaType,ppStreamSink) \ + ( (This)->lpVtbl -> AddStreamSink(This,dwStreamSinkIdentifier,pMediaType,ppStreamSink) ) + +#define IMFMediaSink_RemoveStreamSink(This,dwStreamSinkIdentifier) \ + ( (This)->lpVtbl -> RemoveStreamSink(This,dwStreamSinkIdentifier) ) + +#define IMFMediaSink_GetStreamSinkCount(This,pcStreamSinkCount) \ + ( (This)->lpVtbl -> GetStreamSinkCount(This,pcStreamSinkCount) ) + +#define IMFMediaSink_GetStreamSinkByIndex(This,dwIndex,ppStreamSink) \ + ( (This)->lpVtbl -> GetStreamSinkByIndex(This,dwIndex,ppStreamSink) ) + +#define IMFMediaSink_GetStreamSinkById(This,dwStreamSinkIdentifier,ppStreamSink) \ + ( (This)->lpVtbl -> GetStreamSinkById(This,dwStreamSinkIdentifier,ppStreamSink) ) + +#define IMFMediaSink_SetPresentationClock(This,pPresentationClock) \ + ( (This)->lpVtbl -> SetPresentationClock(This,pPresentationClock) ) + +#define IMFMediaSink_GetPresentationClock(This,ppPresentationClock) \ + ( (This)->lpVtbl -> GetPresentationClock(This,ppPresentationClock) ) + +#define IMFMediaSink_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaSink_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0007 */ +/* [local] */ + +typedef +enum _MFSTREAMSINK_MARKER_TYPE + { + MFSTREAMSINK_MARKER_DEFAULT = 0, + MFSTREAMSINK_MARKER_ENDOFSEGMENT = ( MFSTREAMSINK_MARKER_DEFAULT + 1 ) , + MFSTREAMSINK_MARKER_TICK = ( MFSTREAMSINK_MARKER_ENDOFSEGMENT + 1 ) , + MFSTREAMSINK_MARKER_EVENT = ( MFSTREAMSINK_MARKER_TICK + 1 ) + } MFSTREAMSINK_MARKER_TYPE; + + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0007_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0007_v0_0_s_ifspec; + +#ifndef __IMFStreamSink_INTERFACE_DEFINED__ +#define __IMFStreamSink_INTERFACE_DEFINED__ + +/* interface IMFStreamSink */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFStreamSink; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0A97B3CF-8E7C-4a3d-8F8C-0C843DC247FB") + IMFStreamSink : public IMFMediaEventGenerator + { + public: + virtual HRESULT STDMETHODCALLTYPE GetMediaSink( + /* [out] */ __RPC__deref_out_opt IMFMediaSink **ppMediaSink) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetIdentifier( + /* [out] */ __RPC__out DWORD *pdwIdentifier) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMediaTypeHandler( + /* [out] */ __RPC__deref_out_opt IMFMediaTypeHandler **ppHandler) = 0; + + virtual HRESULT STDMETHODCALLTYPE ProcessSample( + /* [in] */ __RPC__in_opt IMFSample *pSample) = 0; + + virtual HRESULT STDMETHODCALLTYPE PlaceMarker( + /* [in] */ MFSTREAMSINK_MARKER_TYPE eMarkerType, + /* [in] */ __RPC__in const PROPVARIANT *pvarMarkerValue, + /* [in] */ __RPC__in const PROPVARIANT *pvarContextValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE Flush( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFStreamSinkVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFStreamSink * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFStreamSink * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFStreamSink * This); + + HRESULT ( STDMETHODCALLTYPE *GetEvent )( + __RPC__in IMFStreamSink * This, + /* [in] */ DWORD dwFlags, + /* [out] */ __RPC__deref_out_opt IMFMediaEvent **ppEvent); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginGetEvent )( + IMFStreamSink * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndGetEvent )( + IMFStreamSink * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent); + + HRESULT ( STDMETHODCALLTYPE *QueueEvent )( + __RPC__in IMFStreamSink * This, + /* [in] */ MediaEventType met, + /* [in] */ __RPC__in REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ __RPC__in_opt const PROPVARIANT *pvValue); + + HRESULT ( STDMETHODCALLTYPE *GetMediaSink )( + __RPC__in IMFStreamSink * This, + /* [out] */ __RPC__deref_out_opt IMFMediaSink **ppMediaSink); + + HRESULT ( STDMETHODCALLTYPE *GetIdentifier )( + __RPC__in IMFStreamSink * This, + /* [out] */ __RPC__out DWORD *pdwIdentifier); + + HRESULT ( STDMETHODCALLTYPE *GetMediaTypeHandler )( + __RPC__in IMFStreamSink * This, + /* [out] */ __RPC__deref_out_opt IMFMediaTypeHandler **ppHandler); + + HRESULT ( STDMETHODCALLTYPE *ProcessSample )( + __RPC__in IMFStreamSink * This, + /* [in] */ __RPC__in_opt IMFSample *pSample); + + HRESULT ( STDMETHODCALLTYPE *PlaceMarker )( + __RPC__in IMFStreamSink * This, + /* [in] */ MFSTREAMSINK_MARKER_TYPE eMarkerType, + /* [in] */ __RPC__in const PROPVARIANT *pvarMarkerValue, + /* [in] */ __RPC__in const PROPVARIANT *pvarContextValue); + + HRESULT ( STDMETHODCALLTYPE *Flush )( + __RPC__in IMFStreamSink * This); + + END_INTERFACE + } IMFStreamSinkVtbl; + + interface IMFStreamSink + { + CONST_VTBL struct IMFStreamSinkVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFStreamSink_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFStreamSink_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFStreamSink_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFStreamSink_GetEvent(This,dwFlags,ppEvent) \ + ( (This)->lpVtbl -> GetEvent(This,dwFlags,ppEvent) ) + +#define IMFStreamSink_BeginGetEvent(This,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginGetEvent(This,pCallback,punkState) ) + +#define IMFStreamSink_EndGetEvent(This,pResult,ppEvent) \ + ( (This)->lpVtbl -> EndGetEvent(This,pResult,ppEvent) ) + +#define IMFStreamSink_QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) \ + ( (This)->lpVtbl -> QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) ) + + +#define IMFStreamSink_GetMediaSink(This,ppMediaSink) \ + ( (This)->lpVtbl -> GetMediaSink(This,ppMediaSink) ) + +#define IMFStreamSink_GetIdentifier(This,pdwIdentifier) \ + ( (This)->lpVtbl -> GetIdentifier(This,pdwIdentifier) ) + +#define IMFStreamSink_GetMediaTypeHandler(This,ppHandler) \ + ( (This)->lpVtbl -> GetMediaTypeHandler(This,ppHandler) ) + +#define IMFStreamSink_ProcessSample(This,pSample) \ + ( (This)->lpVtbl -> ProcessSample(This,pSample) ) + +#define IMFStreamSink_PlaceMarker(This,eMarkerType,pvarMarkerValue,pvarContextValue) \ + ( (This)->lpVtbl -> PlaceMarker(This,eMarkerType,pvarMarkerValue,pvarContextValue) ) + +#define IMFStreamSink_Flush(This) \ + ( (This)->lpVtbl -> Flush(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFStreamSink_INTERFACE_DEFINED__ */ + + +#ifndef __IMFVideoSampleAllocator_INTERFACE_DEFINED__ +#define __IMFVideoSampleAllocator_INTERFACE_DEFINED__ + +/* interface IMFVideoSampleAllocator */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFVideoSampleAllocator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("86cbc910-e533-4751-8e3b-f19b5b806a03") + IMFVideoSampleAllocator : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetDirectXManager( + /* [unique][in] */ IUnknown *pManager) = 0; + + virtual HRESULT STDMETHODCALLTYPE UninitializeSampleAllocator( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE InitializeSampleAllocator( + /* [in] */ DWORD cRequestedFrames, + /* [in] */ IMFMediaType *pMediaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE AllocateSample( + /* [out] */ IMFSample **ppSample) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFVideoSampleAllocatorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFVideoSampleAllocator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFVideoSampleAllocator * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFVideoSampleAllocator * This); + + HRESULT ( STDMETHODCALLTYPE *SetDirectXManager )( + IMFVideoSampleAllocator * This, + /* [unique][in] */ IUnknown *pManager); + + HRESULT ( STDMETHODCALLTYPE *UninitializeSampleAllocator )( + IMFVideoSampleAllocator * This); + + HRESULT ( STDMETHODCALLTYPE *InitializeSampleAllocator )( + IMFVideoSampleAllocator * This, + /* [in] */ DWORD cRequestedFrames, + /* [in] */ IMFMediaType *pMediaType); + + HRESULT ( STDMETHODCALLTYPE *AllocateSample )( + IMFVideoSampleAllocator * This, + /* [out] */ IMFSample **ppSample); + + END_INTERFACE + } IMFVideoSampleAllocatorVtbl; + + interface IMFVideoSampleAllocator + { + CONST_VTBL struct IMFVideoSampleAllocatorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFVideoSampleAllocator_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFVideoSampleAllocator_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFVideoSampleAllocator_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFVideoSampleAllocator_SetDirectXManager(This,pManager) \ + ( (This)->lpVtbl -> SetDirectXManager(This,pManager) ) + +#define IMFVideoSampleAllocator_UninitializeSampleAllocator(This) \ + ( (This)->lpVtbl -> UninitializeSampleAllocator(This) ) + +#define IMFVideoSampleAllocator_InitializeSampleAllocator(This,cRequestedFrames,pMediaType) \ + ( (This)->lpVtbl -> InitializeSampleAllocator(This,cRequestedFrames,pMediaType) ) + +#define IMFVideoSampleAllocator_AllocateSample(This,ppSample) \ + ( (This)->lpVtbl -> AllocateSample(This,ppSample) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFVideoSampleAllocator_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0009 */ +/* [local] */ + +#if (WINVER >= _WIN32_WINNT_WIN7) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0009_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0009_v0_0_s_ifspec; + +#ifndef __IMFVideoSampleAllocatorNotify_INTERFACE_DEFINED__ +#define __IMFVideoSampleAllocatorNotify_INTERFACE_DEFINED__ + +/* interface IMFVideoSampleAllocatorNotify */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFVideoSampleAllocatorNotify; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A792CDBE-C374-4e89-8335-278E7B9956A4") + IMFVideoSampleAllocatorNotify : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE NotifyRelease( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFVideoSampleAllocatorNotifyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFVideoSampleAllocatorNotify * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFVideoSampleAllocatorNotify * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFVideoSampleAllocatorNotify * This); + + HRESULT ( STDMETHODCALLTYPE *NotifyRelease )( + IMFVideoSampleAllocatorNotify * This); + + END_INTERFACE + } IMFVideoSampleAllocatorNotifyVtbl; + + interface IMFVideoSampleAllocatorNotify + { + CONST_VTBL struct IMFVideoSampleAllocatorNotifyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFVideoSampleAllocatorNotify_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFVideoSampleAllocatorNotify_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFVideoSampleAllocatorNotify_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFVideoSampleAllocatorNotify_NotifyRelease(This) \ + ( (This)->lpVtbl -> NotifyRelease(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFVideoSampleAllocatorNotify_INTERFACE_DEFINED__ */ + + +#ifndef __IMFVideoSampleAllocatorNotifyEx_INTERFACE_DEFINED__ +#define __IMFVideoSampleAllocatorNotifyEx_INTERFACE_DEFINED__ + +/* interface IMFVideoSampleAllocatorNotifyEx */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFVideoSampleAllocatorNotifyEx; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3978AA1A-6D5B-4B7F-A340-90899189AE34") + IMFVideoSampleAllocatorNotifyEx : public IMFVideoSampleAllocatorNotify + { + public: + virtual HRESULT STDMETHODCALLTYPE NotifyPrune( + IMFSample *__MIDL__IMFVideoSampleAllocatorNotifyEx0000) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFVideoSampleAllocatorNotifyExVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFVideoSampleAllocatorNotifyEx * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFVideoSampleAllocatorNotifyEx * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFVideoSampleAllocatorNotifyEx * This); + + HRESULT ( STDMETHODCALLTYPE *NotifyRelease )( + IMFVideoSampleAllocatorNotifyEx * This); + + HRESULT ( STDMETHODCALLTYPE *NotifyPrune )( + IMFVideoSampleAllocatorNotifyEx * This, + IMFSample *__MIDL__IMFVideoSampleAllocatorNotifyEx0000); + + END_INTERFACE + } IMFVideoSampleAllocatorNotifyExVtbl; + + interface IMFVideoSampleAllocatorNotifyEx + { + CONST_VTBL struct IMFVideoSampleAllocatorNotifyExVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFVideoSampleAllocatorNotifyEx_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFVideoSampleAllocatorNotifyEx_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFVideoSampleAllocatorNotifyEx_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFVideoSampleAllocatorNotifyEx_NotifyRelease(This) \ + ( (This)->lpVtbl -> NotifyRelease(This) ) + + +#define IMFVideoSampleAllocatorNotifyEx_NotifyPrune(This,__MIDL__IMFVideoSampleAllocatorNotifyEx0000) \ + ( (This)->lpVtbl -> NotifyPrune(This,__MIDL__IMFVideoSampleAllocatorNotifyEx0000) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFVideoSampleAllocatorNotifyEx_INTERFACE_DEFINED__ */ + + +#ifndef __IMFVideoSampleAllocatorCallback_INTERFACE_DEFINED__ +#define __IMFVideoSampleAllocatorCallback_INTERFACE_DEFINED__ + +/* interface IMFVideoSampleAllocatorCallback */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFVideoSampleAllocatorCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("992388B4-3372-4f67-8B6F-C84C071F4751") + IMFVideoSampleAllocatorCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetCallback( + /* [unique][in] */ IMFVideoSampleAllocatorNotify *pNotify) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFreeSampleCount( + /* [out] */ LONG *plSamples) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFVideoSampleAllocatorCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFVideoSampleAllocatorCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFVideoSampleAllocatorCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFVideoSampleAllocatorCallback * This); + + HRESULT ( STDMETHODCALLTYPE *SetCallback )( + IMFVideoSampleAllocatorCallback * This, + /* [unique][in] */ IMFVideoSampleAllocatorNotify *pNotify); + + HRESULT ( STDMETHODCALLTYPE *GetFreeSampleCount )( + IMFVideoSampleAllocatorCallback * This, + /* [out] */ LONG *plSamples); + + END_INTERFACE + } IMFVideoSampleAllocatorCallbackVtbl; + + interface IMFVideoSampleAllocatorCallback + { + CONST_VTBL struct IMFVideoSampleAllocatorCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFVideoSampleAllocatorCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFVideoSampleAllocatorCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFVideoSampleAllocatorCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFVideoSampleAllocatorCallback_SetCallback(This,pNotify) \ + ( (This)->lpVtbl -> SetCallback(This,pNotify) ) + +#define IMFVideoSampleAllocatorCallback_GetFreeSampleCount(This,plSamples) \ + ( (This)->lpVtbl -> GetFreeSampleCount(This,plSamples) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFVideoSampleAllocatorCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IMFVideoSampleAllocatorEx_INTERFACE_DEFINED__ +#define __IMFVideoSampleAllocatorEx_INTERFACE_DEFINED__ + +/* interface IMFVideoSampleAllocatorEx */ +/* [unique][helpstring][uuid][local][object] */ + + +EXTERN_C const IID IID_IMFVideoSampleAllocatorEx; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("545b3a48-3283-4f62-866f-a62d8f598f9f") + IMFVideoSampleAllocatorEx : public IMFVideoSampleAllocator + { + public: + virtual HRESULT STDMETHODCALLTYPE InitializeSampleAllocatorEx( + /* [annotation] */ + _In_ DWORD cInitialSamples, + /* [annotation] */ + _In_ DWORD cMaximumSamples, + /* [annotation] */ + _In_opt_ IMFAttributes *pAttributes, + /* [annotation] */ + _In_ IMFMediaType *pMediaType) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFVideoSampleAllocatorExVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFVideoSampleAllocatorEx * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFVideoSampleAllocatorEx * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFVideoSampleAllocatorEx * This); + + HRESULT ( STDMETHODCALLTYPE *SetDirectXManager )( + IMFVideoSampleAllocatorEx * This, + /* [unique][in] */ IUnknown *pManager); + + HRESULT ( STDMETHODCALLTYPE *UninitializeSampleAllocator )( + IMFVideoSampleAllocatorEx * This); + + HRESULT ( STDMETHODCALLTYPE *InitializeSampleAllocator )( + IMFVideoSampleAllocatorEx * This, + /* [in] */ DWORD cRequestedFrames, + /* [in] */ IMFMediaType *pMediaType); + + HRESULT ( STDMETHODCALLTYPE *AllocateSample )( + IMFVideoSampleAllocatorEx * This, + /* [out] */ IMFSample **ppSample); + + HRESULT ( STDMETHODCALLTYPE *InitializeSampleAllocatorEx )( + IMFVideoSampleAllocatorEx * This, + /* [annotation] */ + _In_ DWORD cInitialSamples, + /* [annotation] */ + _In_ DWORD cMaximumSamples, + /* [annotation] */ + _In_opt_ IMFAttributes *pAttributes, + /* [annotation] */ + _In_ IMFMediaType *pMediaType); + + END_INTERFACE + } IMFVideoSampleAllocatorExVtbl; + + interface IMFVideoSampleAllocatorEx + { + CONST_VTBL struct IMFVideoSampleAllocatorExVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFVideoSampleAllocatorEx_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFVideoSampleAllocatorEx_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFVideoSampleAllocatorEx_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFVideoSampleAllocatorEx_SetDirectXManager(This,pManager) \ + ( (This)->lpVtbl -> SetDirectXManager(This,pManager) ) + +#define IMFVideoSampleAllocatorEx_UninitializeSampleAllocator(This) \ + ( (This)->lpVtbl -> UninitializeSampleAllocator(This) ) + +#define IMFVideoSampleAllocatorEx_InitializeSampleAllocator(This,cRequestedFrames,pMediaType) \ + ( (This)->lpVtbl -> InitializeSampleAllocator(This,cRequestedFrames,pMediaType) ) + +#define IMFVideoSampleAllocatorEx_AllocateSample(This,ppSample) \ + ( (This)->lpVtbl -> AllocateSample(This,ppSample) ) + + +#define IMFVideoSampleAllocatorEx_InitializeSampleAllocatorEx(This,cInitialSamples,cMaximumSamples,pAttributes,pMediaType) \ + ( (This)->lpVtbl -> InitializeSampleAllocatorEx(This,cInitialSamples,cMaximumSamples,pAttributes,pMediaType) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFVideoSampleAllocatorEx_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0013 */ +/* [local] */ + +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#if (WINVER >= _WIN32_WINNT_WINBLUE) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0013_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0013_v0_0_s_ifspec; + +#ifndef __IMFDXGIDeviceManagerSource_INTERFACE_DEFINED__ +#define __IMFDXGIDeviceManagerSource_INTERFACE_DEFINED__ + +/* interface IMFDXGIDeviceManagerSource */ +/* [unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFDXGIDeviceManagerSource; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("20bc074b-7a8d-4609-8c3b-64a0a3b5d7ce") + IMFDXGIDeviceManagerSource : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetManager( + /* [out] */ __RPC__deref_out_opt IMFDXGIDeviceManager **ppManager) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFDXGIDeviceManagerSourceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFDXGIDeviceManagerSource * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFDXGIDeviceManagerSource * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFDXGIDeviceManagerSource * This); + + HRESULT ( STDMETHODCALLTYPE *GetManager )( + __RPC__in IMFDXGIDeviceManagerSource * This, + /* [out] */ __RPC__deref_out_opt IMFDXGIDeviceManager **ppManager); + + END_INTERFACE + } IMFDXGIDeviceManagerSourceVtbl; + + interface IMFDXGIDeviceManagerSource + { + CONST_VTBL struct IMFDXGIDeviceManagerSourceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFDXGIDeviceManagerSource_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFDXGIDeviceManagerSource_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFDXGIDeviceManagerSource_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFDXGIDeviceManagerSource_GetManager(This,ppManager) \ + ( (This)->lpVtbl -> GetManager(This,ppManager) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFDXGIDeviceManagerSource_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0014 */ +/* [local] */ + +#endif // (WINVER >= _WIN32_WINNT_WINBLUE) +#if (WINVER >= _WIN32_WINNT_WIN8) +typedef +enum _MF_VIDEO_PROCESSOR_ROTATION + { + ROTATION_NONE = 0, + ROTATION_NORMAL = 1 + } MF_VIDEO_PROCESSOR_ROTATION; + +typedef +enum _MF_VIDEO_PROCESSOR_MIRROR + { + MIRROR_NONE = 0, + MIRROR_HORIZONTAL = 1, + MIRROR_VERTICAL = 2 + } MF_VIDEO_PROCESSOR_MIRROR; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0014_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0014_v0_0_s_ifspec; + +#ifndef __IMFVideoProcessorControl_INTERFACE_DEFINED__ +#define __IMFVideoProcessorControl_INTERFACE_DEFINED__ + +/* interface IMFVideoProcessorControl */ +/* [unique][helpstring][uuid][local][object] */ + + +EXTERN_C const IID IID_IMFVideoProcessorControl; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A3F675D5-6119-4f7f-A100-1D8B280F0EFB") + IMFVideoProcessorControl : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetBorderColor( + /* [annotation][in] */ + _In_opt_ MFARGB *pBorderColor) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSourceRectangle( + /* [annotation][in] */ + _In_opt_ RECT *pSrcRect) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDestinationRectangle( + /* [annotation][in] */ + _In_opt_ RECT *pDstRect) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMirror( + /* [annotation][in] */ + _In_ MF_VIDEO_PROCESSOR_MIRROR eMirror) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetRotation( + /* [annotation][in] */ + _In_ MF_VIDEO_PROCESSOR_ROTATION eRotation) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetConstrictionSize( + /* [annotation][in] */ + _In_opt_ SIZE *pConstrictionSize) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFVideoProcessorControlVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFVideoProcessorControl * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFVideoProcessorControl * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFVideoProcessorControl * This); + + HRESULT ( STDMETHODCALLTYPE *SetBorderColor )( + IMFVideoProcessorControl * This, + /* [annotation][in] */ + _In_opt_ MFARGB *pBorderColor); + + HRESULT ( STDMETHODCALLTYPE *SetSourceRectangle )( + IMFVideoProcessorControl * This, + /* [annotation][in] */ + _In_opt_ RECT *pSrcRect); + + HRESULT ( STDMETHODCALLTYPE *SetDestinationRectangle )( + IMFVideoProcessorControl * This, + /* [annotation][in] */ + _In_opt_ RECT *pDstRect); + + HRESULT ( STDMETHODCALLTYPE *SetMirror )( + IMFVideoProcessorControl * This, + /* [annotation][in] */ + _In_ MF_VIDEO_PROCESSOR_MIRROR eMirror); + + HRESULT ( STDMETHODCALLTYPE *SetRotation )( + IMFVideoProcessorControl * This, + /* [annotation][in] */ + _In_ MF_VIDEO_PROCESSOR_ROTATION eRotation); + + HRESULT ( STDMETHODCALLTYPE *SetConstrictionSize )( + IMFVideoProcessorControl * This, + /* [annotation][in] */ + _In_opt_ SIZE *pConstrictionSize); + + END_INTERFACE + } IMFVideoProcessorControlVtbl; + + interface IMFVideoProcessorControl + { + CONST_VTBL struct IMFVideoProcessorControlVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFVideoProcessorControl_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFVideoProcessorControl_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFVideoProcessorControl_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFVideoProcessorControl_SetBorderColor(This,pBorderColor) \ + ( (This)->lpVtbl -> SetBorderColor(This,pBorderColor) ) + +#define IMFVideoProcessorControl_SetSourceRectangle(This,pSrcRect) \ + ( (This)->lpVtbl -> SetSourceRectangle(This,pSrcRect) ) + +#define IMFVideoProcessorControl_SetDestinationRectangle(This,pDstRect) \ + ( (This)->lpVtbl -> SetDestinationRectangle(This,pDstRect) ) + +#define IMFVideoProcessorControl_SetMirror(This,eMirror) \ + ( (This)->lpVtbl -> SetMirror(This,eMirror) ) + +#define IMFVideoProcessorControl_SetRotation(This,eRotation) \ + ( (This)->lpVtbl -> SetRotation(This,eRotation) ) + +#define IMFVideoProcessorControl_SetConstrictionSize(This,pConstrictionSize) \ + ( (This)->lpVtbl -> SetConstrictionSize(This,pConstrictionSize) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFVideoProcessorControl_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0015 */ +/* [local] */ + +#if (WINVER >= _WIN32_WINNT_WINBLUE) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0015_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0015_v0_0_s_ifspec; + +#ifndef __IMFVideoProcessorControl2_INTERFACE_DEFINED__ +#define __IMFVideoProcessorControl2_INTERFACE_DEFINED__ + +/* interface IMFVideoProcessorControl2 */ +/* [unique][uuid][local][object] */ + + +EXTERN_C const IID IID_IMFVideoProcessorControl2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("BDE633D3-E1DC-4a7f-A693-BBAE399C4A20") + IMFVideoProcessorControl2 : public IMFVideoProcessorControl + { + public: + virtual HRESULT STDMETHODCALLTYPE SetRotationOverride( + /* [annotation][in] */ + _In_ UINT uiRotation) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableHardwareEffects( + /* [annotation][in] */ + _In_ BOOL fEnabled) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSupportedHardwareEffects( + /* [annotation][retval][out] */ + _Out_ UINT *puiSupport) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFVideoProcessorControl2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFVideoProcessorControl2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFVideoProcessorControl2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFVideoProcessorControl2 * This); + + HRESULT ( STDMETHODCALLTYPE *SetBorderColor )( + IMFVideoProcessorControl2 * This, + /* [annotation][in] */ + _In_opt_ MFARGB *pBorderColor); + + HRESULT ( STDMETHODCALLTYPE *SetSourceRectangle )( + IMFVideoProcessorControl2 * This, + /* [annotation][in] */ + _In_opt_ RECT *pSrcRect); + + HRESULT ( STDMETHODCALLTYPE *SetDestinationRectangle )( + IMFVideoProcessorControl2 * This, + /* [annotation][in] */ + _In_opt_ RECT *pDstRect); + + HRESULT ( STDMETHODCALLTYPE *SetMirror )( + IMFVideoProcessorControl2 * This, + /* [annotation][in] */ + _In_ MF_VIDEO_PROCESSOR_MIRROR eMirror); + + HRESULT ( STDMETHODCALLTYPE *SetRotation )( + IMFVideoProcessorControl2 * This, + /* [annotation][in] */ + _In_ MF_VIDEO_PROCESSOR_ROTATION eRotation); + + HRESULT ( STDMETHODCALLTYPE *SetConstrictionSize )( + IMFVideoProcessorControl2 * This, + /* [annotation][in] */ + _In_opt_ SIZE *pConstrictionSize); + + HRESULT ( STDMETHODCALLTYPE *SetRotationOverride )( + IMFVideoProcessorControl2 * This, + /* [annotation][in] */ + _In_ UINT uiRotation); + + HRESULT ( STDMETHODCALLTYPE *EnableHardwareEffects )( + IMFVideoProcessorControl2 * This, + /* [annotation][in] */ + _In_ BOOL fEnabled); + + HRESULT ( STDMETHODCALLTYPE *GetSupportedHardwareEffects )( + IMFVideoProcessorControl2 * This, + /* [annotation][retval][out] */ + _Out_ UINT *puiSupport); + + END_INTERFACE + } IMFVideoProcessorControl2Vtbl; + + interface IMFVideoProcessorControl2 + { + CONST_VTBL struct IMFVideoProcessorControl2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFVideoProcessorControl2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFVideoProcessorControl2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFVideoProcessorControl2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFVideoProcessorControl2_SetBorderColor(This,pBorderColor) \ + ( (This)->lpVtbl -> SetBorderColor(This,pBorderColor) ) + +#define IMFVideoProcessorControl2_SetSourceRectangle(This,pSrcRect) \ + ( (This)->lpVtbl -> SetSourceRectangle(This,pSrcRect) ) + +#define IMFVideoProcessorControl2_SetDestinationRectangle(This,pDstRect) \ + ( (This)->lpVtbl -> SetDestinationRectangle(This,pDstRect) ) + +#define IMFVideoProcessorControl2_SetMirror(This,eMirror) \ + ( (This)->lpVtbl -> SetMirror(This,eMirror) ) + +#define IMFVideoProcessorControl2_SetRotation(This,eRotation) \ + ( (This)->lpVtbl -> SetRotation(This,eRotation) ) + +#define IMFVideoProcessorControl2_SetConstrictionSize(This,pConstrictionSize) \ + ( (This)->lpVtbl -> SetConstrictionSize(This,pConstrictionSize) ) + + +#define IMFVideoProcessorControl2_SetRotationOverride(This,uiRotation) \ + ( (This)->lpVtbl -> SetRotationOverride(This,uiRotation) ) + +#define IMFVideoProcessorControl2_EnableHardwareEffects(This,fEnabled) \ + ( (This)->lpVtbl -> EnableHardwareEffects(This,fEnabled) ) + +#define IMFVideoProcessorControl2_GetSupportedHardwareEffects(This,puiSupport) \ + ( (This)->lpVtbl -> GetSupportedHardwareEffects(This,puiSupport) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFVideoProcessorControl2_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0016 */ +/* [local] */ + +#if (WINVER >= _WIN32_WINNT_WIN10) +typedef +enum _MFVideoSphericalFormat + { + MFVideoSphericalFormat_Unsupported = 0, + MFVideoSphericalFormat_Equirectangular = 1 + } MFVideoSphericalFormat; + +#endif /* (WINVER >= _WIN32_WINNT_WIN10) */ +#if (NTDDI_VERSION >= NTDDI_WIN10_RS3) +EXTERN_GUID( MF_XVP_SAMPLE_LOCK_TIMEOUT, 0xaa4ddb29, 0x5134, 0x4363, 0xac, 0x72, 0x83, 0xec, 0x4b, 0xc1, 0x4, 0x26); +typedef +enum MFVideoSphericalProjectionMode + { + MFVideoSphericalProjectionMode_Spherical = 0, + MFVideoSphericalProjectionMode_Flat = ( MFVideoSphericalProjectionMode_Spherical + 1 ) + } MFVideoSphericalProjectionMode; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0016_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0016_v0_0_s_ifspec; + +#ifndef __IMFVideoProcessorControl3_INTERFACE_DEFINED__ +#define __IMFVideoProcessorControl3_INTERFACE_DEFINED__ + +/* interface IMFVideoProcessorControl3 */ +/* [uuid][local][object] */ + + +EXTERN_C const IID IID_IMFVideoProcessorControl3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2424B3F2-EB23-40f1-91AA-74BDDEEA0883") + IMFVideoProcessorControl3 : public IMFVideoProcessorControl2 + { + public: + virtual HRESULT STDMETHODCALLTYPE GetNaturalOutputType( + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppType) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableSphericalVideoProcessing( + /* [annotation][in] */ + _In_ BOOL fEnable, + /* [annotation][in] */ + _In_ MFVideoSphericalFormat eFormat, + /* [annotation][in] */ + _In_ MFVideoSphericalProjectionMode eProjectionMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSphericalVideoProperties( + /* [annotation][in] */ + _In_ float X, + /* [annotation][in] */ + _In_ float Y, + /* [annotation][in] */ + _In_ float Z, + /* [annotation][in] */ + _In_ float W, + /* [annotation][in] */ + _In_ float fieldOfView) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetOutputDevice( + /* [annotation][in] */ + _In_ IUnknown *pOutputDevice) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFVideoProcessorControl3Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFVideoProcessorControl3 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFVideoProcessorControl3 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFVideoProcessorControl3 * This); + + HRESULT ( STDMETHODCALLTYPE *SetBorderColor )( + IMFVideoProcessorControl3 * This, + /* [annotation][in] */ + _In_opt_ MFARGB *pBorderColor); + + HRESULT ( STDMETHODCALLTYPE *SetSourceRectangle )( + IMFVideoProcessorControl3 * This, + /* [annotation][in] */ + _In_opt_ RECT *pSrcRect); + + HRESULT ( STDMETHODCALLTYPE *SetDestinationRectangle )( + IMFVideoProcessorControl3 * This, + /* [annotation][in] */ + _In_opt_ RECT *pDstRect); + + HRESULT ( STDMETHODCALLTYPE *SetMirror )( + IMFVideoProcessorControl3 * This, + /* [annotation][in] */ + _In_ MF_VIDEO_PROCESSOR_MIRROR eMirror); + + HRESULT ( STDMETHODCALLTYPE *SetRotation )( + IMFVideoProcessorControl3 * This, + /* [annotation][in] */ + _In_ MF_VIDEO_PROCESSOR_ROTATION eRotation); + + HRESULT ( STDMETHODCALLTYPE *SetConstrictionSize )( + IMFVideoProcessorControl3 * This, + /* [annotation][in] */ + _In_opt_ SIZE *pConstrictionSize); + + HRESULT ( STDMETHODCALLTYPE *SetRotationOverride )( + IMFVideoProcessorControl3 * This, + /* [annotation][in] */ + _In_ UINT uiRotation); + + HRESULT ( STDMETHODCALLTYPE *EnableHardwareEffects )( + IMFVideoProcessorControl3 * This, + /* [annotation][in] */ + _In_ BOOL fEnabled); + + HRESULT ( STDMETHODCALLTYPE *GetSupportedHardwareEffects )( + IMFVideoProcessorControl3 * This, + /* [annotation][retval][out] */ + _Out_ UINT *puiSupport); + + HRESULT ( STDMETHODCALLTYPE *GetNaturalOutputType )( + IMFVideoProcessorControl3 * This, + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppType); + + HRESULT ( STDMETHODCALLTYPE *EnableSphericalVideoProcessing )( + IMFVideoProcessorControl3 * This, + /* [annotation][in] */ + _In_ BOOL fEnable, + /* [annotation][in] */ + _In_ MFVideoSphericalFormat eFormat, + /* [annotation][in] */ + _In_ MFVideoSphericalProjectionMode eProjectionMode); + + HRESULT ( STDMETHODCALLTYPE *SetSphericalVideoProperties )( + IMFVideoProcessorControl3 * This, + /* [annotation][in] */ + _In_ float X, + /* [annotation][in] */ + _In_ float Y, + /* [annotation][in] */ + _In_ float Z, + /* [annotation][in] */ + _In_ float W, + /* [annotation][in] */ + _In_ float fieldOfView); + + HRESULT ( STDMETHODCALLTYPE *SetOutputDevice )( + IMFVideoProcessorControl3 * This, + /* [annotation][in] */ + _In_ IUnknown *pOutputDevice); + + END_INTERFACE + } IMFVideoProcessorControl3Vtbl; + + interface IMFVideoProcessorControl3 + { + CONST_VTBL struct IMFVideoProcessorControl3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFVideoProcessorControl3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFVideoProcessorControl3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFVideoProcessorControl3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFVideoProcessorControl3_SetBorderColor(This,pBorderColor) \ + ( (This)->lpVtbl -> SetBorderColor(This,pBorderColor) ) + +#define IMFVideoProcessorControl3_SetSourceRectangle(This,pSrcRect) \ + ( (This)->lpVtbl -> SetSourceRectangle(This,pSrcRect) ) + +#define IMFVideoProcessorControl3_SetDestinationRectangle(This,pDstRect) \ + ( (This)->lpVtbl -> SetDestinationRectangle(This,pDstRect) ) + +#define IMFVideoProcessorControl3_SetMirror(This,eMirror) \ + ( (This)->lpVtbl -> SetMirror(This,eMirror) ) + +#define IMFVideoProcessorControl3_SetRotation(This,eRotation) \ + ( (This)->lpVtbl -> SetRotation(This,eRotation) ) + +#define IMFVideoProcessorControl3_SetConstrictionSize(This,pConstrictionSize) \ + ( (This)->lpVtbl -> SetConstrictionSize(This,pConstrictionSize) ) + + +#define IMFVideoProcessorControl3_SetRotationOverride(This,uiRotation) \ + ( (This)->lpVtbl -> SetRotationOverride(This,uiRotation) ) + +#define IMFVideoProcessorControl3_EnableHardwareEffects(This,fEnabled) \ + ( (This)->lpVtbl -> EnableHardwareEffects(This,fEnabled) ) + +#define IMFVideoProcessorControl3_GetSupportedHardwareEffects(This,puiSupport) \ + ( (This)->lpVtbl -> GetSupportedHardwareEffects(This,puiSupport) ) + + +#define IMFVideoProcessorControl3_GetNaturalOutputType(This,ppType) \ + ( (This)->lpVtbl -> GetNaturalOutputType(This,ppType) ) + +#define IMFVideoProcessorControl3_EnableSphericalVideoProcessing(This,fEnable,eFormat,eProjectionMode) \ + ( (This)->lpVtbl -> EnableSphericalVideoProcessing(This,fEnable,eFormat,eProjectionMode) ) + +#define IMFVideoProcessorControl3_SetSphericalVideoProperties(This,X,Y,Z,W,fieldOfView) \ + ( (This)->lpVtbl -> SetSphericalVideoProperties(This,X,Y,Z,W,fieldOfView) ) + +#define IMFVideoProcessorControl3_SetOutputDevice(This,pOutputDevice) \ + ( (This)->lpVtbl -> SetOutputDevice(This,pOutputDevice) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFVideoProcessorControl3_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0017 */ +/* [local] */ + +#endif /* (NTDDI_VERSION >= NTDDI_WIN10_RS3) */ +#endif // (WINVER >= _WIN32_WINNT_WINBLUE) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0017_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0017_v0_0_s_ifspec; + +#ifndef __IMFTopology_INTERFACE_DEFINED__ +#define __IMFTopology_INTERFACE_DEFINED__ + +/* interface IMFTopology */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFTopology; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("83CF873A-F6DA-4bc8-823F-BACFD55DC433") + IMFTopology : public IMFAttributes + { + public: + virtual HRESULT STDMETHODCALLTYPE GetTopologyID( + /* [out] */ __RPC__out TOPOID *pID) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE AddNode( + /* [in] */ IMFTopologyNode *pNode) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE RemoveNode( + /* [in] */ IMFTopologyNode *pNode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetNodeCount( + /* [out] */ __RPC__out WORD *pwNodes) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetNode( + /* [in] */ WORD wIndex, + /* [out] */ __RPC__deref_out_opt IMFTopologyNode **ppNode) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE Clear( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE CloneFrom( + /* [in] */ __RPC__in_opt IMFTopology *pTopology) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetNodeByID( + /* [in] */ TOPOID qwTopoNodeID, + /* [out] */ __RPC__deref_out_opt IMFTopologyNode **ppNode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSourceNodeCollection( + /* [out] */ __RPC__deref_out_opt IMFCollection **ppCollection) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputNodeCollection( + /* [out] */ __RPC__deref_out_opt IMFCollection **ppCollection) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTopologyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFTopology * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFTopology * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFTopology * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + __RPC__in IMFTopology * This, + __RPC__in_opt IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cchBufSize) LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(( *pcchLength + 1 ) ) LPWSTR *ppwszValue, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cbBufSize) UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbSize) UINT8 **ppBuf, + /* [out] */ __RPC__out UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + __RPC__in IMFTopology * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + __RPC__in REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [string][in] */ __RPC__in_string LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [size_is][in] */ __RPC__in_ecount_full(cbBufSize) const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + __RPC__in IMFTopology * This, + __RPC__in REFGUID guidKey, + /* [in] */ __RPC__in_opt IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + __RPC__in IMFTopology * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + __RPC__in IMFTopology * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + __RPC__in IMFTopology * This, + /* [out] */ __RPC__out UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + __RPC__in IMFTopology * This, + UINT32 unIndex, + /* [out] */ __RPC__out GUID *pguidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + __RPC__in IMFTopology * This, + /* [in] */ __RPC__in_opt IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *GetTopologyID )( + __RPC__in IMFTopology * This, + /* [out] */ __RPC__out TOPOID *pID); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *AddNode )( + IMFTopology * This, + /* [in] */ IMFTopologyNode *pNode); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *RemoveNode )( + IMFTopology * This, + /* [in] */ IMFTopologyNode *pNode); + + HRESULT ( STDMETHODCALLTYPE *GetNodeCount )( + __RPC__in IMFTopology * This, + /* [out] */ __RPC__out WORD *pwNodes); + + HRESULT ( STDMETHODCALLTYPE *GetNode )( + __RPC__in IMFTopology * This, + /* [in] */ WORD wIndex, + /* [out] */ __RPC__deref_out_opt IMFTopologyNode **ppNode); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *Clear )( + IMFTopology * This); + + HRESULT ( STDMETHODCALLTYPE *CloneFrom )( + __RPC__in IMFTopology * This, + /* [in] */ __RPC__in_opt IMFTopology *pTopology); + + HRESULT ( STDMETHODCALLTYPE *GetNodeByID )( + __RPC__in IMFTopology * This, + /* [in] */ TOPOID qwTopoNodeID, + /* [out] */ __RPC__deref_out_opt IMFTopologyNode **ppNode); + + HRESULT ( STDMETHODCALLTYPE *GetSourceNodeCollection )( + __RPC__in IMFTopology * This, + /* [out] */ __RPC__deref_out_opt IMFCollection **ppCollection); + + HRESULT ( STDMETHODCALLTYPE *GetOutputNodeCollection )( + __RPC__in IMFTopology * This, + /* [out] */ __RPC__deref_out_opt IMFCollection **ppCollection); + + END_INTERFACE + } IMFTopologyVtbl; + + interface IMFTopology + { + CONST_VTBL struct IMFTopologyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTopology_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTopology_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTopology_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTopology_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFTopology_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFTopology_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFTopology_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFTopology_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFTopology_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFTopology_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFTopology_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFTopology_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFTopology_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFTopology_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFTopology_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFTopology_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFTopology_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFTopology_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFTopology_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFTopology_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFTopology_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFTopology_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFTopology_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFTopology_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFTopology_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFTopology_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFTopology_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFTopology_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFTopology_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFTopology_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFTopology_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFTopology_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFTopology_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFTopology_GetTopologyID(This,pID) \ + ( (This)->lpVtbl -> GetTopologyID(This,pID) ) + +#define IMFTopology_AddNode(This,pNode) \ + ( (This)->lpVtbl -> AddNode(This,pNode) ) + +#define IMFTopology_RemoveNode(This,pNode) \ + ( (This)->lpVtbl -> RemoveNode(This,pNode) ) + +#define IMFTopology_GetNodeCount(This,pwNodes) \ + ( (This)->lpVtbl -> GetNodeCount(This,pwNodes) ) + +#define IMFTopology_GetNode(This,wIndex,ppNode) \ + ( (This)->lpVtbl -> GetNode(This,wIndex,ppNode) ) + +#define IMFTopology_Clear(This) \ + ( (This)->lpVtbl -> Clear(This) ) + +#define IMFTopology_CloneFrom(This,pTopology) \ + ( (This)->lpVtbl -> CloneFrom(This,pTopology) ) + +#define IMFTopology_GetNodeByID(This,qwTopoNodeID,ppNode) \ + ( (This)->lpVtbl -> GetNodeByID(This,qwTopoNodeID,ppNode) ) + +#define IMFTopology_GetSourceNodeCollection(This,ppCollection) \ + ( (This)->lpVtbl -> GetSourceNodeCollection(This,ppCollection) ) + +#define IMFTopology_GetOutputNodeCollection(This,ppCollection) \ + ( (This)->lpVtbl -> GetOutputNodeCollection(This,ppCollection) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTopology_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0018 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +EXTERN_GUID( MF_TOPOLOGY_PROJECTSTART, 0x7ed3f802, 0x86bb, 0x4b3f, 0xb7, 0xe4, 0x7c, 0xb4, 0x3a, 0xfd, 0x4b, 0x80); +EXTERN_GUID( MF_TOPOLOGY_PROJECTSTOP, 0x7ed3f803, 0x86bb, 0x4b3f, 0xb7, 0xe4, 0x7c, 0xb4, 0x3a, 0xfd, 0x4b, 0x80); +EXTERN_GUID( MF_TOPOLOGY_NO_MARKIN_MARKOUT, 0x7ed3f804, 0x86bb, 0x4b3f, 0xb7, 0xe4, 0x7c, 0xb4, 0x3a, 0xfd, 0x4b, 0x80); +#if (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +typedef +enum MFTOPOLOGY_DXVA_MODE + { + MFTOPOLOGY_DXVA_DEFAULT = 0, + MFTOPOLOGY_DXVA_NONE = 1, + MFTOPOLOGY_DXVA_FULL = 2 + } MFTOPOLOGY_DXVA_MODE; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +EXTERN_GUID(MF_TOPOLOGY_DXVA_MODE, 0x1e8d34f6, 0xf5ab, 0x4e23, 0xbb, 0x88, 0x87, 0x4a, 0xa3, 0xa1, 0xa7, 0x4d); +EXTERN_GUID(MF_TOPOLOGY_ENABLE_XVP_FOR_PLAYBACK, 0x1967731f, 0xcd78, 0x42fc, 0xb0, 0x26, 0x9, 0x92, 0xa5, 0x6e, 0x56, 0x93); +EXTERN_GUID(MF_TOPOLOGY_STATIC_PLAYBACK_OPTIMIZATIONS, 0xb86cac42, 0x41a6, 0x4b79, 0x89, 0x7a, 0x1a, 0xb0, 0xe5, 0x2b, 0x4a, 0x1b); +EXTERN_GUID(MF_TOPOLOGY_PLAYBACK_MAX_DIMS, 0x5715cf19, 0x5768, 0x44aa, 0xad, 0x6e, 0x87, 0x21, 0xf1, 0xb0, 0xf9, 0xbb); +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +typedef +enum MFTOPOLOGY_HARDWARE_MODE + { + MFTOPOLOGY_HWMODE_SOFTWARE_ONLY = 0, + MFTOPOLOGY_HWMODE_USE_HARDWARE = 1, + MFTOPOLOGY_HWMODE_USE_ONLY_HARDWARE = 2 + } MFTOPOLOGY_HARDWARE_MODE; + +EXTERN_GUID(MF_TOPOLOGY_HARDWARE_MODE, 0xd2d362fd, 0x4e4f, 0x4191, 0xa5, 0x79, 0xc6, 0x18, 0xb6, 0x67, 0x6, 0xaf); +EXTERN_GUID(MF_TOPOLOGY_PLAYBACK_FRAMERATE, 0xc164737a, 0xc2b1, 0x4553, 0x83, 0xbb, 0x5a, 0x52, 0x60, 0x72, 0x44, 0x8f); +EXTERN_GUID(MF_TOPOLOGY_DYNAMIC_CHANGE_NOT_ALLOWED, 0xd529950b, 0xd484, 0x4527, 0xa9, 0xcd, 0xb1, 0x90, 0x95, 0x32, 0xb5, 0xb0); +EXTERN_GUID(MF_TOPOLOGY_ENUMERATE_SOURCE_TYPES, 0x6248c36d, 0x5d0b, 0x4f40, 0xa0, 0xbb, 0xb0, 0xb3, 0x05, 0xf7, 0x76, 0x98); +EXTERN_GUID( MF_TOPOLOGY_START_TIME_ON_PRESENTATION_SWITCH, 0xc8cc113f, 0x7951, 0x4548, 0xaa, 0xd6, 0x9e, 0xd6, 0x20, 0x2e, 0x62, 0xb3); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#if (WINVER >= _WIN32_WINNT_WIN8) +EXTERN_GUID( MF_DISABLE_LOCALLY_REGISTERED_PLUGINS, 0x66b16da9, 0xadd4, 0x47e0, 0xa1, 0x6b, 0x5a, 0xf1, 0xfb, 0x48, 0x36, 0x34); +EXTERN_GUID( MF_LOCAL_PLUGIN_CONTROL_POLICY, 0xd91b0085, 0xc86d, 0x4f81, 0x88, 0x22, 0x8c, 0x68, 0xe1, 0xd7, 0xfa, 0x04); +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#pragma region PC Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP) +STDAPI MFCreateTopology( + _Outptr_ IMFTopology ** ppTopo ); +typedef +enum MF_TOPOLOGY_TYPE + { + MF_TOPOLOGY_OUTPUT_NODE = 0, + MF_TOPOLOGY_SOURCESTREAM_NODE = ( MF_TOPOLOGY_OUTPUT_NODE + 1 ) , + MF_TOPOLOGY_TRANSFORM_NODE = ( MF_TOPOLOGY_SOURCESTREAM_NODE + 1 ) , + MF_TOPOLOGY_TEE_NODE = ( MF_TOPOLOGY_TRANSFORM_NODE + 1 ) , + MF_TOPOLOGY_MAX = 0xffffffff + } MF_TOPOLOGY_TYPE; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0018_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0018_v0_0_s_ifspec; + +#ifndef __IMFTopologyNode_INTERFACE_DEFINED__ +#define __IMFTopologyNode_INTERFACE_DEFINED__ + +/* interface IMFTopologyNode */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFTopologyNode; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("83CF873A-F6DA-4bc8-823F-BACFD55DC430") + IMFTopologyNode : public IMFAttributes + { + public: + virtual HRESULT STDMETHODCALLTYPE SetObject( + /* [in] */ __RPC__in_opt IUnknown *pObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetObject( + /* [out] */ __RPC__deref_out_opt IUnknown **ppObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetNodeType( + /* [out] */ __RPC__out MF_TOPOLOGY_TYPE *pType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTopoNodeID( + /* [out] */ __RPC__out TOPOID *pID) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTopoNodeID( + /* [in] */ TOPOID ullTopoID) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputCount( + /* [out] */ __RPC__out DWORD *pcInputs) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputCount( + /* [out] */ __RPC__out DWORD *pcOutputs) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE ConnectOutput( + /* [in] */ DWORD dwOutputIndex, + /* [in] */ IMFTopologyNode *pDownstreamNode, + /* [in] */ DWORD dwInputIndexOnDownstreamNode) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE DisconnectOutput( + /* [in] */ DWORD dwOutputIndex) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInput( + /* [in] */ DWORD dwInputIndex, + /* [out] */ __RPC__deref_out_opt IMFTopologyNode **ppUpstreamNode, + /* [out] */ __RPC__out DWORD *pdwOutputIndexOnUpstreamNode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutput( + /* [in] */ DWORD dwOutputIndex, + /* [out] */ __RPC__deref_out_opt IMFTopologyNode **ppDownstreamNode, + /* [out] */ __RPC__out DWORD *pdwInputIndexOnDownstreamNode) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE SetOutputPrefType( + /* [in] */ DWORD dwOutputIndex, + /* [in] */ IMFMediaType *pType) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE GetOutputPrefType( + /* [in] */ DWORD dwOutputIndex, + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppType) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE SetInputPrefType( + /* [in] */ DWORD dwInputIndex, + /* [in] */ IMFMediaType *pType) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE GetInputPrefType( + /* [in] */ DWORD dwInputIndex, + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppType) = 0; + + virtual HRESULT STDMETHODCALLTYPE CloneFrom( + /* [in] */ __RPC__in_opt IMFTopologyNode *pNode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTopologyNodeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFTopologyNode * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFTopologyNode * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFTopologyNode * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + __RPC__in IMFTopologyNode * This, + __RPC__in_opt IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cchBufSize) LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(( *pcchLength + 1 ) ) LPWSTR *ppwszValue, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cbBufSize) UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbSize) UINT8 **ppBuf, + /* [out] */ __RPC__out UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + __RPC__in IMFTopologyNode * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + __RPC__in REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [string][in] */ __RPC__in_string LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [size_is][in] */ __RPC__in_ecount_full(cbBufSize) const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + __RPC__in IMFTopologyNode * This, + __RPC__in REFGUID guidKey, + /* [in] */ __RPC__in_opt IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + __RPC__in IMFTopologyNode * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + __RPC__in IMFTopologyNode * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + __RPC__in IMFTopologyNode * This, + /* [out] */ __RPC__out UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + __RPC__in IMFTopologyNode * This, + UINT32 unIndex, + /* [out] */ __RPC__out GUID *pguidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + __RPC__in IMFTopologyNode * This, + /* [in] */ __RPC__in_opt IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *SetObject )( + __RPC__in IMFTopologyNode * This, + /* [in] */ __RPC__in_opt IUnknown *pObject); + + HRESULT ( STDMETHODCALLTYPE *GetObject )( + __RPC__in IMFTopologyNode * This, + /* [out] */ __RPC__deref_out_opt IUnknown **ppObject); + + HRESULT ( STDMETHODCALLTYPE *GetNodeType )( + __RPC__in IMFTopologyNode * This, + /* [out] */ __RPC__out MF_TOPOLOGY_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *GetTopoNodeID )( + __RPC__in IMFTopologyNode * This, + /* [out] */ __RPC__out TOPOID *pID); + + HRESULT ( STDMETHODCALLTYPE *SetTopoNodeID )( + __RPC__in IMFTopologyNode * This, + /* [in] */ TOPOID ullTopoID); + + HRESULT ( STDMETHODCALLTYPE *GetInputCount )( + __RPC__in IMFTopologyNode * This, + /* [out] */ __RPC__out DWORD *pcInputs); + + HRESULT ( STDMETHODCALLTYPE *GetOutputCount )( + __RPC__in IMFTopologyNode * This, + /* [out] */ __RPC__out DWORD *pcOutputs); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *ConnectOutput )( + IMFTopologyNode * This, + /* [in] */ DWORD dwOutputIndex, + /* [in] */ IMFTopologyNode *pDownstreamNode, + /* [in] */ DWORD dwInputIndexOnDownstreamNode); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *DisconnectOutput )( + IMFTopologyNode * This, + /* [in] */ DWORD dwOutputIndex); + + HRESULT ( STDMETHODCALLTYPE *GetInput )( + __RPC__in IMFTopologyNode * This, + /* [in] */ DWORD dwInputIndex, + /* [out] */ __RPC__deref_out_opt IMFTopologyNode **ppUpstreamNode, + /* [out] */ __RPC__out DWORD *pdwOutputIndexOnUpstreamNode); + + HRESULT ( STDMETHODCALLTYPE *GetOutput )( + __RPC__in IMFTopologyNode * This, + /* [in] */ DWORD dwOutputIndex, + /* [out] */ __RPC__deref_out_opt IMFTopologyNode **ppDownstreamNode, + /* [out] */ __RPC__out DWORD *pdwInputIndexOnDownstreamNode); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetOutputPrefType )( + IMFTopologyNode * This, + /* [in] */ DWORD dwOutputIndex, + /* [in] */ IMFMediaType *pType); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *GetOutputPrefType )( + IMFTopologyNode * This, + /* [in] */ DWORD dwOutputIndex, + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppType); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetInputPrefType )( + IMFTopologyNode * This, + /* [in] */ DWORD dwInputIndex, + /* [in] */ IMFMediaType *pType); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *GetInputPrefType )( + IMFTopologyNode * This, + /* [in] */ DWORD dwInputIndex, + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppType); + + HRESULT ( STDMETHODCALLTYPE *CloneFrom )( + __RPC__in IMFTopologyNode * This, + /* [in] */ __RPC__in_opt IMFTopologyNode *pNode); + + END_INTERFACE + } IMFTopologyNodeVtbl; + + interface IMFTopologyNode + { + CONST_VTBL struct IMFTopologyNodeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTopologyNode_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTopologyNode_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTopologyNode_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTopologyNode_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFTopologyNode_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFTopologyNode_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFTopologyNode_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFTopologyNode_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFTopologyNode_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFTopologyNode_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFTopologyNode_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFTopologyNode_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFTopologyNode_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFTopologyNode_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFTopologyNode_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFTopologyNode_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFTopologyNode_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFTopologyNode_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFTopologyNode_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFTopologyNode_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFTopologyNode_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFTopologyNode_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFTopologyNode_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFTopologyNode_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFTopologyNode_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFTopologyNode_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFTopologyNode_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFTopologyNode_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFTopologyNode_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFTopologyNode_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFTopologyNode_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFTopologyNode_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFTopologyNode_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFTopologyNode_SetObject(This,pObject) \ + ( (This)->lpVtbl -> SetObject(This,pObject) ) + +#define IMFTopologyNode_GetObject(This,ppObject) \ + ( (This)->lpVtbl -> GetObject(This,ppObject) ) + +#define IMFTopologyNode_GetNodeType(This,pType) \ + ( (This)->lpVtbl -> GetNodeType(This,pType) ) + +#define IMFTopologyNode_GetTopoNodeID(This,pID) \ + ( (This)->lpVtbl -> GetTopoNodeID(This,pID) ) + +#define IMFTopologyNode_SetTopoNodeID(This,ullTopoID) \ + ( (This)->lpVtbl -> SetTopoNodeID(This,ullTopoID) ) + +#define IMFTopologyNode_GetInputCount(This,pcInputs) \ + ( (This)->lpVtbl -> GetInputCount(This,pcInputs) ) + +#define IMFTopologyNode_GetOutputCount(This,pcOutputs) \ + ( (This)->lpVtbl -> GetOutputCount(This,pcOutputs) ) + +#define IMFTopologyNode_ConnectOutput(This,dwOutputIndex,pDownstreamNode,dwInputIndexOnDownstreamNode) \ + ( (This)->lpVtbl -> ConnectOutput(This,dwOutputIndex,pDownstreamNode,dwInputIndexOnDownstreamNode) ) + +#define IMFTopologyNode_DisconnectOutput(This,dwOutputIndex) \ + ( (This)->lpVtbl -> DisconnectOutput(This,dwOutputIndex) ) + +#define IMFTopologyNode_GetInput(This,dwInputIndex,ppUpstreamNode,pdwOutputIndexOnUpstreamNode) \ + ( (This)->lpVtbl -> GetInput(This,dwInputIndex,ppUpstreamNode,pdwOutputIndexOnUpstreamNode) ) + +#define IMFTopologyNode_GetOutput(This,dwOutputIndex,ppDownstreamNode,pdwInputIndexOnDownstreamNode) \ + ( (This)->lpVtbl -> GetOutput(This,dwOutputIndex,ppDownstreamNode,pdwInputIndexOnDownstreamNode) ) + +#define IMFTopologyNode_SetOutputPrefType(This,dwOutputIndex,pType) \ + ( (This)->lpVtbl -> SetOutputPrefType(This,dwOutputIndex,pType) ) + +#define IMFTopologyNode_GetOutputPrefType(This,dwOutputIndex,ppType) \ + ( (This)->lpVtbl -> GetOutputPrefType(This,dwOutputIndex,ppType) ) + +#define IMFTopologyNode_SetInputPrefType(This,dwInputIndex,pType) \ + ( (This)->lpVtbl -> SetInputPrefType(This,dwInputIndex,pType) ) + +#define IMFTopologyNode_GetInputPrefType(This,dwInputIndex,ppType) \ + ( (This)->lpVtbl -> GetInputPrefType(This,dwInputIndex,ppType) ) + +#define IMFTopologyNode_CloneFrom(This,pNode) \ + ( (This)->lpVtbl -> CloneFrom(This,pNode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFTopologyNode_RemoteGetOutputPrefType_Proxy( + __RPC__in IMFTopologyNode * This, + /* [in] */ DWORD dwOutputIndex, + /* [out] */ __RPC__out DWORD *pcbData, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbData) BYTE **ppbData); + + +void __RPC_STUB IMFTopologyNode_RemoteGetOutputPrefType_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFTopologyNode_RemoteGetInputPrefType_Proxy( + __RPC__in IMFTopologyNode * This, + /* [in] */ DWORD dwInputIndex, + /* [out] */ __RPC__out DWORD *pcbData, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbData) BYTE **ppbData); + + +void __RPC_STUB IMFTopologyNode_RemoteGetInputPrefType_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMFTopologyNode_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0019 */ +/* [local] */ + +typedef +enum _MF_TOPONODE_FLUSH_MODE + { + MF_TOPONODE_FLUSH_ALWAYS = 0, + MF_TOPONODE_FLUSH_SEEK = ( MF_TOPONODE_FLUSH_ALWAYS + 1 ) , + MF_TOPONODE_FLUSH_NEVER = ( MF_TOPONODE_FLUSH_SEEK + 1 ) + } MF_TOPONODE_FLUSH_MODE; + +EXTERN_GUID( MF_TOPONODE_FLUSH, 0x494bbce8, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +typedef +enum _MF_TOPONODE_DRAIN_MODE + { + MF_TOPONODE_DRAIN_DEFAULT = 0, + MF_TOPONODE_DRAIN_ALWAYS = ( MF_TOPONODE_DRAIN_DEFAULT + 1 ) , + MF_TOPONODE_DRAIN_NEVER = ( MF_TOPONODE_DRAIN_ALWAYS + 1 ) + } MF_TOPONODE_DRAIN_MODE; + +EXTERN_GUID( MF_TOPONODE_DRAIN, 0x494bbce9, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_D3DAWARE, 0x494bbced, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPOLOGY_RESOLUTION_STATUS, 0x494bbcde, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_ERRORCODE, 0x494bbcee, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_CONNECT_METHOD, 0x494bbcf1, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_LOCKED, 0x494bbcf7, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_WORKQUEUE_ID, 0x494bbcf8, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_WORKQUEUE_MMCSS_CLASS, 0x494bbcf9, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_DECRYPTOR, 0x494bbcfa, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_DISCARDABLE, 0x494bbcfb, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_ERROR_MAJORTYPE, 0x494bbcfd, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_ERROR_SUBTYPE, 0x494bbcfe, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_WORKQUEUE_MMCSS_TASKID, 0x494bbcff, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_WORKQUEUE_MMCSS_PRIORITY, 0x5001f840, 0x2816, 0x48f4, 0x93, 0x64, 0xad, 0x1e, 0xf6, 0x61, 0xa1, 0x23); +EXTERN_GUID( MF_TOPONODE_WORKQUEUE_ITEM_PRIORITY, 0xa1ff99be, 0x5e97, 0x4a53, 0xb4, 0x94, 0x56, 0x8c, 0x64, 0x2c, 0x0f, 0xf3); +EXTERN_GUID( MF_TOPONODE_MARKIN_HERE, 0x494bbd00, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_MARKOUT_HERE, 0x494bbd01, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_DECODER, 0x494bbd02, 0xb031, 0x4e38, 0x97, 0xc4, 0xd5, 0x42, 0x2d, 0xd6, 0x18, 0xdc); +EXTERN_GUID( MF_TOPONODE_MEDIASTART, 0x835c58ea, 0xe075, 0x4bc7, 0xbc, 0xba, 0x4d, 0xe0, 0x00, 0xdf, 0x9a, 0xe6); +EXTERN_GUID( MF_TOPONODE_MEDIASTOP, 0x835c58eb, 0xe075, 0x4bc7, 0xbc, 0xba, 0x4d, 0xe0, 0x00, 0xdf, 0x9a, 0xe6); +EXTERN_GUID( MF_TOPONODE_SOURCE, 0x835c58ec, 0xe075, 0x4bc7, 0xbc, 0xba, 0x4d, 0xe0, 0x00, 0xdf, 0x9a, 0xe6); +EXTERN_GUID( MF_TOPONODE_PRESENTATION_DESCRIPTOR, 0x835c58ed, 0xe075, 0x4bc7, 0xbc, 0xba, 0x4d, 0xe0, 0x00, 0xdf, 0x9a, 0xe6); +EXTERN_GUID( MF_TOPONODE_STREAM_DESCRIPTOR, 0x835c58ee, 0xe075, 0x4bc7, 0xbc, 0xba, 0x4d, 0xe0, 0x00, 0xdf, 0x9a, 0xe6); +EXTERN_GUID( MF_TOPONODE_SEQUENCE_ELEMENTID, 0x835c58ef, 0xe075, 0x4bc7, 0xbc, 0xba, 0x4d, 0xe0, 0x00, 0xdf, 0x9a, 0xe6); +EXTERN_GUID( MF_TOPONODE_TRANSFORM_OBJECTID, 0x88dcc0c9, 0x293e, 0x4e8b, 0x9a, 0xeb, 0xa, 0xd6, 0x4c, 0xc0, 0x16, 0xb0); +EXTERN_GUID( MF_TOPONODE_STREAMID, 0x14932f9b, 0x9087, 0x4bb4, 0x84, 0x12, 0x51, 0x67, 0x14, 0x5c, 0xbe, 0x04); +EXTERN_GUID( MF_TOPONODE_NOSHUTDOWN_ON_REMOVE, 0x14932f9c, 0x9087, 0x4bb4, 0x84, 0x12, 0x51, 0x67, 0x14, 0x5c, 0xbe, 0x04); +EXTERN_GUID( MF_TOPONODE_RATELESS, 0x14932f9d, 0x9087, 0x4bb4, 0x84, 0x12, 0x51, 0x67, 0x14, 0x5c, 0xbe, 0x04); +EXTERN_GUID( MF_TOPONODE_DISABLE_PREROLL, 0x14932f9e, 0x9087, 0x4bb4, 0x84, 0x12, 0x51, 0x67, 0x14, 0x5c, 0xbe, 0x04); +EXTERN_GUID( MF_TOPONODE_PRIMARYOUTPUT, 0x6304ef99, 0x16b2, 0x4ebe, 0x9d, 0x67, 0xe4, 0xc5, 0x39, 0xb3, 0xa2, 0x59); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region PC Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP) +STDAPI MFCreateTopologyNode( + MF_TOPOLOGY_TYPE NodeType, + _Outptr_ IMFTopologyNode ** ppNode ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +#if (WINVER >= _WIN32_WINNT_WIN7) +STDAPI MFGetTopoNodeCurrentType( + IMFTopologyNode* pNode, + DWORD dwStreamIndex, + BOOL fOutput, + _Outptr_ IMFMediaType** ppType); +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0019_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0019_v0_0_s_ifspec; + +#ifndef __IMFGetService_INTERFACE_DEFINED__ +#define __IMFGetService_INTERFACE_DEFINED__ + +/* interface IMFGetService */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFGetService; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("fa993888-4383-415a-a930-dd472a8cf6f7") + IMFGetService : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetService( + /* [in] */ __RPC__in REFGUID guidService, + /* [in] */ __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppvObject) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFGetServiceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFGetService * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFGetService * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFGetService * This); + + HRESULT ( STDMETHODCALLTYPE *GetService )( + __RPC__in IMFGetService * This, + /* [in] */ __RPC__in REFGUID guidService, + /* [in] */ __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppvObject); + + END_INTERFACE + } IMFGetServiceVtbl; + + interface IMFGetService + { + CONST_VTBL struct IMFGetServiceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFGetService_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFGetService_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFGetService_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFGetService_GetService(This,guidService,riid,ppvObject) \ + ( (This)->lpVtbl -> GetService(This,guidService,riid,ppvObject) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFGetService_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0020 */ +/* [local] */ + +STDAPI MFGetService( + IUnknown* punkObject, + REFGUID guidService, + REFIID riid, + _Outptr_ LPVOID* ppvObject + ); +typedef LONGLONG MFTIME; + +typedef +enum _MFCLOCK_CHARACTERISTICS_FLAGS + { + MFCLOCK_CHARACTERISTICS_FLAG_FREQUENCY_10MHZ = 0x2, + MFCLOCK_CHARACTERISTICS_FLAG_ALWAYS_RUNNING = 0x4, + MFCLOCK_CHARACTERISTICS_FLAG_IS_SYSTEM_CLOCK = 0x8 + } MFCLOCK_CHARACTERISTICS_FLAGS; + +typedef +enum _MFCLOCK_STATE + { + MFCLOCK_STATE_INVALID = 0, + MFCLOCK_STATE_RUNNING = ( MFCLOCK_STATE_INVALID + 1 ) , + MFCLOCK_STATE_STOPPED = ( MFCLOCK_STATE_RUNNING + 1 ) , + MFCLOCK_STATE_PAUSED = ( MFCLOCK_STATE_STOPPED + 1 ) + } MFCLOCK_STATE; + +typedef +enum _MFCLOCK_RELATIONAL_FLAGS + { + MFCLOCK_RELATIONAL_FLAG_JITTER_NEVER_AHEAD = 0x1 + } MFCLOCK_RELATIONAL_FLAGS; + +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +#pragma warning(push) +#pragma warning(disable:4820) // Disable C4820: padding after data member +#endif +typedef struct _MFCLOCK_PROPERTIES + { + unsigned __int64 qwCorrelationRate; + GUID guidClockId; + DWORD dwClockFlags; + unsigned __int64 qwClockFrequency; + DWORD dwClockTolerance; + DWORD dwClockJitter; + } MFCLOCK_PROPERTIES; + +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +#pragma warning(pop) +#endif +#define MFCLOCK_FREQUENCY_HNS 10000000 +#define MFCLOCK_TOLERANCE_UNKNOWN 50000 +#define MFCLOCK_JITTER_ISR 1000 +#define MFCLOCK_JITTER_DPC 4000 +#define MFCLOCK_JITTER_PASSIVE 10000 + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0020_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0020_v0_0_s_ifspec; + +#ifndef __IMFClock_INTERFACE_DEFINED__ +#define __IMFClock_INTERFACE_DEFINED__ + +/* interface IMFClock */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFClock; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2eb1e945-18b8-4139-9b1a-d5d584818530") + IMFClock : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetClockCharacteristics( + /* [out] */ __RPC__out DWORD *pdwCharacteristics) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCorrelatedTime( + /* [in] */ DWORD dwReserved, + /* [out] */ __RPC__out LONGLONG *pllClockTime, + /* [out] */ __RPC__out MFTIME *phnsSystemTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetContinuityKey( + /* [out] */ __RPC__out DWORD *pdwContinuityKey) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetState( + /* [in] */ DWORD dwReserved, + /* [out] */ __RPC__out MFCLOCK_STATE *peClockState) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetProperties( + /* [out] */ __RPC__out MFCLOCK_PROPERTIES *pClockProperties) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFClockVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFClock * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFClock * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFClock * This); + + HRESULT ( STDMETHODCALLTYPE *GetClockCharacteristics )( + __RPC__in IMFClock * This, + /* [out] */ __RPC__out DWORD *pdwCharacteristics); + + HRESULT ( STDMETHODCALLTYPE *GetCorrelatedTime )( + __RPC__in IMFClock * This, + /* [in] */ DWORD dwReserved, + /* [out] */ __RPC__out LONGLONG *pllClockTime, + /* [out] */ __RPC__out MFTIME *phnsSystemTime); + + HRESULT ( STDMETHODCALLTYPE *GetContinuityKey )( + __RPC__in IMFClock * This, + /* [out] */ __RPC__out DWORD *pdwContinuityKey); + + HRESULT ( STDMETHODCALLTYPE *GetState )( + __RPC__in IMFClock * This, + /* [in] */ DWORD dwReserved, + /* [out] */ __RPC__out MFCLOCK_STATE *peClockState); + + HRESULT ( STDMETHODCALLTYPE *GetProperties )( + __RPC__in IMFClock * This, + /* [out] */ __RPC__out MFCLOCK_PROPERTIES *pClockProperties); + + END_INTERFACE + } IMFClockVtbl; + + interface IMFClock + { + CONST_VTBL struct IMFClockVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFClock_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFClock_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFClock_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFClock_GetClockCharacteristics(This,pdwCharacteristics) \ + ( (This)->lpVtbl -> GetClockCharacteristics(This,pdwCharacteristics) ) + +#define IMFClock_GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime) \ + ( (This)->lpVtbl -> GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime) ) + +#define IMFClock_GetContinuityKey(This,pdwContinuityKey) \ + ( (This)->lpVtbl -> GetContinuityKey(This,pdwContinuityKey) ) + +#define IMFClock_GetState(This,dwReserved,peClockState) \ + ( (This)->lpVtbl -> GetState(This,dwReserved,peClockState) ) + +#define IMFClock_GetProperties(This,pClockProperties) \ + ( (This)->lpVtbl -> GetProperties(This,pClockProperties) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFClock_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0021 */ +/* [local] */ + +STDAPI_(MFTIME) +MFGetSystemTime( + ); +#define PRESENTATION_CURRENT_POSITION 0x7fffffffffffffff + + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0021_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0021_v0_0_s_ifspec; + +#ifndef __IMFPresentationClock_INTERFACE_DEFINED__ +#define __IMFPresentationClock_INTERFACE_DEFINED__ + +/* interface IMFPresentationClock */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFPresentationClock; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("868CE85C-8EA9-4f55-AB82-B009A910A805") + IMFPresentationClock : public IMFClock + { + public: + virtual HRESULT STDMETHODCALLTYPE SetTimeSource( + /* [in] */ __RPC__in_opt IMFPresentationTimeSource *pTimeSource) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimeSource( + /* [out] */ __RPC__deref_out_opt IMFPresentationTimeSource **ppTimeSource) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTime( + /* [out] */ __RPC__out MFTIME *phnsClockTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddClockStateSink( + /* [in] */ __RPC__in_opt IMFClockStateSink *pStateSink) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveClockStateSink( + /* [in] */ __RPC__in_opt IMFClockStateSink *pStateSink) = 0; + + virtual HRESULT STDMETHODCALLTYPE Start( + /* [in] */ LONGLONG llClockStartOffset) = 0; + + virtual HRESULT STDMETHODCALLTYPE Stop( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Pause( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFPresentationClockVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFPresentationClock * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFPresentationClock * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFPresentationClock * This); + + HRESULT ( STDMETHODCALLTYPE *GetClockCharacteristics )( + __RPC__in IMFPresentationClock * This, + /* [out] */ __RPC__out DWORD *pdwCharacteristics); + + HRESULT ( STDMETHODCALLTYPE *GetCorrelatedTime )( + __RPC__in IMFPresentationClock * This, + /* [in] */ DWORD dwReserved, + /* [out] */ __RPC__out LONGLONG *pllClockTime, + /* [out] */ __RPC__out MFTIME *phnsSystemTime); + + HRESULT ( STDMETHODCALLTYPE *GetContinuityKey )( + __RPC__in IMFPresentationClock * This, + /* [out] */ __RPC__out DWORD *pdwContinuityKey); + + HRESULT ( STDMETHODCALLTYPE *GetState )( + __RPC__in IMFPresentationClock * This, + /* [in] */ DWORD dwReserved, + /* [out] */ __RPC__out MFCLOCK_STATE *peClockState); + + HRESULT ( STDMETHODCALLTYPE *GetProperties )( + __RPC__in IMFPresentationClock * This, + /* [out] */ __RPC__out MFCLOCK_PROPERTIES *pClockProperties); + + HRESULT ( STDMETHODCALLTYPE *SetTimeSource )( + __RPC__in IMFPresentationClock * This, + /* [in] */ __RPC__in_opt IMFPresentationTimeSource *pTimeSource); + + HRESULT ( STDMETHODCALLTYPE *GetTimeSource )( + __RPC__in IMFPresentationClock * This, + /* [out] */ __RPC__deref_out_opt IMFPresentationTimeSource **ppTimeSource); + + HRESULT ( STDMETHODCALLTYPE *GetTime )( + __RPC__in IMFPresentationClock * This, + /* [out] */ __RPC__out MFTIME *phnsClockTime); + + HRESULT ( STDMETHODCALLTYPE *AddClockStateSink )( + __RPC__in IMFPresentationClock * This, + /* [in] */ __RPC__in_opt IMFClockStateSink *pStateSink); + + HRESULT ( STDMETHODCALLTYPE *RemoveClockStateSink )( + __RPC__in IMFPresentationClock * This, + /* [in] */ __RPC__in_opt IMFClockStateSink *pStateSink); + + HRESULT ( STDMETHODCALLTYPE *Start )( + __RPC__in IMFPresentationClock * This, + /* [in] */ LONGLONG llClockStartOffset); + + HRESULT ( STDMETHODCALLTYPE *Stop )( + __RPC__in IMFPresentationClock * This); + + HRESULT ( STDMETHODCALLTYPE *Pause )( + __RPC__in IMFPresentationClock * This); + + END_INTERFACE + } IMFPresentationClockVtbl; + + interface IMFPresentationClock + { + CONST_VTBL struct IMFPresentationClockVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFPresentationClock_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFPresentationClock_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFPresentationClock_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFPresentationClock_GetClockCharacteristics(This,pdwCharacteristics) \ + ( (This)->lpVtbl -> GetClockCharacteristics(This,pdwCharacteristics) ) + +#define IMFPresentationClock_GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime) \ + ( (This)->lpVtbl -> GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime) ) + +#define IMFPresentationClock_GetContinuityKey(This,pdwContinuityKey) \ + ( (This)->lpVtbl -> GetContinuityKey(This,pdwContinuityKey) ) + +#define IMFPresentationClock_GetState(This,dwReserved,peClockState) \ + ( (This)->lpVtbl -> GetState(This,dwReserved,peClockState) ) + +#define IMFPresentationClock_GetProperties(This,pClockProperties) \ + ( (This)->lpVtbl -> GetProperties(This,pClockProperties) ) + + +#define IMFPresentationClock_SetTimeSource(This,pTimeSource) \ + ( (This)->lpVtbl -> SetTimeSource(This,pTimeSource) ) + +#define IMFPresentationClock_GetTimeSource(This,ppTimeSource) \ + ( (This)->lpVtbl -> GetTimeSource(This,ppTimeSource) ) + +#define IMFPresentationClock_GetTime(This,phnsClockTime) \ + ( (This)->lpVtbl -> GetTime(This,phnsClockTime) ) + +#define IMFPresentationClock_AddClockStateSink(This,pStateSink) \ + ( (This)->lpVtbl -> AddClockStateSink(This,pStateSink) ) + +#define IMFPresentationClock_RemoveClockStateSink(This,pStateSink) \ + ( (This)->lpVtbl -> RemoveClockStateSink(This,pStateSink) ) + +#define IMFPresentationClock_Start(This,llClockStartOffset) \ + ( (This)->lpVtbl -> Start(This,llClockStartOffset) ) + +#define IMFPresentationClock_Stop(This) \ + ( (This)->lpVtbl -> Stop(This) ) + +#define IMFPresentationClock_Pause(This) \ + ( (This)->lpVtbl -> Pause(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFPresentationClock_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0022 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region PC Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP) +STDAPI MFCreatePresentationClock( + _Outptr_ IMFPresentationClock** ppPresentationClock + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0022_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0022_v0_0_s_ifspec; + +#ifndef __IMFPresentationTimeSource_INTERFACE_DEFINED__ +#define __IMFPresentationTimeSource_INTERFACE_DEFINED__ + +/* interface IMFPresentationTimeSource */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFPresentationTimeSource; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7FF12CCE-F76F-41c2-863B-1666C8E5E139") + IMFPresentationTimeSource : public IMFClock + { + public: + virtual HRESULT STDMETHODCALLTYPE GetUnderlyingClock( + /* [out] */ __RPC__deref_out_opt IMFClock **ppClock) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFPresentationTimeSourceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFPresentationTimeSource * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFPresentationTimeSource * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFPresentationTimeSource * This); + + HRESULT ( STDMETHODCALLTYPE *GetClockCharacteristics )( + __RPC__in IMFPresentationTimeSource * This, + /* [out] */ __RPC__out DWORD *pdwCharacteristics); + + HRESULT ( STDMETHODCALLTYPE *GetCorrelatedTime )( + __RPC__in IMFPresentationTimeSource * This, + /* [in] */ DWORD dwReserved, + /* [out] */ __RPC__out LONGLONG *pllClockTime, + /* [out] */ __RPC__out MFTIME *phnsSystemTime); + + HRESULT ( STDMETHODCALLTYPE *GetContinuityKey )( + __RPC__in IMFPresentationTimeSource * This, + /* [out] */ __RPC__out DWORD *pdwContinuityKey); + + HRESULT ( STDMETHODCALLTYPE *GetState )( + __RPC__in IMFPresentationTimeSource * This, + /* [in] */ DWORD dwReserved, + /* [out] */ __RPC__out MFCLOCK_STATE *peClockState); + + HRESULT ( STDMETHODCALLTYPE *GetProperties )( + __RPC__in IMFPresentationTimeSource * This, + /* [out] */ __RPC__out MFCLOCK_PROPERTIES *pClockProperties); + + HRESULT ( STDMETHODCALLTYPE *GetUnderlyingClock )( + __RPC__in IMFPresentationTimeSource * This, + /* [out] */ __RPC__deref_out_opt IMFClock **ppClock); + + END_INTERFACE + } IMFPresentationTimeSourceVtbl; + + interface IMFPresentationTimeSource + { + CONST_VTBL struct IMFPresentationTimeSourceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFPresentationTimeSource_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFPresentationTimeSource_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFPresentationTimeSource_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFPresentationTimeSource_GetClockCharacteristics(This,pdwCharacteristics) \ + ( (This)->lpVtbl -> GetClockCharacteristics(This,pdwCharacteristics) ) + +#define IMFPresentationTimeSource_GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime) \ + ( (This)->lpVtbl -> GetCorrelatedTime(This,dwReserved,pllClockTime,phnsSystemTime) ) + +#define IMFPresentationTimeSource_GetContinuityKey(This,pdwContinuityKey) \ + ( (This)->lpVtbl -> GetContinuityKey(This,pdwContinuityKey) ) + +#define IMFPresentationTimeSource_GetState(This,dwReserved,peClockState) \ + ( (This)->lpVtbl -> GetState(This,dwReserved,peClockState) ) + +#define IMFPresentationTimeSource_GetProperties(This,pClockProperties) \ + ( (This)->lpVtbl -> GetProperties(This,pClockProperties) ) + + +#define IMFPresentationTimeSource_GetUnderlyingClock(This,ppClock) \ + ( (This)->lpVtbl -> GetUnderlyingClock(This,ppClock) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFPresentationTimeSource_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0023 */ +/* [local] */ + +STDAPI +MFCreateSystemTimeSource( + _Outptr_ IMFPresentationTimeSource** ppSystemTimeSource + ); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0023_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0023_v0_0_s_ifspec; + +#ifndef __IMFClockStateSink_INTERFACE_DEFINED__ +#define __IMFClockStateSink_INTERFACE_DEFINED__ + +/* interface IMFClockStateSink */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFClockStateSink; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F6696E82-74F7-4f3d-A178-8A5E09C3659F") + IMFClockStateSink : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE OnClockStart( + /* [in] */ MFTIME hnsSystemTime, + /* [in] */ LONGLONG llClockStartOffset) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnClockStop( + /* [in] */ MFTIME hnsSystemTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnClockPause( + /* [in] */ MFTIME hnsSystemTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnClockRestart( + /* [in] */ MFTIME hnsSystemTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnClockSetRate( + /* [in] */ MFTIME hnsSystemTime, + /* [in] */ float flRate) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFClockStateSinkVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFClockStateSink * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFClockStateSink * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFClockStateSink * This); + + HRESULT ( STDMETHODCALLTYPE *OnClockStart )( + __RPC__in IMFClockStateSink * This, + /* [in] */ MFTIME hnsSystemTime, + /* [in] */ LONGLONG llClockStartOffset); + + HRESULT ( STDMETHODCALLTYPE *OnClockStop )( + __RPC__in IMFClockStateSink * This, + /* [in] */ MFTIME hnsSystemTime); + + HRESULT ( STDMETHODCALLTYPE *OnClockPause )( + __RPC__in IMFClockStateSink * This, + /* [in] */ MFTIME hnsSystemTime); + + HRESULT ( STDMETHODCALLTYPE *OnClockRestart )( + __RPC__in IMFClockStateSink * This, + /* [in] */ MFTIME hnsSystemTime); + + HRESULT ( STDMETHODCALLTYPE *OnClockSetRate )( + __RPC__in IMFClockStateSink * This, + /* [in] */ MFTIME hnsSystemTime, + /* [in] */ float flRate); + + END_INTERFACE + } IMFClockStateSinkVtbl; + + interface IMFClockStateSink + { + CONST_VTBL struct IMFClockStateSinkVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFClockStateSink_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFClockStateSink_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFClockStateSink_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFClockStateSink_OnClockStart(This,hnsSystemTime,llClockStartOffset) \ + ( (This)->lpVtbl -> OnClockStart(This,hnsSystemTime,llClockStartOffset) ) + +#define IMFClockStateSink_OnClockStop(This,hnsSystemTime) \ + ( (This)->lpVtbl -> OnClockStop(This,hnsSystemTime) ) + +#define IMFClockStateSink_OnClockPause(This,hnsSystemTime) \ + ( (This)->lpVtbl -> OnClockPause(This,hnsSystemTime) ) + +#define IMFClockStateSink_OnClockRestart(This,hnsSystemTime) \ + ( (This)->lpVtbl -> OnClockRestart(This,hnsSystemTime) ) + +#define IMFClockStateSink_OnClockSetRate(This,hnsSystemTime,flRate) \ + ( (This)->lpVtbl -> OnClockSetRate(This,hnsSystemTime,flRate) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFClockStateSink_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0024 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +EXTERN_GUID( MF_PD_PMPHOST_CONTEXT, 0x6c990d31, 0xbb8e, 0x477a, 0x85, 0x98, 0xd, 0x5d, 0x96, 0xfc, 0xd8, 0x8a ); +EXTERN_GUID( MF_PD_APP_CONTEXT, 0x6c990d32, 0xbb8e, 0x477a, 0x85, 0x98, 0xd, 0x5d, 0x96, 0xfc, 0xd8, 0x8a ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_GUID( MF_PD_DURATION, 0x6c990d33, 0xbb8e, 0x477a, 0x85, 0x98, 0xd, 0x5d, 0x96, 0xfc, 0xd8, 0x8a ); +EXTERN_GUID( MF_PD_TOTAL_FILE_SIZE, 0x6c990d34, 0xbb8e, 0x477a, 0x85, 0x98, 0xd, 0x5d, 0x96, 0xfc, 0xd8, 0x8a ); +EXTERN_GUID( MF_PD_AUDIO_ENCODING_BITRATE, 0x6c990d35, 0xbb8e, 0x477a, 0x85, 0x98, 0xd, 0x5d, 0x96, 0xfc, 0xd8, 0x8a ); +EXTERN_GUID( MF_PD_VIDEO_ENCODING_BITRATE, 0x6c990d36, 0xbb8e, 0x477a, 0x85, 0x98, 0xd, 0x5d, 0x96, 0xfc, 0xd8, 0x8a ); +EXTERN_GUID( MF_PD_MIME_TYPE, 0x6c990d37, 0xbb8e, 0x477a, 0x85, 0x98, 0xd, 0x5d, 0x96, 0xfc, 0xd8, 0x8a ); +EXTERN_GUID(MF_PD_LAST_MODIFIED_TIME, 0x6c990d38, 0xbb8e, 0x477a, 0x85, 0x98, 0xd, 0x5d, 0x96, 0xfc, 0xd8, 0x8a ); +#if (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_GUID(MF_PD_PLAYBACK_ELEMENT_ID, 0x6c990d39, 0xbb8e, 0x477a, 0x85, 0x98, 0xd, 0x5d, 0x96, 0xfc, 0xd8, 0x8a ); +EXTERN_GUID( MF_PD_PREFERRED_LANGUAGE, 0x6c990d3A, 0xbb8e, 0x477a, 0x85, 0x98, 0xd, 0x5d, 0x96, 0xfc, 0xd8, 0x8a ); +EXTERN_GUID(MF_PD_PLAYBACK_BOUNDARY_TIME, 0x6c990d3b, 0xbb8e, 0x477a, 0x85, 0x98, 0xd, 0x5d, 0x96, 0xfc, 0xd8, 0x8a ); +EXTERN_GUID( MF_PD_AUDIO_ISVARIABLEBITRATE, 0x33026ee0, 0xe387, 0x4582, 0xae, 0x0a, 0x34, 0xa2, 0xad, 0x3b, 0xaa, 0x18 ); +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +DEFINE_GUID( MF_PD_ADAPTIVE_STREAMING, 0xEA0D5D97, 0x29F9, 0x488B, 0xAE, 0x6B, 0x7D, 0x6B, 0x41, 0x36, 0x11, 0x2B); +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0024_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0024_v0_0_s_ifspec; + +#ifndef __IMFPresentationDescriptor_INTERFACE_DEFINED__ +#define __IMFPresentationDescriptor_INTERFACE_DEFINED__ + +/* interface IMFPresentationDescriptor */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFPresentationDescriptor; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("03cb2711-24d7-4db6-a17f-f3a7a479a536") + IMFPresentationDescriptor : public IMFAttributes + { + public: + virtual HRESULT STDMETHODCALLTYPE GetStreamDescriptorCount( + /* [out] */ __RPC__out DWORD *pdwDescriptorCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamDescriptorByIndex( + /* [in] */ DWORD dwIndex, + /* [out] */ __RPC__out BOOL *pfSelected, + /* [out] */ __RPC__deref_out_opt IMFStreamDescriptor **ppDescriptor) = 0; + + virtual HRESULT STDMETHODCALLTYPE SelectStream( + /* [in] */ DWORD dwDescriptorIndex) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeselectStream( + /* [in] */ DWORD dwDescriptorIndex) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ __RPC__deref_out_opt IMFPresentationDescriptor **ppPresentationDescriptor) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFPresentationDescriptorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFPresentationDescriptor * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFPresentationDescriptor * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFPresentationDescriptor * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in_opt IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cchBufSize) LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(( *pcchLength + 1 ) ) LPWSTR *ppwszValue, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cbBufSize) UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbSize) UINT8 **ppBuf, + /* [out] */ __RPC__out UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + __RPC__in IMFPresentationDescriptor * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + __RPC__in REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [string][in] */ __RPC__in_string LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [size_is][in] */ __RPC__in_ecount_full(cbBufSize) const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + __RPC__in IMFPresentationDescriptor * This, + __RPC__in REFGUID guidKey, + /* [in] */ __RPC__in_opt IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + __RPC__in IMFPresentationDescriptor * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + __RPC__in IMFPresentationDescriptor * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + __RPC__in IMFPresentationDescriptor * This, + /* [out] */ __RPC__out UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + __RPC__in IMFPresentationDescriptor * This, + UINT32 unIndex, + /* [out] */ __RPC__out GUID *pguidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + __RPC__in IMFPresentationDescriptor * This, + /* [in] */ __RPC__in_opt IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *GetStreamDescriptorCount )( + __RPC__in IMFPresentationDescriptor * This, + /* [out] */ __RPC__out DWORD *pdwDescriptorCount); + + HRESULT ( STDMETHODCALLTYPE *GetStreamDescriptorByIndex )( + __RPC__in IMFPresentationDescriptor * This, + /* [in] */ DWORD dwIndex, + /* [out] */ __RPC__out BOOL *pfSelected, + /* [out] */ __RPC__deref_out_opt IMFStreamDescriptor **ppDescriptor); + + HRESULT ( STDMETHODCALLTYPE *SelectStream )( + __RPC__in IMFPresentationDescriptor * This, + /* [in] */ DWORD dwDescriptorIndex); + + HRESULT ( STDMETHODCALLTYPE *DeselectStream )( + __RPC__in IMFPresentationDescriptor * This, + /* [in] */ DWORD dwDescriptorIndex); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + __RPC__in IMFPresentationDescriptor * This, + /* [out] */ __RPC__deref_out_opt IMFPresentationDescriptor **ppPresentationDescriptor); + + END_INTERFACE + } IMFPresentationDescriptorVtbl; + + interface IMFPresentationDescriptor + { + CONST_VTBL struct IMFPresentationDescriptorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFPresentationDescriptor_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFPresentationDescriptor_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFPresentationDescriptor_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFPresentationDescriptor_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFPresentationDescriptor_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFPresentationDescriptor_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFPresentationDescriptor_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFPresentationDescriptor_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFPresentationDescriptor_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFPresentationDescriptor_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFPresentationDescriptor_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFPresentationDescriptor_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFPresentationDescriptor_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFPresentationDescriptor_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFPresentationDescriptor_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFPresentationDescriptor_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFPresentationDescriptor_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFPresentationDescriptor_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFPresentationDescriptor_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFPresentationDescriptor_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFPresentationDescriptor_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFPresentationDescriptor_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFPresentationDescriptor_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFPresentationDescriptor_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFPresentationDescriptor_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFPresentationDescriptor_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFPresentationDescriptor_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFPresentationDescriptor_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFPresentationDescriptor_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFPresentationDescriptor_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFPresentationDescriptor_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFPresentationDescriptor_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFPresentationDescriptor_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFPresentationDescriptor_GetStreamDescriptorCount(This,pdwDescriptorCount) \ + ( (This)->lpVtbl -> GetStreamDescriptorCount(This,pdwDescriptorCount) ) + +#define IMFPresentationDescriptor_GetStreamDescriptorByIndex(This,dwIndex,pfSelected,ppDescriptor) \ + ( (This)->lpVtbl -> GetStreamDescriptorByIndex(This,dwIndex,pfSelected,ppDescriptor) ) + +#define IMFPresentationDescriptor_SelectStream(This,dwDescriptorIndex) \ + ( (This)->lpVtbl -> SelectStream(This,dwDescriptorIndex) ) + +#define IMFPresentationDescriptor_DeselectStream(This,dwDescriptorIndex) \ + ( (This)->lpVtbl -> DeselectStream(This,dwDescriptorIndex) ) + +#define IMFPresentationDescriptor_Clone(This,ppPresentationDescriptor) \ + ( (This)->lpVtbl -> Clone(This,ppPresentationDescriptor) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFPresentationDescriptor_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0025 */ +/* [local] */ + +STDAPI MFCreatePresentationDescriptor( + DWORD cStreamDescriptors, + _In_reads_opt_( cStreamDescriptors ) IMFStreamDescriptor** apStreamDescriptors, + _Outptr_ IMFPresentationDescriptor** ppPresentationDescriptor + ); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +STDAPI MFRequireProtectedEnvironment( + _In_ IMFPresentationDescriptor* pPresentationDescriptor + ); + +STDAPI MFSerializePresentationDescriptor( + _In_ IMFPresentationDescriptor * pPD, + _Out_ DWORD * pcbData, + _Outptr_result_bytebuffer_to_(*pcbData, *pcbData) BYTE ** ppbData); + +STDAPI MFDeserializePresentationDescriptor( + _In_ DWORD cbData, + _In_reads_( cbData ) BYTE * pbData, + _Outptr_ IMFPresentationDescriptor ** ppPD); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_GUID(MF_SD_LANGUAGE, 0xaf2180, 0xbdc2, 0x423c, 0xab, 0xca, 0xf5, 0x3, 0x59, 0x3b, 0xc1, 0x21); +EXTERN_GUID(MF_SD_PROTECTED, 0xaf2181, 0xbdc2, 0x423c, 0xab, 0xca, 0xf5, 0x3, 0x59, 0x3b, 0xc1, 0x21); +EXTERN_GUID(MF_SD_STREAM_NAME, 0x4f1b099d, 0xd314, 0x41e5, 0xa7, 0x81, 0x7f, 0xef, 0xaa, 0x4c, 0x50, 0x1f); +EXTERN_GUID(MF_SD_MUTUALLY_EXCLUSIVE, 0x23ef79c, 0x388d, 0x487f, 0xac, 0x17, 0x69, 0x6c, 0xd6, 0xe3, 0xc6, 0xf5); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0025_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0025_v0_0_s_ifspec; + +#ifndef __IMFStreamDescriptor_INTERFACE_DEFINED__ +#define __IMFStreamDescriptor_INTERFACE_DEFINED__ + +/* interface IMFStreamDescriptor */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFStreamDescriptor; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("56c03d9c-9dbb-45f5-ab4b-d80f47c05938") + IMFStreamDescriptor : public IMFAttributes + { + public: + virtual HRESULT STDMETHODCALLTYPE GetStreamIdentifier( + /* [out] */ __RPC__out DWORD *pdwStreamIdentifier) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMediaTypeHandler( + /* [out] */ __RPC__deref_out_opt IMFMediaTypeHandler **ppMediaTypeHandler) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFStreamDescriptorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFStreamDescriptor * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFStreamDescriptor * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFStreamDescriptor * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in_opt IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cchBufSize) LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(( *pcchLength + 1 ) ) LPWSTR *ppwszValue, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cbBufSize) UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbSize) UINT8 **ppBuf, + /* [out] */ __RPC__out UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + __RPC__in IMFStreamDescriptor * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + __RPC__in REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [string][in] */ __RPC__in_string LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [size_is][in] */ __RPC__in_ecount_full(cbBufSize) const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + __RPC__in IMFStreamDescriptor * This, + __RPC__in REFGUID guidKey, + /* [in] */ __RPC__in_opt IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + __RPC__in IMFStreamDescriptor * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + __RPC__in IMFStreamDescriptor * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + __RPC__in IMFStreamDescriptor * This, + /* [out] */ __RPC__out UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + __RPC__in IMFStreamDescriptor * This, + UINT32 unIndex, + /* [out] */ __RPC__out GUID *pguidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + __RPC__in IMFStreamDescriptor * This, + /* [in] */ __RPC__in_opt IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *GetStreamIdentifier )( + __RPC__in IMFStreamDescriptor * This, + /* [out] */ __RPC__out DWORD *pdwStreamIdentifier); + + HRESULT ( STDMETHODCALLTYPE *GetMediaTypeHandler )( + __RPC__in IMFStreamDescriptor * This, + /* [out] */ __RPC__deref_out_opt IMFMediaTypeHandler **ppMediaTypeHandler); + + END_INTERFACE + } IMFStreamDescriptorVtbl; + + interface IMFStreamDescriptor + { + CONST_VTBL struct IMFStreamDescriptorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFStreamDescriptor_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFStreamDescriptor_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFStreamDescriptor_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFStreamDescriptor_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFStreamDescriptor_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFStreamDescriptor_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFStreamDescriptor_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFStreamDescriptor_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFStreamDescriptor_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFStreamDescriptor_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFStreamDescriptor_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFStreamDescriptor_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFStreamDescriptor_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFStreamDescriptor_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFStreamDescriptor_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFStreamDescriptor_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFStreamDescriptor_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFStreamDescriptor_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFStreamDescriptor_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFStreamDescriptor_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFStreamDescriptor_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFStreamDescriptor_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFStreamDescriptor_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFStreamDescriptor_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFStreamDescriptor_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFStreamDescriptor_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFStreamDescriptor_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFStreamDescriptor_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFStreamDescriptor_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFStreamDescriptor_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFStreamDescriptor_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFStreamDescriptor_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFStreamDescriptor_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFStreamDescriptor_GetStreamIdentifier(This,pdwStreamIdentifier) \ + ( (This)->lpVtbl -> GetStreamIdentifier(This,pdwStreamIdentifier) ) + +#define IMFStreamDescriptor_GetMediaTypeHandler(This,ppMediaTypeHandler) \ + ( (This)->lpVtbl -> GetMediaTypeHandler(This,ppMediaTypeHandler) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFStreamDescriptor_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0026 */ +/* [local] */ + +STDAPI MFCreateStreamDescriptor( + DWORD dwStreamIdentifier, + DWORD cMediaTypes, + _In_reads_(cMediaTypes) IMFMediaType** apMediaTypes, + _Outptr_ IMFStreamDescriptor** ppDescriptor + ); + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0026_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0026_v0_0_s_ifspec; + +#ifndef __IMFMediaTypeHandler_INTERFACE_DEFINED__ +#define __IMFMediaTypeHandler_INTERFACE_DEFINED__ + +/* interface IMFMediaTypeHandler */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaTypeHandler; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e93dcf6c-4b07-4e1e-8123-aa16ed6eadf5") + IMFMediaTypeHandler : public IUnknown + { + public: + virtual /* [local] */ HRESULT STDMETHODCALLTYPE IsMediaTypeSupported( + /* [in] */ IMFMediaType *pMediaType, + /* [annotation][out] */ + _Outptr_opt_result_maybenull_ IMFMediaType **ppMediaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMediaTypeCount( + /* [out] */ __RPC__out DWORD *pdwTypeCount) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE GetMediaTypeByIndex( + /* [in] */ DWORD dwIndex, + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppType) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE SetCurrentMediaType( + /* [in] */ IMFMediaType *pMediaType) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE GetCurrentMediaType( + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppMediaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMajorType( + /* [out] */ __RPC__out GUID *pguidMajorType) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaTypeHandlerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaTypeHandler * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaTypeHandler * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaTypeHandler * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *IsMediaTypeSupported )( + IMFMediaTypeHandler * This, + /* [in] */ IMFMediaType *pMediaType, + /* [annotation][out] */ + _Outptr_opt_result_maybenull_ IMFMediaType **ppMediaType); + + HRESULT ( STDMETHODCALLTYPE *GetMediaTypeCount )( + __RPC__in IMFMediaTypeHandler * This, + /* [out] */ __RPC__out DWORD *pdwTypeCount); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *GetMediaTypeByIndex )( + IMFMediaTypeHandler * This, + /* [in] */ DWORD dwIndex, + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppType); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *SetCurrentMediaType )( + IMFMediaTypeHandler * This, + /* [in] */ IMFMediaType *pMediaType); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *GetCurrentMediaType )( + IMFMediaTypeHandler * This, + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppMediaType); + + HRESULT ( STDMETHODCALLTYPE *GetMajorType )( + __RPC__in IMFMediaTypeHandler * This, + /* [out] */ __RPC__out GUID *pguidMajorType); + + END_INTERFACE + } IMFMediaTypeHandlerVtbl; + + interface IMFMediaTypeHandler + { + CONST_VTBL struct IMFMediaTypeHandlerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaTypeHandler_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaTypeHandler_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaTypeHandler_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaTypeHandler_IsMediaTypeSupported(This,pMediaType,ppMediaType) \ + ( (This)->lpVtbl -> IsMediaTypeSupported(This,pMediaType,ppMediaType) ) + +#define IMFMediaTypeHandler_GetMediaTypeCount(This,pdwTypeCount) \ + ( (This)->lpVtbl -> GetMediaTypeCount(This,pdwTypeCount) ) + +#define IMFMediaTypeHandler_GetMediaTypeByIndex(This,dwIndex,ppType) \ + ( (This)->lpVtbl -> GetMediaTypeByIndex(This,dwIndex,ppType) ) + +#define IMFMediaTypeHandler_SetCurrentMediaType(This,pMediaType) \ + ( (This)->lpVtbl -> SetCurrentMediaType(This,pMediaType) ) + +#define IMFMediaTypeHandler_GetCurrentMediaType(This,ppMediaType) \ + ( (This)->lpVtbl -> GetCurrentMediaType(This,ppMediaType) ) + +#define IMFMediaTypeHandler_GetMajorType(This,pguidMajorType) \ + ( (This)->lpVtbl -> GetMajorType(This,pguidMajorType) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_RemoteIsMediaTypeSupported_Proxy( + __RPC__in IMFMediaTypeHandler * This, + /* [size_is][in] */ __RPC__in_ecount_full(cbData) BYTE *pbData, + /* [in] */ DWORD cbData, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbBestMatch) BYTE **ppbBestMatch, + /* [out] */ __RPC__out DWORD *pcbBestMatch); + + +void __RPC_STUB IMFMediaTypeHandler_RemoteIsMediaTypeSupported_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_RemoteGetMediaTypeByIndex_Proxy( + __RPC__in IMFMediaTypeHandler * This, + /* [in] */ DWORD dwIndex, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbData) BYTE **ppbData, + /* [out] */ __RPC__out DWORD *pcbData); + + +void __RPC_STUB IMFMediaTypeHandler_RemoteGetMediaTypeByIndex_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_RemoteSetCurrentMediaType_Proxy( + __RPC__in IMFMediaTypeHandler * This, + /* [size_is][in] */ __RPC__in_ecount_full(cbData) BYTE *pbData, + /* [in] */ DWORD cbData); + + +void __RPC_STUB IMFMediaTypeHandler_RemoteSetCurrentMediaType_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_RemoteGetCurrentMediaType_Proxy( + __RPC__in IMFMediaTypeHandler * This, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbData) BYTE **ppbData, + /* [out] */ __RPC__out DWORD *pcbData); + + +void __RPC_STUB IMFMediaTypeHandler_RemoteGetCurrentMediaType_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMFMediaTypeHandler_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0027 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +STDAPI MFCreateSimpleTypeHandler( + _Outptr_ IMFMediaTypeHandler ** ppHandler ); +typedef +enum MFTIMER_FLAGS + { + MFTIMER_RELATIVE = 0x1 + } MFTIMER_FLAGS; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0027_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0027_v0_0_s_ifspec; + +#ifndef __IMFTimer_INTERFACE_DEFINED__ +#define __IMFTimer_INTERFACE_DEFINED__ + +/* interface IMFTimer */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFTimer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e56e4cbd-8f70-49d8-a0f8-edb3d6ab9bf2") + IMFTimer : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetTimer( + /* [in] */ DWORD dwFlags, + /* [in] */ LONGLONG llClockTime, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState, + /* [out] */ IUnknown **ppunkKey) = 0; + + virtual HRESULT STDMETHODCALLTYPE CancelTimer( + /* [in] */ IUnknown *punkKey) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTimerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTimer * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTimer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTimer * This); + + HRESULT ( STDMETHODCALLTYPE *SetTimer )( + IMFTimer * This, + /* [in] */ DWORD dwFlags, + /* [in] */ LONGLONG llClockTime, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState, + /* [out] */ IUnknown **ppunkKey); + + HRESULT ( STDMETHODCALLTYPE *CancelTimer )( + IMFTimer * This, + /* [in] */ IUnknown *punkKey); + + END_INTERFACE + } IMFTimerVtbl; + + interface IMFTimer + { + CONST_VTBL struct IMFTimerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTimer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTimer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTimer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTimer_SetTimer(This,dwFlags,llClockTime,pCallback,punkState,ppunkKey) \ + ( (This)->lpVtbl -> SetTimer(This,dwFlags,llClockTime,pCallback,punkState,ppunkKey) ) + +#define IMFTimer_CancelTimer(This,punkKey) \ + ( (This)->lpVtbl -> CancelTimer(This,punkKey) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTimer_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0028 */ +/* [local] */ + +EXTERN_GUID( MF_ACTIVATE_CUSTOM_VIDEO_MIXER_CLSID, 0xba491360, 0xbe50, 0x451e, 0x95, 0xab, 0x6d, 0x4a, 0xcc, 0xc7, 0xda, 0xd8 ); +EXTERN_GUID( MF_ACTIVATE_CUSTOM_VIDEO_MIXER_ACTIVATE, 0xba491361, 0xbe50, 0x451e, 0x95, 0xab, 0x6d, 0x4a, 0xcc, 0xc7, 0xda, 0xd8 ); +EXTERN_GUID( MF_ACTIVATE_CUSTOM_VIDEO_MIXER_FLAGS, 0xba491362, 0xbe50, 0x451e, 0x95, 0xab, 0x6d, 0x4a, 0xcc, 0xc7, 0xda, 0xd8 ); +EXTERN_GUID( MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_CLSID, 0xba491364, 0xbe50, 0x451e, 0x95, 0xab, 0x6d, 0x4a, 0xcc, 0xc7, 0xda, 0xd8 ); +EXTERN_GUID( MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_ACTIVATE, 0xba491365, 0xbe50, 0x451e, 0x95, 0xab, 0x6d, 0x4a, 0xcc, 0xc7, 0xda, 0xd8 ); +EXTERN_GUID( MF_ACTIVATE_CUSTOM_VIDEO_PRESENTER_FLAGS, 0xba491366, 0xbe50, 0x451e, 0x95, 0xab, 0x6d, 0x4a, 0xcc, 0xc7, 0xda, 0xd8 ); + +enum __MIDL___MIDL_itf_mfidl_0000_0028_0001 + { + MF_ACTIVATE_CUSTOM_MIXER_ALLOWFAIL = 0x1 + } ; + +enum __MIDL___MIDL_itf_mfidl_0000_0028_0002 + { + MF_ACTIVATE_CUSTOM_PRESENTER_ALLOWFAIL = 0x1 + } ; +EXTERN_GUID( MF_ACTIVATE_MFT_LOCKED, 0xc1f6093c, 0x7f65, 0x4fbd, 0x9e, 0x39, 0x5f, 0xae, 0xc3, 0xc4, 0xfb, 0xd7 ); +EXTERN_GUID( MF_ACTIVATE_VIDEO_WINDOW, 0x9a2dbbdd, 0xf57e, 0x4162, 0x82, 0xb9, 0x68, 0x31, 0x37, 0x76, 0x82, 0xd3 ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef +enum _MFSHUTDOWN_STATUS + { + MFSHUTDOWN_INITIATED = 0, + MFSHUTDOWN_COMPLETED = ( MFSHUTDOWN_INITIATED + 1 ) + } MFSHUTDOWN_STATUS; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0028_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0028_v0_0_s_ifspec; + +#ifndef __IMFShutdown_INTERFACE_DEFINED__ +#define __IMFShutdown_INTERFACE_DEFINED__ + +/* interface IMFShutdown */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFShutdown; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("97ec2ea4-0e42-4937-97ac-9d6d328824e1") + IMFShutdown : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Shutdown( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetShutdownStatus( + /* [out] */ __RPC__out MFSHUTDOWN_STATUS *pStatus) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFShutdownVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFShutdown * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFShutdown * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFShutdown * This); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + __RPC__in IMFShutdown * This); + + HRESULT ( STDMETHODCALLTYPE *GetShutdownStatus )( + __RPC__in IMFShutdown * This, + /* [out] */ __RPC__out MFSHUTDOWN_STATUS *pStatus); + + END_INTERFACE + } IMFShutdownVtbl; + + interface IMFShutdown + { + CONST_VTBL struct IMFShutdownVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFShutdown_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFShutdown_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFShutdown_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFShutdown_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + +#define IMFShutdown_GetShutdownStatus(This,pStatus) \ + ( (This)->lpVtbl -> GetShutdownStatus(This,pStatus) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFShutdown_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0029 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +STDAPI +MFShutdownObject( + IUnknown * pUnk ); +STDAPI +MFCreateAudioRenderer( + IMFAttributes* pAudioAttributes, + _Outptr_ IMFMediaSink** ppSink + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region PC Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP) +STDAPI +MFCreateAudioRendererActivate( + _Outptr_ IMFActivate ** ppActivate + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_PC_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +EXTERN_GUID( MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS, 0xede4b5e0, 0xf805, 0x4d6c, 0x99, 0xb3, 0xdb, 0x01, 0xbf, 0x95, 0xdf, 0xab); +#define MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS_CROSSPROCESS 0x00000001 +#define MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS_NOPERSIST 0x00000002 +#if (WINVER >= _WIN32_WINNT_WIN7) +#define MF_AUDIO_RENDERER_ATTRIBUTE_FLAGS_DONT_ALLOW_FORMAT_CHANGES 0x00000004 +#endif // (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_GUID( MF_AUDIO_RENDERER_ATTRIBUTE_SESSION_ID, 0xede4b5e3, 0xf805, 0x4d6c, 0x99, 0xb3, 0xdb, 0x01, 0xbf, 0x95, 0xdf, 0xab); +EXTERN_GUID( MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ID, 0xb10aaec3, 0xef71, 0x4cc3, 0xb8, 0x73, 0x5, 0xa9, 0xa0, 0x8b, 0x9f, 0x8e); +EXTERN_GUID( MF_AUDIO_RENDERER_ATTRIBUTE_ENDPOINT_ROLE, 0x6ba644ff, 0x27c5, 0x4d02, 0x98, 0x87, 0xc2, 0x86, 0x19, 0xfd, 0xb9, 0x1b); +EXTERN_GUID( MF_AUDIO_RENDERER_ATTRIBUTE_STREAM_CATEGORY, 0xa9770471, 0x92ec, 0x4df4, 0x94, 0xfe, 0x81, 0xc3, 0x6f, 0xc, 0x3a, 0x7a); +STDAPI +MFCreateVideoRendererActivate( + _In_ HWND hwndVideo, + _Outptr_ IMFActivate ** ppActivate + ); +#if (WINVER >= _WIN32_WINNT_WIN7) +STDAPI +MFCreateMPEG4MediaSink( + _In_ IMFByteStream* pIByteStream, + _In_opt_ IMFMediaType* pVideoMediaType, + _In_opt_ IMFMediaType* pAudioMediaType, + _Outptr_ IMFMediaSink** ppIMediaSink + ); +STDAPI +MFCreate3GPMediaSink( + _In_ IMFByteStream* pIByteStream, + _In_opt_ IMFMediaType* pVideoMediaType, + _In_opt_ IMFMediaType* pAudioMediaType, + _Outptr_ IMFMediaSink** ppIMediaSink + ); +STDAPI +MFCreateMP3MediaSink( + _In_ IMFByteStream* pTargetByteStream, + _Outptr_ IMFMediaSink** ppMediaSink + ); +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#if (WINVER >= _WIN32_WINNT_WIN8) +STDAPI +MFCreateAC3MediaSink( + _In_ IMFByteStream* pTargetByteStream, + _In_ IMFMediaType* pAudioMediaType, + _Outptr_ IMFMediaSink** ppMediaSink + ); +STDAPI +MFCreateADTSMediaSink( + _In_ IMFByteStream* pTargetByteStream, + _In_ IMFMediaType* pAudioMediaType, + _Outptr_ IMFMediaSink** ppMediaSink + ); +STDAPI +MFCreateMuxSink( + _In_ GUID guidOutputSubType, + _In_opt_ IMFAttributes* pOutputAttributes, + _In_opt_ IMFByteStream* pOutputByteStream, + _Outptr_ IMFMediaSink** ppMuxSink + ); +STDAPI +MFCreateFMPEG4MediaSink( + _In_ IMFByteStream* pIByteStream, + _In_opt_ IMFMediaType* pVideoMediaType, + _In_opt_ IMFMediaType* pAudioMediaType, + _Outptr_ IMFMediaSink** ppIMediaSink + ); +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#if (WINVER >= _WIN32_WINNT_WINBLUE) +STDAPI +MFCreateAVIMediaSink( + _In_ IMFByteStream* pIByteStream, + _In_ IMFMediaType* pVideoMediaType, + _In_opt_ IMFMediaType* pAudioMediaType, + _Outptr_ IMFMediaSink** ppIMediaSink + ); +#endif // (WINVER >= _WIN32_WINNT_WINBLUE) +#if (WINVER >= _WIN32_WINNT_WINBLUE) +STDAPI +MFCreateWAVEMediaSink( + _In_ IMFByteStream* pTargetByteStream, + _In_ IMFMediaType* pAudioMediaType, + _Outptr_ IMFMediaSink** ppMediaSink + ); +#endif // (WINVER >= _WIN32_WINNT_WINBLUE) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0029_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0029_v0_0_s_ifspec; + +#ifndef __IMFTopoLoader_INTERFACE_DEFINED__ +#define __IMFTopoLoader_INTERFACE_DEFINED__ + +/* interface IMFTopoLoader */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFTopoLoader; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DE9A6157-F660-4643-B56A-DF9F7998C7CD") + IMFTopoLoader : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Load( + /* [in] */ IMFTopology *pInputTopo, + /* [annotation][out] */ + _Outptr_ IMFTopology **ppOutputTopo, + /* [in] */ IMFTopology *pCurrentTopo) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTopoLoaderVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTopoLoader * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTopoLoader * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTopoLoader * This); + + HRESULT ( STDMETHODCALLTYPE *Load )( + IMFTopoLoader * This, + /* [in] */ IMFTopology *pInputTopo, + /* [annotation][out] */ + _Outptr_ IMFTopology **ppOutputTopo, + /* [in] */ IMFTopology *pCurrentTopo); + + END_INTERFACE + } IMFTopoLoaderVtbl; + + interface IMFTopoLoader + { + CONST_VTBL struct IMFTopoLoaderVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTopoLoader_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTopoLoader_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTopoLoader_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTopoLoader_Load(This,pInputTopo,ppOutputTopo,pCurrentTopo) \ + ( (This)->lpVtbl -> Load(This,pInputTopo,ppOutputTopo,pCurrentTopo) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTopoLoader_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0030 */ +/* [local] */ + +STDAPI MFCreateTopoLoader( + _Outptr_ IMFTopoLoader ** ppObj ); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0030_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0030_v0_0_s_ifspec; + +#ifndef __IMFContentProtectionManager_INTERFACE_DEFINED__ +#define __IMFContentProtectionManager_INTERFACE_DEFINED__ + +/* interface IMFContentProtectionManager */ +/* [unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFContentProtectionManager; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ACF92459-6A61-42bd-B57C-B43E51203CB0") + IMFContentProtectionManager : public IUnknown + { + public: + virtual /* [local] */ HRESULT STDMETHODCALLTYPE BeginEnableContent( + /* [in] */ IMFActivate *pEnablerActivate, + /* [in] */ IMFTopology *pTopo, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE EndEnableContent( + /* [in] */ IMFAsyncResult *pResult) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFContentProtectionManagerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFContentProtectionManager * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFContentProtectionManager * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFContentProtectionManager * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginEnableContent )( + IMFContentProtectionManager * This, + /* [in] */ IMFActivate *pEnablerActivate, + /* [in] */ IMFTopology *pTopo, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndEnableContent )( + IMFContentProtectionManager * This, + /* [in] */ IMFAsyncResult *pResult); + + END_INTERFACE + } IMFContentProtectionManagerVtbl; + + interface IMFContentProtectionManager + { + CONST_VTBL struct IMFContentProtectionManagerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFContentProtectionManager_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFContentProtectionManager_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFContentProtectionManager_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFContentProtectionManager_BeginEnableContent(This,pEnablerActivate,pTopo,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginEnableContent(This,pEnablerActivate,pTopo,pCallback,punkState) ) + +#define IMFContentProtectionManager_EndEnableContent(This,pResult) \ + ( (This)->lpVtbl -> EndEnableContent(This,pResult) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFContentProtectionManager_RemoteBeginEnableContent_Proxy( + __RPC__in IMFContentProtectionManager * This, + /* [in] */ __RPC__in REFCLSID clsidType, + /* [size_is][in] */ __RPC__in_ecount_full(cbData) BYTE *pbData, + /* [in] */ DWORD cbData, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + + +void __RPC_STUB IMFContentProtectionManager_RemoteBeginEnableContent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFContentProtectionManager_RemoteEndEnableContent_Proxy( + __RPC__in IMFContentProtectionManager * This, + /* [in] */ __RPC__in_opt IUnknown *pResult); + + +void __RPC_STUB IMFContentProtectionManager_RemoteEndEnableContent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMFContentProtectionManager_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0031 */ +/* [local] */ + +typedef /* [public][public] */ +enum __MIDL___MIDL_itf_mfidl_0000_0031_0001 + { + MF_LICENSE_URL_UNTRUSTED = 0, + MF_LICENSE_URL_TRUSTED = ( MF_LICENSE_URL_UNTRUSTED + 1 ) , + MF_LICENSE_URL_TAMPERED = ( MF_LICENSE_URL_TRUSTED + 1 ) + } MF_URL_TRUST_STATUS; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0031_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0031_v0_0_s_ifspec; + +#ifndef __IMFContentEnabler_INTERFACE_DEFINED__ +#define __IMFContentEnabler_INTERFACE_DEFINED__ + +/* interface IMFContentEnabler */ +/* [unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFContentEnabler; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("D3C4EF59-49CE-4381-9071-D5BCD044C770") + IMFContentEnabler : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetEnableType( + /* [out] */ __RPC__out GUID *pType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetEnableURL( + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcchURL) LPWSTR *ppwszURL, + /* [out] */ __RPC__out DWORD *pcchURL, + /* [unique][out][in] */ __RPC__inout_opt MF_URL_TRUST_STATUS *pTrustStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetEnableData( + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbData) BYTE **ppbData, + /* [out] */ __RPC__out DWORD *pcbData) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsAutomaticSupported( + /* [out] */ __RPC__out BOOL *pfAutomatic) = 0; + + virtual HRESULT STDMETHODCALLTYPE AutomaticEnable( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE MonitorEnable( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Cancel( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFContentEnablerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFContentEnabler * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFContentEnabler * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFContentEnabler * This); + + HRESULT ( STDMETHODCALLTYPE *GetEnableType )( + __RPC__in IMFContentEnabler * This, + /* [out] */ __RPC__out GUID *pType); + + HRESULT ( STDMETHODCALLTYPE *GetEnableURL )( + __RPC__in IMFContentEnabler * This, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcchURL) LPWSTR *ppwszURL, + /* [out] */ __RPC__out DWORD *pcchURL, + /* [unique][out][in] */ __RPC__inout_opt MF_URL_TRUST_STATUS *pTrustStatus); + + HRESULT ( STDMETHODCALLTYPE *GetEnableData )( + __RPC__in IMFContentEnabler * This, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbData) BYTE **ppbData, + /* [out] */ __RPC__out DWORD *pcbData); + + HRESULT ( STDMETHODCALLTYPE *IsAutomaticSupported )( + __RPC__in IMFContentEnabler * This, + /* [out] */ __RPC__out BOOL *pfAutomatic); + + HRESULT ( STDMETHODCALLTYPE *AutomaticEnable )( + __RPC__in IMFContentEnabler * This); + + HRESULT ( STDMETHODCALLTYPE *MonitorEnable )( + __RPC__in IMFContentEnabler * This); + + HRESULT ( STDMETHODCALLTYPE *Cancel )( + __RPC__in IMFContentEnabler * This); + + END_INTERFACE + } IMFContentEnablerVtbl; + + interface IMFContentEnabler + { + CONST_VTBL struct IMFContentEnablerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFContentEnabler_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFContentEnabler_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFContentEnabler_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFContentEnabler_GetEnableType(This,pType) \ + ( (This)->lpVtbl -> GetEnableType(This,pType) ) + +#define IMFContentEnabler_GetEnableURL(This,ppwszURL,pcchURL,pTrustStatus) \ + ( (This)->lpVtbl -> GetEnableURL(This,ppwszURL,pcchURL,pTrustStatus) ) + +#define IMFContentEnabler_GetEnableData(This,ppbData,pcbData) \ + ( (This)->lpVtbl -> GetEnableData(This,ppbData,pcbData) ) + +#define IMFContentEnabler_IsAutomaticSupported(This,pfAutomatic) \ + ( (This)->lpVtbl -> IsAutomaticSupported(This,pfAutomatic) ) + +#define IMFContentEnabler_AutomaticEnable(This) \ + ( (This)->lpVtbl -> AutomaticEnable(This) ) + +#define IMFContentEnabler_MonitorEnable(This) \ + ( (This)->lpVtbl -> MonitorEnable(This) ) + +#define IMFContentEnabler_Cancel(This) \ + ( (This)->lpVtbl -> Cancel(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFContentEnabler_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0032 */ +/* [local] */ + + +EXTERN_GUID( MFENABLETYPE_WMDRMV1_LicenseAcquisition, 0x4ff6eeaf, 0xb43, 0x4797, 0x9b, 0x85, 0xab, 0xf3, 0x18, 0x15, 0xe7, 0xb0); +EXTERN_GUID( MFENABLETYPE_WMDRMV7_LicenseAcquisition, 0x3306df, 0x4a06, 0x4884,0xa0, 0x97, 0xef, 0x6d, 0x22, 0xec, 0x84, 0xa3); +EXTERN_GUID( MFENABLETYPE_WMDRMV7_Individualization, 0xacd2c84a, 0xb303, 0x4f65, 0xbc, 0x2c, 0x2c, 0x84, 0x8d, 0x1, 0xa9, 0x89); +EXTERN_GUID( MFENABLETYPE_MF_UpdateRevocationInformation, 0xe558b0b5, 0xb3c4, 0x44a0, 0x92, 0x4c, 0x50, 0xd1, 0x78, 0x93, 0x23, 0x85); +EXTERN_GUID( MFENABLETYPE_MF_UpdateUntrustedComponent, 0x9879f3d6, 0xcee2, 0x48e6, 0xb5, 0x73, 0x97, 0x67, 0xab, 0x17, 0x2f, 0x16); +EXTERN_GUID( MFENABLETYPE_MF_RebootRequired, 0x6d4d3d4b, 0x0ece, 0x4652, 0x8b, 0x3a, 0xf2, 0xd2, 0x42, 0x60, 0xd8, 0x87); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +// +// Structs that contain information about revoked or unsigned binaries, +// returned by the IMFContentEnabler::GetEnableData() method of +// the Revocation content enabler +// +#ifndef MFRR_INFO_VERSION +#define MFRR_INFO_VERSION 0 +#endif +// +// The values for MFRR_COMPONENT_HASH_INFO.ulReason +// +#define MF_USER_MODE_COMPONENT_LOAD 0x00000001 +#define MF_KERNEL_MODE_COMPONENT_LOAD 0x00000002 +#define MF_GRL_LOAD_FAILED 0x00000010 +#define MF_INVALID_GRL_SIGNATURE 0x00000020 +#define MF_GRL_ABSENT 0x00001000 +#define MF_COMPONENT_REVOKED 0x00002000 +#define MF_COMPONENT_INVALID_EKU 0x00004000 +#define MF_COMPONENT_CERT_REVOKED 0x00008000 +#define MF_COMPONENT_INVALID_ROOT 0x00010000 +#define MF_COMPONENT_HS_CERT_REVOKED 0x00020000 +#define MF_COMPONENT_LS_CERT_REVOKED 0x00040000 +#define MF_BOOT_DRIVER_VERIFICATION_FAILED 0x00100000 +#define MF_TEST_SIGNED_COMPONENT_LOADING 0x01000000 +#define MF_MINCRYPT_FAILURE 0x10000000 +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +// +// STR_HASH_LEN: Number of characters required to represent a SHA-1 hash +// (RTL_MAX_HASH_LEN_V1) as a string of the form "0x5a3b53463b672a4f..." +// Each byte of a SHA-1 hash takes two characters to represent, and +// we add in two leading characters "0x" as well as the NULL terminator +// +#define SHA_HASH_LEN 20 +#define STR_HASH_LEN (SHA_HASH_LEN*2 + 3) +typedef struct _MFRR_COMPONENT_HASH_INFO +{ + // Reason for failure (revoked or unsigned or badly signed). + DWORD ulReason; + + // Header hash of the component + WCHAR rgHeaderHash[STR_HASH_LEN]; + + // Hash of public key if one of the certificates + // in the signing certificate chain is revoked + WCHAR rgPublicKeyHash[STR_HASH_LEN]; + + // Component name (full path name) + WCHAR wszName[MAX_PATH]; + +} MFRR_COMPONENT_HASH_INFO, *PMFRR_COMPONENT_HASH_INFO; +typedef struct _MFRR_COMPONENTS +{ + + // Version number + DWORD dwRRInfoVersion; + + // Number of components in list + DWORD dwRRComponents; + + // points to the end of this structure that has + // allocated memory for the array of component info structures + PMFRR_COMPONENT_HASH_INFO pRRComponents; + +} MFRR_COMPONENTS, *PMFRR_COMPONENTS; +#pragma pack ( push ) +#pragma pack ( 1 ) +typedef struct _ASFFlatPicture +{ + // + // Direct mapped fields + // + BYTE bPictureType; + DWORD dwDataLen; +} ASF_FLAT_PICTURE; +#pragma pack ( pop ) +#pragma pack ( push ) +#pragma pack ( 1 ) +typedef struct _ASFFlatSynchronisedLyrics +{ + // + // Direct mapped fields + // + BYTE bTimeStampFormat; + BYTE bContentType; + DWORD dwLyricsLen; +} ASF_FLAT_SYNCHRONISED_LYRICS; +#pragma pack ( pop ) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0032_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0032_v0_0_s_ifspec; + +#ifndef __IMFMetadata_INTERFACE_DEFINED__ +#define __IMFMetadata_INTERFACE_DEFINED__ + +/* interface IMFMetadata */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMetadata; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F88CFB8C-EF16-4991-B450-CB8C69E51704") + IMFMetadata : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetLanguage( + /* [in] */ __RPC__in LPCWSTR pwszRFC1766) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetLanguage( + /* [out] */ __RPC__deref_out_opt LPWSTR *ppwszRFC1766) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAllLanguages( + /* [out] */ __RPC__out PROPVARIANT *ppvLanguages) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetProperty( + /* [in] */ __RPC__in LPCWSTR pwszName, + /* [in] */ __RPC__in const PROPVARIANT *ppvValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetProperty( + /* [in] */ __RPC__in LPCWSTR pwszName, + /* [out] */ __RPC__out PROPVARIANT *ppvValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeleteProperty( + /* [in] */ __RPC__in LPCWSTR pwszName) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAllPropertyNames( + /* [out] */ __RPC__out PROPVARIANT *ppvNames) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMetadataVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMetadata * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMetadata * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMetadata * This); + + HRESULT ( STDMETHODCALLTYPE *SetLanguage )( + __RPC__in IMFMetadata * This, + /* [in] */ __RPC__in LPCWSTR pwszRFC1766); + + HRESULT ( STDMETHODCALLTYPE *GetLanguage )( + __RPC__in IMFMetadata * This, + /* [out] */ __RPC__deref_out_opt LPWSTR *ppwszRFC1766); + + HRESULT ( STDMETHODCALLTYPE *GetAllLanguages )( + __RPC__in IMFMetadata * This, + /* [out] */ __RPC__out PROPVARIANT *ppvLanguages); + + HRESULT ( STDMETHODCALLTYPE *SetProperty )( + __RPC__in IMFMetadata * This, + /* [in] */ __RPC__in LPCWSTR pwszName, + /* [in] */ __RPC__in const PROPVARIANT *ppvValue); + + HRESULT ( STDMETHODCALLTYPE *GetProperty )( + __RPC__in IMFMetadata * This, + /* [in] */ __RPC__in LPCWSTR pwszName, + /* [out] */ __RPC__out PROPVARIANT *ppvValue); + + HRESULT ( STDMETHODCALLTYPE *DeleteProperty )( + __RPC__in IMFMetadata * This, + /* [in] */ __RPC__in LPCWSTR pwszName); + + HRESULT ( STDMETHODCALLTYPE *GetAllPropertyNames )( + __RPC__in IMFMetadata * This, + /* [out] */ __RPC__out PROPVARIANT *ppvNames); + + END_INTERFACE + } IMFMetadataVtbl; + + interface IMFMetadata + { + CONST_VTBL struct IMFMetadataVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMetadata_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMetadata_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMetadata_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMetadata_SetLanguage(This,pwszRFC1766) \ + ( (This)->lpVtbl -> SetLanguage(This,pwszRFC1766) ) + +#define IMFMetadata_GetLanguage(This,ppwszRFC1766) \ + ( (This)->lpVtbl -> GetLanguage(This,ppwszRFC1766) ) + +#define IMFMetadata_GetAllLanguages(This,ppvLanguages) \ + ( (This)->lpVtbl -> GetAllLanguages(This,ppvLanguages) ) + +#define IMFMetadata_SetProperty(This,pwszName,ppvValue) \ + ( (This)->lpVtbl -> SetProperty(This,pwszName,ppvValue) ) + +#define IMFMetadata_GetProperty(This,pwszName,ppvValue) \ + ( (This)->lpVtbl -> GetProperty(This,pwszName,ppvValue) ) + +#define IMFMetadata_DeleteProperty(This,pwszName) \ + ( (This)->lpVtbl -> DeleteProperty(This,pwszName) ) + +#define IMFMetadata_GetAllPropertyNames(This,ppvNames) \ + ( (This)->lpVtbl -> GetAllPropertyNames(This,ppvNames) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMetadata_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMetadataProvider_INTERFACE_DEFINED__ +#define __IMFMetadataProvider_INTERFACE_DEFINED__ + +/* interface IMFMetadataProvider */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMetadataProvider; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("56181D2D-E221-4adb-B1C8-3CEE6A53F76F") + IMFMetadataProvider : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetMFMetadata( + /* [in] */ __RPC__in_opt IMFPresentationDescriptor *pPresentationDescriptor, + /* [in] */ DWORD dwStreamIdentifier, + /* [in] */ DWORD dwFlags, + /* [out] */ __RPC__deref_out_opt IMFMetadata **ppMFMetadata) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMetadataProviderVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMetadataProvider * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMetadataProvider * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMetadataProvider * This); + + HRESULT ( STDMETHODCALLTYPE *GetMFMetadata )( + __RPC__in IMFMetadataProvider * This, + /* [in] */ __RPC__in_opt IMFPresentationDescriptor *pPresentationDescriptor, + /* [in] */ DWORD dwStreamIdentifier, + /* [in] */ DWORD dwFlags, + /* [out] */ __RPC__deref_out_opt IMFMetadata **ppMFMetadata); + + END_INTERFACE + } IMFMetadataProviderVtbl; + + interface IMFMetadataProvider + { + CONST_VTBL struct IMFMetadataProviderVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMetadataProvider_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMetadataProvider_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMetadataProvider_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMetadataProvider_GetMFMetadata(This,pPresentationDescriptor,dwStreamIdentifier,dwFlags,ppMFMetadata) \ + ( (This)->lpVtbl -> GetMFMetadata(This,pPresentationDescriptor,dwStreamIdentifier,dwFlags,ppMFMetadata) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMetadataProvider_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0034 */ +/* [local] */ + +EXTERN_GUID( MF_METADATA_PROVIDER_SERVICE, 0xdb214084, 0x58a4, 0x4d2e, 0xb8, 0x4f, 0x6f, 0x75, 0x5b, 0x2f, 0x7a, 0xd); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +#if (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_GUID( MF_PROPERTY_HANDLER_SERVICE, 0xa3face02, 0x32b8, 0x41dd, 0x90, 0xe7, 0x5f, 0xef, 0x7c, 0x89, 0x91, 0xb5); +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef +enum _MFRATE_DIRECTION + { + MFRATE_FORWARD = 0, + MFRATE_REVERSE = ( MFRATE_FORWARD + 1 ) + } MFRATE_DIRECTION; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0034_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0034_v0_0_s_ifspec; + +#ifndef __IMFRateSupport_INTERFACE_DEFINED__ +#define __IMFRateSupport_INTERFACE_DEFINED__ + +/* interface IMFRateSupport */ +/* [unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFRateSupport; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0a9ccdbc-d797-4563-9667-94ec5d79292d") + IMFRateSupport : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetSlowestRate( + /* [in] */ MFRATE_DIRECTION eDirection, + /* [in] */ BOOL fThin, + /* [out] */ __RPC__out float *pflRate) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFastestRate( + /* [in] */ MFRATE_DIRECTION eDirection, + /* [in] */ BOOL fThin, + /* [out] */ __RPC__out float *pflRate) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsRateSupported( + /* [in] */ BOOL fThin, + /* [in] */ float flRate, + /* [unique][out][in] */ __RPC__inout_opt float *pflNearestSupportedRate) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFRateSupportVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFRateSupport * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFRateSupport * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFRateSupport * This); + + HRESULT ( STDMETHODCALLTYPE *GetSlowestRate )( + __RPC__in IMFRateSupport * This, + /* [in] */ MFRATE_DIRECTION eDirection, + /* [in] */ BOOL fThin, + /* [out] */ __RPC__out float *pflRate); + + HRESULT ( STDMETHODCALLTYPE *GetFastestRate )( + __RPC__in IMFRateSupport * This, + /* [in] */ MFRATE_DIRECTION eDirection, + /* [in] */ BOOL fThin, + /* [out] */ __RPC__out float *pflRate); + + HRESULT ( STDMETHODCALLTYPE *IsRateSupported )( + __RPC__in IMFRateSupport * This, + /* [in] */ BOOL fThin, + /* [in] */ float flRate, + /* [unique][out][in] */ __RPC__inout_opt float *pflNearestSupportedRate); + + END_INTERFACE + } IMFRateSupportVtbl; + + interface IMFRateSupport + { + CONST_VTBL struct IMFRateSupportVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFRateSupport_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFRateSupport_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFRateSupport_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFRateSupport_GetSlowestRate(This,eDirection,fThin,pflRate) \ + ( (This)->lpVtbl -> GetSlowestRate(This,eDirection,fThin,pflRate) ) + +#define IMFRateSupport_GetFastestRate(This,eDirection,fThin,pflRate) \ + ( (This)->lpVtbl -> GetFastestRate(This,eDirection,fThin,pflRate) ) + +#define IMFRateSupport_IsRateSupported(This,fThin,flRate,pflNearestSupportedRate) \ + ( (This)->lpVtbl -> IsRateSupported(This,fThin,flRate,pflNearestSupportedRate) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFRateSupport_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0035 */ +/* [local] */ + +EXTERN_GUID( MF_RATE_CONTROL_SERVICE, 0x866fa297, 0xb802, 0x4bf8, 0x9d, 0xc9, 0x5e, 0x3b, 0x6a, 0x9f, 0x53, 0xc9); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0035_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0035_v0_0_s_ifspec; + +#ifndef __IMFRateControl_INTERFACE_DEFINED__ +#define __IMFRateControl_INTERFACE_DEFINED__ + +/* interface IMFRateControl */ +/* [unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFRateControl; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("88ddcd21-03c3-4275-91ed-55ee3929328f") + IMFRateControl : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetRate( + /* [in] */ BOOL fThin, + /* [in] */ float flRate) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRate( + /* [unique][out][in] */ __RPC__inout_opt BOOL *pfThin, + /* [unique][out][in] */ __RPC__inout_opt float *pflRate) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFRateControlVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFRateControl * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFRateControl * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFRateControl * This); + + HRESULT ( STDMETHODCALLTYPE *SetRate )( + __RPC__in IMFRateControl * This, + /* [in] */ BOOL fThin, + /* [in] */ float flRate); + + HRESULT ( STDMETHODCALLTYPE *GetRate )( + __RPC__in IMFRateControl * This, + /* [unique][out][in] */ __RPC__inout_opt BOOL *pfThin, + /* [unique][out][in] */ __RPC__inout_opt float *pflRate); + + END_INTERFACE + } IMFRateControlVtbl; + + interface IMFRateControl + { + CONST_VTBL struct IMFRateControlVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFRateControl_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFRateControl_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFRateControl_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFRateControl_SetRate(This,fThin,flRate) \ + ( (This)->lpVtbl -> SetRate(This,fThin,flRate) ) + +#define IMFRateControl_GetRate(This,pfThin,pflRate) \ + ( (This)->lpVtbl -> GetRate(This,pfThin,pflRate) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFRateControl_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0036 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +#if (WINVER >= _WIN32_WINNT_WIN7) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0036_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0036_v0_0_s_ifspec; + +#ifndef __IMFTimecodeTranslate_INTERFACE_DEFINED__ +#define __IMFTimecodeTranslate_INTERFACE_DEFINED__ + +/* interface IMFTimecodeTranslate */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFTimecodeTranslate; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ab9d8661-f7e8-4ef4-9861-89f334f94e74") + IMFTimecodeTranslate : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE BeginConvertTimecodeToHNS( + /* [in] */ const PROPVARIANT *pPropVarTimecode, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndConvertTimecodeToHNS( + /* [in] */ IMFAsyncResult *pResult, + /* [out] */ MFTIME *phnsTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginConvertHNSToTimecode( + /* [in] */ MFTIME hnsTime, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndConvertHNSToTimecode( + /* [in] */ IMFAsyncResult *pResult, + /* [out] */ PROPVARIANT *pPropVarTimecode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTimecodeTranslateVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTimecodeTranslate * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTimecodeTranslate * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTimecodeTranslate * This); + + HRESULT ( STDMETHODCALLTYPE *BeginConvertTimecodeToHNS )( + IMFTimecodeTranslate * This, + /* [in] */ const PROPVARIANT *pPropVarTimecode, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + HRESULT ( STDMETHODCALLTYPE *EndConvertTimecodeToHNS )( + IMFTimecodeTranslate * This, + /* [in] */ IMFAsyncResult *pResult, + /* [out] */ MFTIME *phnsTime); + + HRESULT ( STDMETHODCALLTYPE *BeginConvertHNSToTimecode )( + IMFTimecodeTranslate * This, + /* [in] */ MFTIME hnsTime, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + HRESULT ( STDMETHODCALLTYPE *EndConvertHNSToTimecode )( + IMFTimecodeTranslate * This, + /* [in] */ IMFAsyncResult *pResult, + /* [out] */ PROPVARIANT *pPropVarTimecode); + + END_INTERFACE + } IMFTimecodeTranslateVtbl; + + interface IMFTimecodeTranslate + { + CONST_VTBL struct IMFTimecodeTranslateVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTimecodeTranslate_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTimecodeTranslate_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTimecodeTranslate_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTimecodeTranslate_BeginConvertTimecodeToHNS(This,pPropVarTimecode,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginConvertTimecodeToHNS(This,pPropVarTimecode,pCallback,punkState) ) + +#define IMFTimecodeTranslate_EndConvertTimecodeToHNS(This,pResult,phnsTime) \ + ( (This)->lpVtbl -> EndConvertTimecodeToHNS(This,pResult,phnsTime) ) + +#define IMFTimecodeTranslate_BeginConvertHNSToTimecode(This,hnsTime,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginConvertHNSToTimecode(This,hnsTime,pCallback,punkState) ) + +#define IMFTimecodeTranslate_EndConvertHNSToTimecode(This,pResult,pPropVarTimecode) \ + ( (This)->lpVtbl -> EndConvertHNSToTimecode(This,pResult,pPropVarTimecode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTimecodeTranslate_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0037 */ +/* [local] */ + +EXTERN_GUID( MF_TIMECODE_SERVICE, 0xa0d502a7, 0x0eb3, 0x4885, 0xb1, 0xb9, 0x9f, 0xeb, 0x0d, 0x08, 0x34, 0x54 ); +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +#if (WINVER >= _WIN32_WINNT_WIN8) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0037_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0037_v0_0_s_ifspec; + +#ifndef __IMFSeekInfo_INTERFACE_DEFINED__ +#define __IMFSeekInfo_INTERFACE_DEFINED__ + +/* interface IMFSeekInfo */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSeekInfo; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("26AFEA53-D9ED-42B5-AB80-E64F9EE34779") + IMFSeekInfo : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetNearestKeyFrames( + /* [annotation][in] */ + _In_ const GUID *pguidTimeFormat, + /* [annotation][in] */ + _In_ const PROPVARIANT *pvarStartPosition, + /* [annotation][out] */ + _Out_ PROPVARIANT *pvarPreviousKeyFrame, + /* [annotation][out] */ + _Out_ PROPVARIANT *pvarNextKeyFrame) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSeekInfoVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSeekInfo * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSeekInfo * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSeekInfo * This); + + HRESULT ( STDMETHODCALLTYPE *GetNearestKeyFrames )( + IMFSeekInfo * This, + /* [annotation][in] */ + _In_ const GUID *pguidTimeFormat, + /* [annotation][in] */ + _In_ const PROPVARIANT *pvarStartPosition, + /* [annotation][out] */ + _Out_ PROPVARIANT *pvarPreviousKeyFrame, + /* [annotation][out] */ + _Out_ PROPVARIANT *pvarNextKeyFrame); + + END_INTERFACE + } IMFSeekInfoVtbl; + + interface IMFSeekInfo + { + CONST_VTBL struct IMFSeekInfoVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSeekInfo_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSeekInfo_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSeekInfo_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSeekInfo_GetNearestKeyFrames(This,pguidTimeFormat,pvarStartPosition,pvarPreviousKeyFrame,pvarNextKeyFrame) \ + ( (This)->lpVtbl -> GetNearestKeyFrames(This,pguidTimeFormat,pvarStartPosition,pvarPreviousKeyFrame,pvarNextKeyFrame) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSeekInfo_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0038 */ +/* [local] */ + +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +#if (WINVER >= _WIN32_WINNT_WIN8) +EXTERN_C const GUID MF_SCRUBBING_SERVICE; +#endif // (WINVER >= _WIN32_WINNT_WIN8) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0038_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0038_v0_0_s_ifspec; + +#ifndef __IMFSimpleAudioVolume_INTERFACE_DEFINED__ +#define __IMFSimpleAudioVolume_INTERFACE_DEFINED__ + +/* interface IMFSimpleAudioVolume */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFSimpleAudioVolume; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("089EDF13-CF71-4338-8D13-9E569DBDC319") + IMFSimpleAudioVolume : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetMasterVolume( + /* [in] */ float fLevel) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMasterVolume( + /* [out] */ __RPC__out float *pfLevel) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMute( + /* [in] */ const BOOL bMute) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMute( + /* [out] */ __RPC__out BOOL *pbMute) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSimpleAudioVolumeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFSimpleAudioVolume * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFSimpleAudioVolume * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFSimpleAudioVolume * This); + + HRESULT ( STDMETHODCALLTYPE *SetMasterVolume )( + __RPC__in IMFSimpleAudioVolume * This, + /* [in] */ float fLevel); + + HRESULT ( STDMETHODCALLTYPE *GetMasterVolume )( + __RPC__in IMFSimpleAudioVolume * This, + /* [out] */ __RPC__out float *pfLevel); + + HRESULT ( STDMETHODCALLTYPE *SetMute )( + __RPC__in IMFSimpleAudioVolume * This, + /* [in] */ const BOOL bMute); + + HRESULT ( STDMETHODCALLTYPE *GetMute )( + __RPC__in IMFSimpleAudioVolume * This, + /* [out] */ __RPC__out BOOL *pbMute); + + END_INTERFACE + } IMFSimpleAudioVolumeVtbl; + + interface IMFSimpleAudioVolume + { + CONST_VTBL struct IMFSimpleAudioVolumeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSimpleAudioVolume_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSimpleAudioVolume_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSimpleAudioVolume_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSimpleAudioVolume_SetMasterVolume(This,fLevel) \ + ( (This)->lpVtbl -> SetMasterVolume(This,fLevel) ) + +#define IMFSimpleAudioVolume_GetMasterVolume(This,pfLevel) \ + ( (This)->lpVtbl -> GetMasterVolume(This,pfLevel) ) + +#define IMFSimpleAudioVolume_SetMute(This,bMute) \ + ( (This)->lpVtbl -> SetMute(This,bMute) ) + +#define IMFSimpleAudioVolume_GetMute(This,pbMute) \ + ( (This)->lpVtbl -> GetMute(This,pbMute) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSimpleAudioVolume_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0039 */ +/* [local] */ + +EXTERN_GUID( MR_POLICY_VOLUME_SERVICE, 0x1abaa2ac, 0x9d3b, 0x47c6, 0xab, 0x48, 0xc5, 0x95, 0x6, 0xde, 0x78, 0x4d); +#if (WINVER >= _WIN32_WINNT_WIN8) +EXTERN_GUID( MR_CAPTURE_POLICY_VOLUME_SERVICE, 0x24030acd, 0x107a, 0x4265, 0x97, 0x5c, 0x41, 0x4e, 0x33, 0xe6, 0x5f, 0x2a); +#endif // (WINVER >= _WIN32_WINNT_WIN8) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0039_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0039_v0_0_s_ifspec; + +#ifndef __IMFAudioStreamVolume_INTERFACE_DEFINED__ +#define __IMFAudioStreamVolume_INTERFACE_DEFINED__ + +/* interface IMFAudioStreamVolume */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFAudioStreamVolume; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("76B1BBDB-4EC8-4f36-B106-70A9316DF593") + IMFAudioStreamVolume : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetChannelCount( + /* [out] */ __RPC__out UINT32 *pdwCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetChannelVolume( + /* [in] */ UINT32 dwIndex, + /* [in] */ const float fLevel) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetChannelVolume( + /* [in] */ UINT32 dwIndex, + /* [out] */ __RPC__out float *pfLevel) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAllVolumes( + /* [in] */ UINT32 dwCount, + /* [size_is][in] */ __RPC__in_ecount_full(dwCount) const float *pfVolumes) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAllVolumes( + /* [in] */ UINT32 dwCount, + /* [size_is][out] */ __RPC__out_ecount_full(dwCount) float *pfVolumes) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFAudioStreamVolumeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFAudioStreamVolume * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFAudioStreamVolume * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFAudioStreamVolume * This); + + HRESULT ( STDMETHODCALLTYPE *GetChannelCount )( + __RPC__in IMFAudioStreamVolume * This, + /* [out] */ __RPC__out UINT32 *pdwCount); + + HRESULT ( STDMETHODCALLTYPE *SetChannelVolume )( + __RPC__in IMFAudioStreamVolume * This, + /* [in] */ UINT32 dwIndex, + /* [in] */ const float fLevel); + + HRESULT ( STDMETHODCALLTYPE *GetChannelVolume )( + __RPC__in IMFAudioStreamVolume * This, + /* [in] */ UINT32 dwIndex, + /* [out] */ __RPC__out float *pfLevel); + + HRESULT ( STDMETHODCALLTYPE *SetAllVolumes )( + __RPC__in IMFAudioStreamVolume * This, + /* [in] */ UINT32 dwCount, + /* [size_is][in] */ __RPC__in_ecount_full(dwCount) const float *pfVolumes); + + HRESULT ( STDMETHODCALLTYPE *GetAllVolumes )( + __RPC__in IMFAudioStreamVolume * This, + /* [in] */ UINT32 dwCount, + /* [size_is][out] */ __RPC__out_ecount_full(dwCount) float *pfVolumes); + + END_INTERFACE + } IMFAudioStreamVolumeVtbl; + + interface IMFAudioStreamVolume + { + CONST_VTBL struct IMFAudioStreamVolumeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFAudioStreamVolume_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFAudioStreamVolume_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFAudioStreamVolume_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFAudioStreamVolume_GetChannelCount(This,pdwCount) \ + ( (This)->lpVtbl -> GetChannelCount(This,pdwCount) ) + +#define IMFAudioStreamVolume_SetChannelVolume(This,dwIndex,fLevel) \ + ( (This)->lpVtbl -> SetChannelVolume(This,dwIndex,fLevel) ) + +#define IMFAudioStreamVolume_GetChannelVolume(This,dwIndex,pfLevel) \ + ( (This)->lpVtbl -> GetChannelVolume(This,dwIndex,pfLevel) ) + +#define IMFAudioStreamVolume_SetAllVolumes(This,dwCount,pfVolumes) \ + ( (This)->lpVtbl -> SetAllVolumes(This,dwCount,pfVolumes) ) + +#define IMFAudioStreamVolume_GetAllVolumes(This,dwCount,pfVolumes) \ + ( (This)->lpVtbl -> GetAllVolumes(This,dwCount,pfVolumes) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFAudioStreamVolume_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0040 */ +/* [local] */ + +EXTERN_GUID( MR_STREAM_VOLUME_SERVICE, 0xf8b5fa2f, 0x32ef, 0x46f5, 0xb1, 0x72, 0x13, 0x21, 0x21, 0x2f, 0xb2, 0xc4); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0040_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0040_v0_0_s_ifspec; + +#ifndef __IMFAudioPolicy_INTERFACE_DEFINED__ +#define __IMFAudioPolicy_INTERFACE_DEFINED__ + +/* interface IMFAudioPolicy */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFAudioPolicy; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("a0638c2b-6465-4395-9ae7-a321a9fd2856") + IMFAudioPolicy : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetGroupingParam( + /* [in] */ REFGUID rguidClass) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGroupingParam( + /* [annotation][out] */ + _Out_ GUID *pguidClass) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDisplayName( + /* [in] */ LPCWSTR pszName) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayName( + /* [annotation][out] */ + _Outptr_ LPWSTR *pszName) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetIconPath( + /* [in] */ LPCWSTR pszPath) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetIconPath( + /* [annotation][out] */ + _Outptr_ LPWSTR *pszPath) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFAudioPolicyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFAudioPolicy * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFAudioPolicy * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFAudioPolicy * This); + + HRESULT ( STDMETHODCALLTYPE *SetGroupingParam )( + IMFAudioPolicy * This, + /* [in] */ REFGUID rguidClass); + + HRESULT ( STDMETHODCALLTYPE *GetGroupingParam )( + IMFAudioPolicy * This, + /* [annotation][out] */ + _Out_ GUID *pguidClass); + + HRESULT ( STDMETHODCALLTYPE *SetDisplayName )( + IMFAudioPolicy * This, + /* [in] */ LPCWSTR pszName); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayName )( + IMFAudioPolicy * This, + /* [annotation][out] */ + _Outptr_ LPWSTR *pszName); + + HRESULT ( STDMETHODCALLTYPE *SetIconPath )( + IMFAudioPolicy * This, + /* [in] */ LPCWSTR pszPath); + + HRESULT ( STDMETHODCALLTYPE *GetIconPath )( + IMFAudioPolicy * This, + /* [annotation][out] */ + _Outptr_ LPWSTR *pszPath); + + END_INTERFACE + } IMFAudioPolicyVtbl; + + interface IMFAudioPolicy + { + CONST_VTBL struct IMFAudioPolicyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFAudioPolicy_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFAudioPolicy_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFAudioPolicy_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFAudioPolicy_SetGroupingParam(This,rguidClass) \ + ( (This)->lpVtbl -> SetGroupingParam(This,rguidClass) ) + +#define IMFAudioPolicy_GetGroupingParam(This,pguidClass) \ + ( (This)->lpVtbl -> GetGroupingParam(This,pguidClass) ) + +#define IMFAudioPolicy_SetDisplayName(This,pszName) \ + ( (This)->lpVtbl -> SetDisplayName(This,pszName) ) + +#define IMFAudioPolicy_GetDisplayName(This,pszName) \ + ( (This)->lpVtbl -> GetDisplayName(This,pszName) ) + +#define IMFAudioPolicy_SetIconPath(This,pszPath) \ + ( (This)->lpVtbl -> SetIconPath(This,pszPath) ) + +#define IMFAudioPolicy_GetIconPath(This,pszPath) \ + ( (This)->lpVtbl -> GetIconPath(This,pszPath) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFAudioPolicy_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0041 */ +/* [local] */ + +EXTERN_GUID( MR_AUDIO_POLICY_SERVICE, 0x911fd737, 0x6775, 0x4ab0, 0xa6, 0x14, 0x29, 0x78, 0x62, 0xfd, 0xac, 0x88); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0041_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0041_v0_0_s_ifspec; + +#ifndef __IMFSampleGrabberSinkCallback_INTERFACE_DEFINED__ +#define __IMFSampleGrabberSinkCallback_INTERFACE_DEFINED__ + +/* interface IMFSampleGrabberSinkCallback */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSampleGrabberSinkCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8C7B80BF-EE42-4b59-B1DF-55668E1BDCA8") + IMFSampleGrabberSinkCallback : public IMFClockStateSink + { + public: + virtual HRESULT STDMETHODCALLTYPE OnSetPresentationClock( + /* [in] */ IMFPresentationClock *pPresentationClock) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnProcessSample( + /* [in] */ REFGUID guidMajorMediaType, + /* [in] */ DWORD dwSampleFlags, + /* [in] */ LONGLONG llSampleTime, + /* [in] */ LONGLONG llSampleDuration, + /* [annotation][in] */ + _In_reads_bytes_(dwSampleSize) const BYTE *pSampleBuffer, + /* [in] */ DWORD dwSampleSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnShutdown( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSampleGrabberSinkCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSampleGrabberSinkCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSampleGrabberSinkCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSampleGrabberSinkCallback * This); + + HRESULT ( STDMETHODCALLTYPE *OnClockStart )( + IMFSampleGrabberSinkCallback * This, + /* [in] */ MFTIME hnsSystemTime, + /* [in] */ LONGLONG llClockStartOffset); + + HRESULT ( STDMETHODCALLTYPE *OnClockStop )( + IMFSampleGrabberSinkCallback * This, + /* [in] */ MFTIME hnsSystemTime); + + HRESULT ( STDMETHODCALLTYPE *OnClockPause )( + IMFSampleGrabberSinkCallback * This, + /* [in] */ MFTIME hnsSystemTime); + + HRESULT ( STDMETHODCALLTYPE *OnClockRestart )( + IMFSampleGrabberSinkCallback * This, + /* [in] */ MFTIME hnsSystemTime); + + HRESULT ( STDMETHODCALLTYPE *OnClockSetRate )( + IMFSampleGrabberSinkCallback * This, + /* [in] */ MFTIME hnsSystemTime, + /* [in] */ float flRate); + + HRESULT ( STDMETHODCALLTYPE *OnSetPresentationClock )( + IMFSampleGrabberSinkCallback * This, + /* [in] */ IMFPresentationClock *pPresentationClock); + + HRESULT ( STDMETHODCALLTYPE *OnProcessSample )( + IMFSampleGrabberSinkCallback * This, + /* [in] */ REFGUID guidMajorMediaType, + /* [in] */ DWORD dwSampleFlags, + /* [in] */ LONGLONG llSampleTime, + /* [in] */ LONGLONG llSampleDuration, + /* [annotation][in] */ + _In_reads_bytes_(dwSampleSize) const BYTE *pSampleBuffer, + /* [in] */ DWORD dwSampleSize); + + HRESULT ( STDMETHODCALLTYPE *OnShutdown )( + IMFSampleGrabberSinkCallback * This); + + END_INTERFACE + } IMFSampleGrabberSinkCallbackVtbl; + + interface IMFSampleGrabberSinkCallback + { + CONST_VTBL struct IMFSampleGrabberSinkCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSampleGrabberSinkCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSampleGrabberSinkCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSampleGrabberSinkCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSampleGrabberSinkCallback_OnClockStart(This,hnsSystemTime,llClockStartOffset) \ + ( (This)->lpVtbl -> OnClockStart(This,hnsSystemTime,llClockStartOffset) ) + +#define IMFSampleGrabberSinkCallback_OnClockStop(This,hnsSystemTime) \ + ( (This)->lpVtbl -> OnClockStop(This,hnsSystemTime) ) + +#define IMFSampleGrabberSinkCallback_OnClockPause(This,hnsSystemTime) \ + ( (This)->lpVtbl -> OnClockPause(This,hnsSystemTime) ) + +#define IMFSampleGrabberSinkCallback_OnClockRestart(This,hnsSystemTime) \ + ( (This)->lpVtbl -> OnClockRestart(This,hnsSystemTime) ) + +#define IMFSampleGrabberSinkCallback_OnClockSetRate(This,hnsSystemTime,flRate) \ + ( (This)->lpVtbl -> OnClockSetRate(This,hnsSystemTime,flRate) ) + + +#define IMFSampleGrabberSinkCallback_OnSetPresentationClock(This,pPresentationClock) \ + ( (This)->lpVtbl -> OnSetPresentationClock(This,pPresentationClock) ) + +#define IMFSampleGrabberSinkCallback_OnProcessSample(This,guidMajorMediaType,dwSampleFlags,llSampleTime,llSampleDuration,pSampleBuffer,dwSampleSize) \ + ( (This)->lpVtbl -> OnProcessSample(This,guidMajorMediaType,dwSampleFlags,llSampleTime,llSampleDuration,pSampleBuffer,dwSampleSize) ) + +#define IMFSampleGrabberSinkCallback_OnShutdown(This) \ + ( (This)->lpVtbl -> OnShutdown(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSampleGrabberSinkCallback_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0042 */ +/* [local] */ + +STDAPI +MFCreateSampleGrabberSinkActivate( + IMFMediaType *pIMFMediaType, + IMFSampleGrabberSinkCallback* pIMFSampleGrabberSinkCallback, + _Outptr_ IMFActivate** ppIActivate + ); +EXTERN_GUID( MF_SAMPLEGRABBERSINK_SAMPLE_TIME_OFFSET, 0x62e3d776, 0x8100, 0x4e03, 0xa6, 0xe8, 0xbd, 0x38, 0x57, 0xac, 0x9c, 0x47); +#if (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_GUID( MF_SAMPLEGRABBERSINK_IGNORE_CLOCK, 0x0efda2c0, 0x2b69, 0x4e2e, 0xab, 0x8d, 0x46, 0xdc, 0xbf, 0xf7, 0xd2, 0x5d); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0042_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0042_v0_0_s_ifspec; + +#ifndef __IMFSampleGrabberSinkCallback2_INTERFACE_DEFINED__ +#define __IMFSampleGrabberSinkCallback2_INTERFACE_DEFINED__ + +/* interface IMFSampleGrabberSinkCallback2 */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSampleGrabberSinkCallback2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ca86aa50-c46e-429e-ab27-16d6ac6844cb") + IMFSampleGrabberSinkCallback2 : public IMFSampleGrabberSinkCallback + { + public: + virtual HRESULT STDMETHODCALLTYPE OnProcessSampleEx( + /* [in] */ REFGUID guidMajorMediaType, + /* [in] */ DWORD dwSampleFlags, + /* [in] */ LONGLONG llSampleTime, + /* [in] */ LONGLONG llSampleDuration, + /* [annotation][in] */ + _In_reads_bytes_(dwSampleSize) const BYTE *pSampleBuffer, + /* [in] */ DWORD dwSampleSize, + /* [annotation][in] */ + _In_ IMFAttributes *pAttributes) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSampleGrabberSinkCallback2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSampleGrabberSinkCallback2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSampleGrabberSinkCallback2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSampleGrabberSinkCallback2 * This); + + HRESULT ( STDMETHODCALLTYPE *OnClockStart )( + IMFSampleGrabberSinkCallback2 * This, + /* [in] */ MFTIME hnsSystemTime, + /* [in] */ LONGLONG llClockStartOffset); + + HRESULT ( STDMETHODCALLTYPE *OnClockStop )( + IMFSampleGrabberSinkCallback2 * This, + /* [in] */ MFTIME hnsSystemTime); + + HRESULT ( STDMETHODCALLTYPE *OnClockPause )( + IMFSampleGrabberSinkCallback2 * This, + /* [in] */ MFTIME hnsSystemTime); + + HRESULT ( STDMETHODCALLTYPE *OnClockRestart )( + IMFSampleGrabberSinkCallback2 * This, + /* [in] */ MFTIME hnsSystemTime); + + HRESULT ( STDMETHODCALLTYPE *OnClockSetRate )( + IMFSampleGrabberSinkCallback2 * This, + /* [in] */ MFTIME hnsSystemTime, + /* [in] */ float flRate); + + HRESULT ( STDMETHODCALLTYPE *OnSetPresentationClock )( + IMFSampleGrabberSinkCallback2 * This, + /* [in] */ IMFPresentationClock *pPresentationClock); + + HRESULT ( STDMETHODCALLTYPE *OnProcessSample )( + IMFSampleGrabberSinkCallback2 * This, + /* [in] */ REFGUID guidMajorMediaType, + /* [in] */ DWORD dwSampleFlags, + /* [in] */ LONGLONG llSampleTime, + /* [in] */ LONGLONG llSampleDuration, + /* [annotation][in] */ + _In_reads_bytes_(dwSampleSize) const BYTE *pSampleBuffer, + /* [in] */ DWORD dwSampleSize); + + HRESULT ( STDMETHODCALLTYPE *OnShutdown )( + IMFSampleGrabberSinkCallback2 * This); + + HRESULT ( STDMETHODCALLTYPE *OnProcessSampleEx )( + IMFSampleGrabberSinkCallback2 * This, + /* [in] */ REFGUID guidMajorMediaType, + /* [in] */ DWORD dwSampleFlags, + /* [in] */ LONGLONG llSampleTime, + /* [in] */ LONGLONG llSampleDuration, + /* [annotation][in] */ + _In_reads_bytes_(dwSampleSize) const BYTE *pSampleBuffer, + /* [in] */ DWORD dwSampleSize, + /* [annotation][in] */ + _In_ IMFAttributes *pAttributes); + + END_INTERFACE + } IMFSampleGrabberSinkCallback2Vtbl; + + interface IMFSampleGrabberSinkCallback2 + { + CONST_VTBL struct IMFSampleGrabberSinkCallback2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSampleGrabberSinkCallback2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSampleGrabberSinkCallback2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSampleGrabberSinkCallback2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSampleGrabberSinkCallback2_OnClockStart(This,hnsSystemTime,llClockStartOffset) \ + ( (This)->lpVtbl -> OnClockStart(This,hnsSystemTime,llClockStartOffset) ) + +#define IMFSampleGrabberSinkCallback2_OnClockStop(This,hnsSystemTime) \ + ( (This)->lpVtbl -> OnClockStop(This,hnsSystemTime) ) + +#define IMFSampleGrabberSinkCallback2_OnClockPause(This,hnsSystemTime) \ + ( (This)->lpVtbl -> OnClockPause(This,hnsSystemTime) ) + +#define IMFSampleGrabberSinkCallback2_OnClockRestart(This,hnsSystemTime) \ + ( (This)->lpVtbl -> OnClockRestart(This,hnsSystemTime) ) + +#define IMFSampleGrabberSinkCallback2_OnClockSetRate(This,hnsSystemTime,flRate) \ + ( (This)->lpVtbl -> OnClockSetRate(This,hnsSystemTime,flRate) ) + + +#define IMFSampleGrabberSinkCallback2_OnSetPresentationClock(This,pPresentationClock) \ + ( (This)->lpVtbl -> OnSetPresentationClock(This,pPresentationClock) ) + +#define IMFSampleGrabberSinkCallback2_OnProcessSample(This,guidMajorMediaType,dwSampleFlags,llSampleTime,llSampleDuration,pSampleBuffer,dwSampleSize) \ + ( (This)->lpVtbl -> OnProcessSample(This,guidMajorMediaType,dwSampleFlags,llSampleTime,llSampleDuration,pSampleBuffer,dwSampleSize) ) + +#define IMFSampleGrabberSinkCallback2_OnShutdown(This) \ + ( (This)->lpVtbl -> OnShutdown(This) ) + + +#define IMFSampleGrabberSinkCallback2_OnProcessSampleEx(This,guidMajorMediaType,dwSampleFlags,llSampleTime,llSampleDuration,pSampleBuffer,dwSampleSize,pAttributes) \ + ( (This)->lpVtbl -> OnProcessSampleEx(This,guidMajorMediaType,dwSampleFlags,llSampleTime,llSampleDuration,pSampleBuffer,dwSampleSize,pAttributes) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSampleGrabberSinkCallback2_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0043 */ +/* [local] */ + +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_GUID( MF_QUALITY_SERVICES, 0xb7e2be11, 0x2f96, 0x4640, 0xb5, 0x2c, 0x28, 0x23, 0x65, 0xbd, 0xf1, 0x6c); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0043_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0043_v0_0_s_ifspec; + +#ifndef __IMFWorkQueueServices_INTERFACE_DEFINED__ +#define __IMFWorkQueueServices_INTERFACE_DEFINED__ + +/* interface IMFWorkQueueServices */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFWorkQueueServices; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("35FE1BB8-A3A9-40fe-BBEC-EB569C9CCCA3") + IMFWorkQueueServices : public IUnknown + { + public: + virtual /* [local] */ HRESULT STDMETHODCALLTYPE BeginRegisterTopologyWorkQueuesWithMMCSS( + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE EndRegisterTopologyWorkQueuesWithMMCSS( + /* [in] */ IMFAsyncResult *pResult) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE BeginUnregisterTopologyWorkQueuesWithMMCSS( + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE EndUnregisterTopologyWorkQueuesWithMMCSS( + /* [in] */ IMFAsyncResult *pResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTopologyWorkQueueMMCSSClass( + /* [in] */ DWORD dwTopologyWorkQueueId, + /* [size_is][out] */ __RPC__out_ecount_full(*pcchClass) LPWSTR pwszClass, + /* [out][in] */ __RPC__inout DWORD *pcchClass) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTopologyWorkQueueMMCSSTaskId( + /* [in] */ DWORD dwTopologyWorkQueueId, + /* [out] */ __RPC__out DWORD *pdwTaskId) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE BeginRegisterPlatformWorkQueueWithMMCSS( + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ LPCWSTR wszClass, + /* [in] */ DWORD dwTaskId, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE EndRegisterPlatformWorkQueueWithMMCSS( + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ DWORD *pdwTaskId) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE BeginUnregisterPlatformWorkQueueWithMMCSS( + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE EndUnregisterPlatformWorkQueueWithMMCSS( + /* [in] */ IMFAsyncResult *pResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPlaftormWorkQueueMMCSSClass( + /* [in] */ DWORD dwPlatformWorkQueueId, + /* [size_is][out] */ __RPC__out_ecount_full(*pcchClass) LPWSTR pwszClass, + /* [out][in] */ __RPC__inout DWORD *pcchClass) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPlatformWorkQueueMMCSSTaskId( + /* [in] */ DWORD dwPlatformWorkQueueId, + /* [out] */ __RPC__out DWORD *pdwTaskId) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFWorkQueueServicesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFWorkQueueServices * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFWorkQueueServices * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginRegisterTopologyWorkQueuesWithMMCSS )( + IMFWorkQueueServices * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndRegisterTopologyWorkQueuesWithMMCSS )( + IMFWorkQueueServices * This, + /* [in] */ IMFAsyncResult *pResult); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginUnregisterTopologyWorkQueuesWithMMCSS )( + IMFWorkQueueServices * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndUnregisterTopologyWorkQueuesWithMMCSS )( + IMFWorkQueueServices * This, + /* [in] */ IMFAsyncResult *pResult); + + HRESULT ( STDMETHODCALLTYPE *GetTopologyWorkQueueMMCSSClass )( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ DWORD dwTopologyWorkQueueId, + /* [size_is][out] */ __RPC__out_ecount_full(*pcchClass) LPWSTR pwszClass, + /* [out][in] */ __RPC__inout DWORD *pcchClass); + + HRESULT ( STDMETHODCALLTYPE *GetTopologyWorkQueueMMCSSTaskId )( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ DWORD dwTopologyWorkQueueId, + /* [out] */ __RPC__out DWORD *pdwTaskId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginRegisterPlatformWorkQueueWithMMCSS )( + IMFWorkQueueServices * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ LPCWSTR wszClass, + /* [in] */ DWORD dwTaskId, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndRegisterPlatformWorkQueueWithMMCSS )( + IMFWorkQueueServices * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ DWORD *pdwTaskId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginUnregisterPlatformWorkQueueWithMMCSS )( + IMFWorkQueueServices * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndUnregisterPlatformWorkQueueWithMMCSS )( + IMFWorkQueueServices * This, + /* [in] */ IMFAsyncResult *pResult); + + HRESULT ( STDMETHODCALLTYPE *GetPlaftormWorkQueueMMCSSClass )( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ DWORD dwPlatformWorkQueueId, + /* [size_is][out] */ __RPC__out_ecount_full(*pcchClass) LPWSTR pwszClass, + /* [out][in] */ __RPC__inout DWORD *pcchClass); + + HRESULT ( STDMETHODCALLTYPE *GetPlatformWorkQueueMMCSSTaskId )( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ DWORD dwPlatformWorkQueueId, + /* [out] */ __RPC__out DWORD *pdwTaskId); + + END_INTERFACE + } IMFWorkQueueServicesVtbl; + + interface IMFWorkQueueServices + { + CONST_VTBL struct IMFWorkQueueServicesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFWorkQueueServices_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFWorkQueueServices_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFWorkQueueServices_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFWorkQueueServices_BeginRegisterTopologyWorkQueuesWithMMCSS(This,pCallback,pState) \ + ( (This)->lpVtbl -> BeginRegisterTopologyWorkQueuesWithMMCSS(This,pCallback,pState) ) + +#define IMFWorkQueueServices_EndRegisterTopologyWorkQueuesWithMMCSS(This,pResult) \ + ( (This)->lpVtbl -> EndRegisterTopologyWorkQueuesWithMMCSS(This,pResult) ) + +#define IMFWorkQueueServices_BeginUnregisterTopologyWorkQueuesWithMMCSS(This,pCallback,pState) \ + ( (This)->lpVtbl -> BeginUnregisterTopologyWorkQueuesWithMMCSS(This,pCallback,pState) ) + +#define IMFWorkQueueServices_EndUnregisterTopologyWorkQueuesWithMMCSS(This,pResult) \ + ( (This)->lpVtbl -> EndUnregisterTopologyWorkQueuesWithMMCSS(This,pResult) ) + +#define IMFWorkQueueServices_GetTopologyWorkQueueMMCSSClass(This,dwTopologyWorkQueueId,pwszClass,pcchClass) \ + ( (This)->lpVtbl -> GetTopologyWorkQueueMMCSSClass(This,dwTopologyWorkQueueId,pwszClass,pcchClass) ) + +#define IMFWorkQueueServices_GetTopologyWorkQueueMMCSSTaskId(This,dwTopologyWorkQueueId,pdwTaskId) \ + ( (This)->lpVtbl -> GetTopologyWorkQueueMMCSSTaskId(This,dwTopologyWorkQueueId,pdwTaskId) ) + +#define IMFWorkQueueServices_BeginRegisterPlatformWorkQueueWithMMCSS(This,dwPlatformWorkQueue,wszClass,dwTaskId,pCallback,pState) \ + ( (This)->lpVtbl -> BeginRegisterPlatformWorkQueueWithMMCSS(This,dwPlatformWorkQueue,wszClass,dwTaskId,pCallback,pState) ) + +#define IMFWorkQueueServices_EndRegisterPlatformWorkQueueWithMMCSS(This,pResult,pdwTaskId) \ + ( (This)->lpVtbl -> EndRegisterPlatformWorkQueueWithMMCSS(This,pResult,pdwTaskId) ) + +#define IMFWorkQueueServices_BeginUnregisterPlatformWorkQueueWithMMCSS(This,dwPlatformWorkQueue,pCallback,pState) \ + ( (This)->lpVtbl -> BeginUnregisterPlatformWorkQueueWithMMCSS(This,dwPlatformWorkQueue,pCallback,pState) ) + +#define IMFWorkQueueServices_EndUnregisterPlatformWorkQueueWithMMCSS(This,pResult) \ + ( (This)->lpVtbl -> EndUnregisterPlatformWorkQueueWithMMCSS(This,pResult) ) + +#define IMFWorkQueueServices_GetPlaftormWorkQueueMMCSSClass(This,dwPlatformWorkQueueId,pwszClass,pcchClass) \ + ( (This)->lpVtbl -> GetPlaftormWorkQueueMMCSSClass(This,dwPlatformWorkQueueId,pwszClass,pcchClass) ) + +#define IMFWorkQueueServices_GetPlatformWorkQueueMMCSSTaskId(This,dwPlatformWorkQueueId,pdwTaskId) \ + ( (This)->lpVtbl -> GetPlatformWorkQueueMMCSSTaskId(This,dwPlatformWorkQueueId,pdwTaskId) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_RemoteBeginRegisterTopologyWorkQueuesWithMMCSS_Proxy( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + + +void __RPC_STUB IMFWorkQueueServices_RemoteBeginRegisterTopologyWorkQueuesWithMMCSS_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_RemoteEndRegisterTopologyWorkQueuesWithMMCSS_Proxy( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in_opt IUnknown *pResult); + + +void __RPC_STUB IMFWorkQueueServices_RemoteEndRegisterTopologyWorkQueuesWithMMCSS_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_RemoteBeginUnregisterTopologyWorkQueuesWithMMCSS_Proxy( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + + +void __RPC_STUB IMFWorkQueueServices_RemoteBeginUnregisterTopologyWorkQueuesWithMMCSS_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_RemoteEndUnregisterTopologyWorkQueuesWithMMCSS_Proxy( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in_opt IUnknown *pResult); + + +void __RPC_STUB IMFWorkQueueServices_RemoteEndUnregisterTopologyWorkQueuesWithMMCSS_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_RemoteBeginRegisterPlatformWorkQueueWithMMCSS_Proxy( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ __RPC__in LPCWSTR wszClass, + /* [in] */ DWORD dwTaskId, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + + +void __RPC_STUB IMFWorkQueueServices_RemoteBeginRegisterPlatformWorkQueueWithMMCSS_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_RemoteEndRegisterPlatformWorkQueueWithMMCSS_Proxy( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in_opt IUnknown *pResult, + /* [out] */ __RPC__out DWORD *pdwTaskId); + + +void __RPC_STUB IMFWorkQueueServices_RemoteEndRegisterPlatformWorkQueueWithMMCSS_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_RemoteBeginUnregisterPlatformWorkQueueWithMMCSS_Proxy( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + + +void __RPC_STUB IMFWorkQueueServices_RemoteBeginUnregisterPlatformWorkQueueWithMMCSS_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_RemoteEndUnregisterPlatformWorkQueueWithMMCSS_Proxy( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in_opt IUnknown *pResult); + + +void __RPC_STUB IMFWorkQueueServices_RemoteEndUnregisterPlatformWorkQueueWithMMCSS_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMFWorkQueueServices_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0044 */ +/* [local] */ + +EXTERN_GUID( MF_WORKQUEUE_SERVICES, 0x8e37d489, 0x41e0, 0x413a, 0x90, 0x68, 0x28, 0x7c, 0x88, 0x6d, 0x8d, 0xda); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0044_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0044_v0_0_s_ifspec; + +#ifndef __IMFWorkQueueServicesEx_INTERFACE_DEFINED__ +#define __IMFWorkQueueServicesEx_INTERFACE_DEFINED__ + +/* interface IMFWorkQueueServicesEx */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFWorkQueueServicesEx; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("96bf961b-40fe-42f1-ba9d-320238b49700") + IMFWorkQueueServicesEx : public IMFWorkQueueServices + { + public: + virtual HRESULT STDMETHODCALLTYPE GetTopologyWorkQueueMMCSSPriority( + /* [in] */ DWORD dwTopologyWorkQueueId, + /* [out] */ __RPC__out LONG *plPriority) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE BeginRegisterPlatformWorkQueueWithMMCSSEx( + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ LPCWSTR wszClass, + /* [in] */ DWORD dwTaskId, + /* [in] */ LONG lPriority, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPlatformWorkQueueMMCSSPriority( + /* [in] */ DWORD dwPlatformWorkQueueId, + /* [out] */ __RPC__out LONG *plPriority) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFWorkQueueServicesExVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFWorkQueueServicesEx * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFWorkQueueServicesEx * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFWorkQueueServicesEx * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginRegisterTopologyWorkQueuesWithMMCSS )( + IMFWorkQueueServicesEx * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndRegisterTopologyWorkQueuesWithMMCSS )( + IMFWorkQueueServicesEx * This, + /* [in] */ IMFAsyncResult *pResult); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginUnregisterTopologyWorkQueuesWithMMCSS )( + IMFWorkQueueServicesEx * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndUnregisterTopologyWorkQueuesWithMMCSS )( + IMFWorkQueueServicesEx * This, + /* [in] */ IMFAsyncResult *pResult); + + HRESULT ( STDMETHODCALLTYPE *GetTopologyWorkQueueMMCSSClass )( + __RPC__in IMFWorkQueueServicesEx * This, + /* [in] */ DWORD dwTopologyWorkQueueId, + /* [size_is][out] */ __RPC__out_ecount_full(*pcchClass) LPWSTR pwszClass, + /* [out][in] */ __RPC__inout DWORD *pcchClass); + + HRESULT ( STDMETHODCALLTYPE *GetTopologyWorkQueueMMCSSTaskId )( + __RPC__in IMFWorkQueueServicesEx * This, + /* [in] */ DWORD dwTopologyWorkQueueId, + /* [out] */ __RPC__out DWORD *pdwTaskId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginRegisterPlatformWorkQueueWithMMCSS )( + IMFWorkQueueServicesEx * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ LPCWSTR wszClass, + /* [in] */ DWORD dwTaskId, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndRegisterPlatformWorkQueueWithMMCSS )( + IMFWorkQueueServicesEx * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ DWORD *pdwTaskId); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginUnregisterPlatformWorkQueueWithMMCSS )( + IMFWorkQueueServicesEx * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndUnregisterPlatformWorkQueueWithMMCSS )( + IMFWorkQueueServicesEx * This, + /* [in] */ IMFAsyncResult *pResult); + + HRESULT ( STDMETHODCALLTYPE *GetPlaftormWorkQueueMMCSSClass )( + __RPC__in IMFWorkQueueServicesEx * This, + /* [in] */ DWORD dwPlatformWorkQueueId, + /* [size_is][out] */ __RPC__out_ecount_full(*pcchClass) LPWSTR pwszClass, + /* [out][in] */ __RPC__inout DWORD *pcchClass); + + HRESULT ( STDMETHODCALLTYPE *GetPlatformWorkQueueMMCSSTaskId )( + __RPC__in IMFWorkQueueServicesEx * This, + /* [in] */ DWORD dwPlatformWorkQueueId, + /* [out] */ __RPC__out DWORD *pdwTaskId); + + HRESULT ( STDMETHODCALLTYPE *GetTopologyWorkQueueMMCSSPriority )( + __RPC__in IMFWorkQueueServicesEx * This, + /* [in] */ DWORD dwTopologyWorkQueueId, + /* [out] */ __RPC__out LONG *plPriority); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginRegisterPlatformWorkQueueWithMMCSSEx )( + IMFWorkQueueServicesEx * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ LPCWSTR wszClass, + /* [in] */ DWORD dwTaskId, + /* [in] */ LONG lPriority, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + HRESULT ( STDMETHODCALLTYPE *GetPlatformWorkQueueMMCSSPriority )( + __RPC__in IMFWorkQueueServicesEx * This, + /* [in] */ DWORD dwPlatformWorkQueueId, + /* [out] */ __RPC__out LONG *plPriority); + + END_INTERFACE + } IMFWorkQueueServicesExVtbl; + + interface IMFWorkQueueServicesEx + { + CONST_VTBL struct IMFWorkQueueServicesExVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFWorkQueueServicesEx_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFWorkQueueServicesEx_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFWorkQueueServicesEx_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFWorkQueueServicesEx_BeginRegisterTopologyWorkQueuesWithMMCSS(This,pCallback,pState) \ + ( (This)->lpVtbl -> BeginRegisterTopologyWorkQueuesWithMMCSS(This,pCallback,pState) ) + +#define IMFWorkQueueServicesEx_EndRegisterTopologyWorkQueuesWithMMCSS(This,pResult) \ + ( (This)->lpVtbl -> EndRegisterTopologyWorkQueuesWithMMCSS(This,pResult) ) + +#define IMFWorkQueueServicesEx_BeginUnregisterTopologyWorkQueuesWithMMCSS(This,pCallback,pState) \ + ( (This)->lpVtbl -> BeginUnregisterTopologyWorkQueuesWithMMCSS(This,pCallback,pState) ) + +#define IMFWorkQueueServicesEx_EndUnregisterTopologyWorkQueuesWithMMCSS(This,pResult) \ + ( (This)->lpVtbl -> EndUnregisterTopologyWorkQueuesWithMMCSS(This,pResult) ) + +#define IMFWorkQueueServicesEx_GetTopologyWorkQueueMMCSSClass(This,dwTopologyWorkQueueId,pwszClass,pcchClass) \ + ( (This)->lpVtbl -> GetTopologyWorkQueueMMCSSClass(This,dwTopologyWorkQueueId,pwszClass,pcchClass) ) + +#define IMFWorkQueueServicesEx_GetTopologyWorkQueueMMCSSTaskId(This,dwTopologyWorkQueueId,pdwTaskId) \ + ( (This)->lpVtbl -> GetTopologyWorkQueueMMCSSTaskId(This,dwTopologyWorkQueueId,pdwTaskId) ) + +#define IMFWorkQueueServicesEx_BeginRegisterPlatformWorkQueueWithMMCSS(This,dwPlatformWorkQueue,wszClass,dwTaskId,pCallback,pState) \ + ( (This)->lpVtbl -> BeginRegisterPlatformWorkQueueWithMMCSS(This,dwPlatformWorkQueue,wszClass,dwTaskId,pCallback,pState) ) + +#define IMFWorkQueueServicesEx_EndRegisterPlatformWorkQueueWithMMCSS(This,pResult,pdwTaskId) \ + ( (This)->lpVtbl -> EndRegisterPlatformWorkQueueWithMMCSS(This,pResult,pdwTaskId) ) + +#define IMFWorkQueueServicesEx_BeginUnregisterPlatformWorkQueueWithMMCSS(This,dwPlatformWorkQueue,pCallback,pState) \ + ( (This)->lpVtbl -> BeginUnregisterPlatformWorkQueueWithMMCSS(This,dwPlatformWorkQueue,pCallback,pState) ) + +#define IMFWorkQueueServicesEx_EndUnregisterPlatformWorkQueueWithMMCSS(This,pResult) \ + ( (This)->lpVtbl -> EndUnregisterPlatformWorkQueueWithMMCSS(This,pResult) ) + +#define IMFWorkQueueServicesEx_GetPlaftormWorkQueueMMCSSClass(This,dwPlatformWorkQueueId,pwszClass,pcchClass) \ + ( (This)->lpVtbl -> GetPlaftormWorkQueueMMCSSClass(This,dwPlatformWorkQueueId,pwszClass,pcchClass) ) + +#define IMFWorkQueueServicesEx_GetPlatformWorkQueueMMCSSTaskId(This,dwPlatformWorkQueueId,pdwTaskId) \ + ( (This)->lpVtbl -> GetPlatformWorkQueueMMCSSTaskId(This,dwPlatformWorkQueueId,pdwTaskId) ) + + +#define IMFWorkQueueServicesEx_GetTopologyWorkQueueMMCSSPriority(This,dwTopologyWorkQueueId,plPriority) \ + ( (This)->lpVtbl -> GetTopologyWorkQueueMMCSSPriority(This,dwTopologyWorkQueueId,plPriority) ) + +#define IMFWorkQueueServicesEx_BeginRegisterPlatformWorkQueueWithMMCSSEx(This,dwPlatformWorkQueue,wszClass,dwTaskId,lPriority,pCallback,pState) \ + ( (This)->lpVtbl -> BeginRegisterPlatformWorkQueueWithMMCSSEx(This,dwPlatformWorkQueue,wszClass,dwTaskId,lPriority,pCallback,pState) ) + +#define IMFWorkQueueServicesEx_GetPlatformWorkQueueMMCSSPriority(This,dwPlatformWorkQueueId,plPriority) \ + ( (This)->lpVtbl -> GetPlatformWorkQueueMMCSSPriority(This,dwPlatformWorkQueueId,plPriority) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServicesEx_RemoteBeginRegisterPlatformWorkQueueWithMMCSSEx_Proxy( + __RPC__in IMFWorkQueueServicesEx * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ __RPC__in LPCWSTR wszClass, + /* [in] */ DWORD dwTaskId, + /* [in] */ LONG lPriority, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + + +void __RPC_STUB IMFWorkQueueServicesEx_RemoteBeginRegisterPlatformWorkQueueWithMMCSSEx_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMFWorkQueueServicesEx_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0045 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef +enum _MF_QUALITY_DROP_MODE + { + MF_DROP_MODE_NONE = 0, + MF_DROP_MODE_1 = 0x1, + MF_DROP_MODE_2 = 0x2, + MF_DROP_MODE_3 = 0x3, + MF_DROP_MODE_4 = 0x4, + MF_DROP_MODE_5 = 0x5, + MF_NUM_DROP_MODES = 0x6 + } MF_QUALITY_DROP_MODE; + +typedef +enum _MF_QUALITY_LEVEL + { + MF_QUALITY_NORMAL = 0, + MF_QUALITY_NORMAL_MINUS_1 = 0x1, + MF_QUALITY_NORMAL_MINUS_2 = 0x2, + MF_QUALITY_NORMAL_MINUS_3 = 0x3, + MF_QUALITY_NORMAL_MINUS_4 = 0x4, + MF_QUALITY_NORMAL_MINUS_5 = 0x5, + MF_NUM_QUALITY_LEVELS = 0x6 + } MF_QUALITY_LEVEL; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef +enum _MF_QUALITY_ADVISE_FLAGS + { + MF_QUALITY_CANNOT_KEEP_UP = 0x1 + } MF_QUALITY_ADVISE_FLAGS; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0045_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0045_v0_0_s_ifspec; + +#ifndef __IMFQualityManager_INTERFACE_DEFINED__ +#define __IMFQualityManager_INTERFACE_DEFINED__ + +/* interface IMFQualityManager */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFQualityManager; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8D009D86-5B9F-4115-B1FC-9F80D52AB8AB") + IMFQualityManager : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE NotifyTopology( + /* [in] */ IMFTopology *pTopology) = 0; + + virtual HRESULT STDMETHODCALLTYPE NotifyPresentationClock( + /* [in] */ IMFPresentationClock *pClock) = 0; + + virtual HRESULT STDMETHODCALLTYPE NotifyProcessInput( + /* [in] */ IMFTopologyNode *pNode, + /* [in] */ long lInputIndex, + /* [in] */ IMFSample *pSample) = 0; + + virtual HRESULT STDMETHODCALLTYPE NotifyProcessOutput( + /* [in] */ IMFTopologyNode *pNode, + /* [in] */ long lOutputIndex, + /* [in] */ IMFSample *pSample) = 0; + + virtual HRESULT STDMETHODCALLTYPE NotifyQualityEvent( + /* [in] */ IUnknown *pObject, + /* [in] */ IMFMediaEvent *pEvent) = 0; + + virtual HRESULT STDMETHODCALLTYPE Shutdown( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFQualityManagerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFQualityManager * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFQualityManager * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFQualityManager * This); + + HRESULT ( STDMETHODCALLTYPE *NotifyTopology )( + IMFQualityManager * This, + /* [in] */ IMFTopology *pTopology); + + HRESULT ( STDMETHODCALLTYPE *NotifyPresentationClock )( + IMFQualityManager * This, + /* [in] */ IMFPresentationClock *pClock); + + HRESULT ( STDMETHODCALLTYPE *NotifyProcessInput )( + IMFQualityManager * This, + /* [in] */ IMFTopologyNode *pNode, + /* [in] */ long lInputIndex, + /* [in] */ IMFSample *pSample); + + HRESULT ( STDMETHODCALLTYPE *NotifyProcessOutput )( + IMFQualityManager * This, + /* [in] */ IMFTopologyNode *pNode, + /* [in] */ long lOutputIndex, + /* [in] */ IMFSample *pSample); + + HRESULT ( STDMETHODCALLTYPE *NotifyQualityEvent )( + IMFQualityManager * This, + /* [in] */ IUnknown *pObject, + /* [in] */ IMFMediaEvent *pEvent); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + IMFQualityManager * This); + + END_INTERFACE + } IMFQualityManagerVtbl; + + interface IMFQualityManager + { + CONST_VTBL struct IMFQualityManagerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFQualityManager_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFQualityManager_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFQualityManager_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFQualityManager_NotifyTopology(This,pTopology) \ + ( (This)->lpVtbl -> NotifyTopology(This,pTopology) ) + +#define IMFQualityManager_NotifyPresentationClock(This,pClock) \ + ( (This)->lpVtbl -> NotifyPresentationClock(This,pClock) ) + +#define IMFQualityManager_NotifyProcessInput(This,pNode,lInputIndex,pSample) \ + ( (This)->lpVtbl -> NotifyProcessInput(This,pNode,lInputIndex,pSample) ) + +#define IMFQualityManager_NotifyProcessOutput(This,pNode,lOutputIndex,pSample) \ + ( (This)->lpVtbl -> NotifyProcessOutput(This,pNode,lOutputIndex,pSample) ) + +#define IMFQualityManager_NotifyQualityEvent(This,pObject,pEvent) \ + ( (This)->lpVtbl -> NotifyQualityEvent(This,pObject,pEvent) ) + +#define IMFQualityManager_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFQualityManager_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0046 */ +/* [local] */ + +STDAPI MFCreateStandardQualityManager( + _Outptr_ IMFQualityManager **ppQualityManager ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_GUID( MF_QUALITY_NOTIFY_PROCESSING_LATENCY, 0xf6b44af8, 0x604d, 0x46fe, 0xa9, 0x5d, 0x45, 0x47, 0x9b, 0x10, 0xc9, 0xbc ); +EXTERN_GUID( MF_QUALITY_NOTIFY_SAMPLE_LAG, 0x30d15206, 0xed2a, 0x4760, 0xbe, 0x17, 0xeb, 0x4a, 0x9f, 0x12, 0x29, 0x5c ); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0046_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0046_v0_0_s_ifspec; + +#ifndef __IMFQualityAdvise_INTERFACE_DEFINED__ +#define __IMFQualityAdvise_INTERFACE_DEFINED__ + +/* interface IMFQualityAdvise */ +/* [uuid][object] */ + + + + + + +EXTERN_C const IID IID_IMFQualityAdvise; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("EC15E2E9-E36B-4f7c-8758-77D452EF4CE7") + IMFQualityAdvise : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetDropMode( + /* [in] */ MF_QUALITY_DROP_MODE eDropMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetQualityLevel( + /* [in] */ MF_QUALITY_LEVEL eQualityLevel) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDropMode( + /* [annotation][out] */ + _Out_ MF_QUALITY_DROP_MODE *peDropMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetQualityLevel( + /* [annotation][out] */ + _Out_ MF_QUALITY_LEVEL *peQualityLevel) = 0; + + virtual HRESULT STDMETHODCALLTYPE DropTime( + /* [in] */ LONGLONG hnsAmountToDrop) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFQualityAdviseVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFQualityAdvise * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFQualityAdvise * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFQualityAdvise * This); + + HRESULT ( STDMETHODCALLTYPE *SetDropMode )( + __RPC__in IMFQualityAdvise * This, + /* [in] */ MF_QUALITY_DROP_MODE eDropMode); + + HRESULT ( STDMETHODCALLTYPE *SetQualityLevel )( + __RPC__in IMFQualityAdvise * This, + /* [in] */ MF_QUALITY_LEVEL eQualityLevel); + + HRESULT ( STDMETHODCALLTYPE *GetDropMode )( + __RPC__in IMFQualityAdvise * This, + /* [annotation][out] */ + _Out_ MF_QUALITY_DROP_MODE *peDropMode); + + HRESULT ( STDMETHODCALLTYPE *GetQualityLevel )( + __RPC__in IMFQualityAdvise * This, + /* [annotation][out] */ + _Out_ MF_QUALITY_LEVEL *peQualityLevel); + + HRESULT ( STDMETHODCALLTYPE *DropTime )( + __RPC__in IMFQualityAdvise * This, + /* [in] */ LONGLONG hnsAmountToDrop); + + END_INTERFACE + } IMFQualityAdviseVtbl; + + interface IMFQualityAdvise + { + CONST_VTBL struct IMFQualityAdviseVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFQualityAdvise_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFQualityAdvise_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFQualityAdvise_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFQualityAdvise_SetDropMode(This,eDropMode) \ + ( (This)->lpVtbl -> SetDropMode(This,eDropMode) ) + +#define IMFQualityAdvise_SetQualityLevel(This,eQualityLevel) \ + ( (This)->lpVtbl -> SetQualityLevel(This,eQualityLevel) ) + +#define IMFQualityAdvise_GetDropMode(This,peDropMode) \ + ( (This)->lpVtbl -> GetDropMode(This,peDropMode) ) + +#define IMFQualityAdvise_GetQualityLevel(This,peQualityLevel) \ + ( (This)->lpVtbl -> GetQualityLevel(This,peQualityLevel) ) + +#define IMFQualityAdvise_DropTime(This,hnsAmountToDrop) \ + ( (This)->lpVtbl -> DropTime(This,hnsAmountToDrop) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFQualityAdvise_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0047 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0047_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0047_v0_0_s_ifspec; + +#ifndef __IMFQualityAdvise2_INTERFACE_DEFINED__ +#define __IMFQualityAdvise2_INTERFACE_DEFINED__ + +/* interface IMFQualityAdvise2 */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFQualityAdvise2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F3706F0D-8EA2-4886-8000-7155E9EC2EAE") + IMFQualityAdvise2 : public IMFQualityAdvise + { + public: + virtual HRESULT STDMETHODCALLTYPE NotifyQualityEvent( + /* [in] */ __RPC__in_opt IMFMediaEvent *pEvent, + /* [out] */ __RPC__out DWORD *pdwFlags) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFQualityAdvise2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFQualityAdvise2 * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFQualityAdvise2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFQualityAdvise2 * This); + + HRESULT ( STDMETHODCALLTYPE *SetDropMode )( + __RPC__in IMFQualityAdvise2 * This, + /* [in] */ MF_QUALITY_DROP_MODE eDropMode); + + HRESULT ( STDMETHODCALLTYPE *SetQualityLevel )( + __RPC__in IMFQualityAdvise2 * This, + /* [in] */ MF_QUALITY_LEVEL eQualityLevel); + + HRESULT ( STDMETHODCALLTYPE *GetDropMode )( + __RPC__in IMFQualityAdvise2 * This, + /* [annotation][out] */ + _Out_ MF_QUALITY_DROP_MODE *peDropMode); + + HRESULT ( STDMETHODCALLTYPE *GetQualityLevel )( + __RPC__in IMFQualityAdvise2 * This, + /* [annotation][out] */ + _Out_ MF_QUALITY_LEVEL *peQualityLevel); + + HRESULT ( STDMETHODCALLTYPE *DropTime )( + __RPC__in IMFQualityAdvise2 * This, + /* [in] */ LONGLONG hnsAmountToDrop); + + HRESULT ( STDMETHODCALLTYPE *NotifyQualityEvent )( + __RPC__in IMFQualityAdvise2 * This, + /* [in] */ __RPC__in_opt IMFMediaEvent *pEvent, + /* [out] */ __RPC__out DWORD *pdwFlags); + + END_INTERFACE + } IMFQualityAdvise2Vtbl; + + interface IMFQualityAdvise2 + { + CONST_VTBL struct IMFQualityAdvise2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFQualityAdvise2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFQualityAdvise2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFQualityAdvise2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFQualityAdvise2_SetDropMode(This,eDropMode) \ + ( (This)->lpVtbl -> SetDropMode(This,eDropMode) ) + +#define IMFQualityAdvise2_SetQualityLevel(This,eQualityLevel) \ + ( (This)->lpVtbl -> SetQualityLevel(This,eQualityLevel) ) + +#define IMFQualityAdvise2_GetDropMode(This,peDropMode) \ + ( (This)->lpVtbl -> GetDropMode(This,peDropMode) ) + +#define IMFQualityAdvise2_GetQualityLevel(This,peQualityLevel) \ + ( (This)->lpVtbl -> GetQualityLevel(This,peQualityLevel) ) + +#define IMFQualityAdvise2_DropTime(This,hnsAmountToDrop) \ + ( (This)->lpVtbl -> DropTime(This,hnsAmountToDrop) ) + + +#define IMFQualityAdvise2_NotifyQualityEvent(This,pEvent,pdwFlags) \ + ( (This)->lpVtbl -> NotifyQualityEvent(This,pEvent,pdwFlags) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFQualityAdvise2_INTERFACE_DEFINED__ */ + + +#ifndef __IMFQualityAdviseLimits_INTERFACE_DEFINED__ +#define __IMFQualityAdviseLimits_INTERFACE_DEFINED__ + +/* interface IMFQualityAdviseLimits */ +/* [uuid][object] */ + + + + + + +EXTERN_C const IID IID_IMFQualityAdviseLimits; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("dfcd8e4d-30b5-4567-acaa-8eb5b7853dc9") + IMFQualityAdviseLimits : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetMaximumDropMode( + /* [annotation][out] */ + _Out_ MF_QUALITY_DROP_MODE *peDropMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMinimumQualityLevel( + /* [annotation][out] */ + _Out_ MF_QUALITY_LEVEL *peQualityLevel) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFQualityAdviseLimitsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFQualityAdviseLimits * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFQualityAdviseLimits * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFQualityAdviseLimits * This); + + HRESULT ( STDMETHODCALLTYPE *GetMaximumDropMode )( + __RPC__in IMFQualityAdviseLimits * This, + /* [annotation][out] */ + _Out_ MF_QUALITY_DROP_MODE *peDropMode); + + HRESULT ( STDMETHODCALLTYPE *GetMinimumQualityLevel )( + __RPC__in IMFQualityAdviseLimits * This, + /* [annotation][out] */ + _Out_ MF_QUALITY_LEVEL *peQualityLevel); + + END_INTERFACE + } IMFQualityAdviseLimitsVtbl; + + interface IMFQualityAdviseLimits + { + CONST_VTBL struct IMFQualityAdviseLimitsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFQualityAdviseLimits_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFQualityAdviseLimits_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFQualityAdviseLimits_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFQualityAdviseLimits_GetMaximumDropMode(This,peDropMode) \ + ( (This)->lpVtbl -> GetMaximumDropMode(This,peDropMode) ) + +#define IMFQualityAdviseLimits_GetMinimumQualityLevel(This,peQualityLevel) \ + ( (This)->lpVtbl -> GetMinimumQualityLevel(This,peQualityLevel) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFQualityAdviseLimits_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0049 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0049_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0049_v0_0_s_ifspec; + +#ifndef __IMFRealTimeClient_INTERFACE_DEFINED__ +#define __IMFRealTimeClient_INTERFACE_DEFINED__ + +/* interface IMFRealTimeClient */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFRealTimeClient; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2347D60B-3FB5-480c-8803-8DF3ADCD3EF0") + IMFRealTimeClient : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE RegisterThreads( + /* [in] */ DWORD dwTaskIndex, + /* [in] */ LPCWSTR wszClass) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnregisterThreads( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetWorkQueue( + /* [in] */ DWORD dwWorkQueueId) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFRealTimeClientVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFRealTimeClient * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFRealTimeClient * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFRealTimeClient * This); + + HRESULT ( STDMETHODCALLTYPE *RegisterThreads )( + IMFRealTimeClient * This, + /* [in] */ DWORD dwTaskIndex, + /* [in] */ LPCWSTR wszClass); + + HRESULT ( STDMETHODCALLTYPE *UnregisterThreads )( + IMFRealTimeClient * This); + + HRESULT ( STDMETHODCALLTYPE *SetWorkQueue )( + IMFRealTimeClient * This, + /* [in] */ DWORD dwWorkQueueId); + + END_INTERFACE + } IMFRealTimeClientVtbl; + + interface IMFRealTimeClient + { + CONST_VTBL struct IMFRealTimeClientVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFRealTimeClient_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFRealTimeClient_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFRealTimeClient_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFRealTimeClient_RegisterThreads(This,dwTaskIndex,wszClass) \ + ( (This)->lpVtbl -> RegisterThreads(This,dwTaskIndex,wszClass) ) + +#define IMFRealTimeClient_UnregisterThreads(This) \ + ( (This)->lpVtbl -> UnregisterThreads(This) ) + +#define IMFRealTimeClient_SetWorkQueue(This,dwWorkQueueId) \ + ( (This)->lpVtbl -> SetWorkQueue(This,dwWorkQueueId) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFRealTimeClient_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0050 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WIN8) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0050_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0050_v0_0_s_ifspec; + +#ifndef __IMFRealTimeClientEx_INTERFACE_DEFINED__ +#define __IMFRealTimeClientEx_INTERFACE_DEFINED__ + +/* interface IMFRealTimeClientEx */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFRealTimeClientEx; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("03910848-AB16-4611-B100-17B88AE2F248") + IMFRealTimeClientEx : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE RegisterThreadsEx( + /* [out][in] */ __RPC__inout DWORD *pdwTaskIndex, + /* [in] */ __RPC__in LPCWSTR wszClassName, + /* [in] */ LONG lBasePriority) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnregisterThreads( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetWorkQueueEx( + /* [in] */ DWORD dwMultithreadedWorkQueueId, + /* [in] */ LONG lWorkItemBasePriority) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFRealTimeClientExVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFRealTimeClientEx * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFRealTimeClientEx * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFRealTimeClientEx * This); + + HRESULT ( STDMETHODCALLTYPE *RegisterThreadsEx )( + __RPC__in IMFRealTimeClientEx * This, + /* [out][in] */ __RPC__inout DWORD *pdwTaskIndex, + /* [in] */ __RPC__in LPCWSTR wszClassName, + /* [in] */ LONG lBasePriority); + + HRESULT ( STDMETHODCALLTYPE *UnregisterThreads )( + __RPC__in IMFRealTimeClientEx * This); + + HRESULT ( STDMETHODCALLTYPE *SetWorkQueueEx )( + __RPC__in IMFRealTimeClientEx * This, + /* [in] */ DWORD dwMultithreadedWorkQueueId, + /* [in] */ LONG lWorkItemBasePriority); + + END_INTERFACE + } IMFRealTimeClientExVtbl; + + interface IMFRealTimeClientEx + { + CONST_VTBL struct IMFRealTimeClientExVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFRealTimeClientEx_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFRealTimeClientEx_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFRealTimeClientEx_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFRealTimeClientEx_RegisterThreadsEx(This,pdwTaskIndex,wszClassName,lBasePriority) \ + ( (This)->lpVtbl -> RegisterThreadsEx(This,pdwTaskIndex,wszClassName,lBasePriority) ) + +#define IMFRealTimeClientEx_UnregisterThreads(This) \ + ( (This)->lpVtbl -> UnregisterThreads(This) ) + +#define IMFRealTimeClientEx_SetWorkQueueEx(This,dwMultithreadedWorkQueueId,lWorkItemBasePriority) \ + ( (This)->lpVtbl -> SetWorkQueueEx(This,dwMultithreadedWorkQueueId,lWorkItemBasePriority) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFRealTimeClientEx_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0051 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +typedef DWORD MFSequencerElementId; + +#define MFSEQUENCER_INVALID_ELEMENT_ID ( 0xffffffff ) + +typedef +enum _MFSequencerTopologyFlags + { + SequencerTopologyFlags_Last = 0x1 + } MFSequencerTopologyFlags; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0051_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0051_v0_0_s_ifspec; + +#ifndef __IMFSequencerSource_INTERFACE_DEFINED__ +#define __IMFSequencerSource_INTERFACE_DEFINED__ + +/* interface IMFSequencerSource */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSequencerSource; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("197CD219-19CB-4de1-A64C-ACF2EDCBE59E") + IMFSequencerSource : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE AppendTopology( + /* [in] */ IMFTopology *pTopology, + /* [in] */ DWORD dwFlags, + /* [annotation][out] */ + _Out_ MFSequencerElementId *pdwId) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeleteTopology( + /* [in] */ MFSequencerElementId dwId) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPresentationContext( + /* [in] */ IMFPresentationDescriptor *pPD, + /* [annotation][optional][out] */ + _Out_opt_ MFSequencerElementId *pId, + /* [annotation][optional][out] */ + _Out_opt_ IMFTopology **ppTopology) = 0; + + virtual HRESULT STDMETHODCALLTYPE UpdateTopology( + /* [in] */ MFSequencerElementId dwId, + /* [in] */ IMFTopology *pTopology) = 0; + + virtual HRESULT STDMETHODCALLTYPE UpdateTopologyFlags( + /* [in] */ MFSequencerElementId dwId, + /* [in] */ DWORD dwFlags) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSequencerSourceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSequencerSource * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSequencerSource * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSequencerSource * This); + + HRESULT ( STDMETHODCALLTYPE *AppendTopology )( + IMFSequencerSource * This, + /* [in] */ IMFTopology *pTopology, + /* [in] */ DWORD dwFlags, + /* [annotation][out] */ + _Out_ MFSequencerElementId *pdwId); + + HRESULT ( STDMETHODCALLTYPE *DeleteTopology )( + IMFSequencerSource * This, + /* [in] */ MFSequencerElementId dwId); + + HRESULT ( STDMETHODCALLTYPE *GetPresentationContext )( + IMFSequencerSource * This, + /* [in] */ IMFPresentationDescriptor *pPD, + /* [annotation][optional][out] */ + _Out_opt_ MFSequencerElementId *pId, + /* [annotation][optional][out] */ + _Out_opt_ IMFTopology **ppTopology); + + HRESULT ( STDMETHODCALLTYPE *UpdateTopology )( + IMFSequencerSource * This, + /* [in] */ MFSequencerElementId dwId, + /* [in] */ IMFTopology *pTopology); + + HRESULT ( STDMETHODCALLTYPE *UpdateTopologyFlags )( + IMFSequencerSource * This, + /* [in] */ MFSequencerElementId dwId, + /* [in] */ DWORD dwFlags); + + END_INTERFACE + } IMFSequencerSourceVtbl; + + interface IMFSequencerSource + { + CONST_VTBL struct IMFSequencerSourceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSequencerSource_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSequencerSource_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSequencerSource_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSequencerSource_AppendTopology(This,pTopology,dwFlags,pdwId) \ + ( (This)->lpVtbl -> AppendTopology(This,pTopology,dwFlags,pdwId) ) + +#define IMFSequencerSource_DeleteTopology(This,dwId) \ + ( (This)->lpVtbl -> DeleteTopology(This,dwId) ) + +#define IMFSequencerSource_GetPresentationContext(This,pPD,pId,ppTopology) \ + ( (This)->lpVtbl -> GetPresentationContext(This,pPD,pId,ppTopology) ) + +#define IMFSequencerSource_UpdateTopology(This,dwId,pTopology) \ + ( (This)->lpVtbl -> UpdateTopology(This,dwId,pTopology) ) + +#define IMFSequencerSource_UpdateTopologyFlags(This,dwId,dwFlags) \ + ( (This)->lpVtbl -> UpdateTopologyFlags(This,dwId,dwFlags) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSequencerSource_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0052 */ +/* [local] */ + +EXTERN_GUID( MF_TIME_FORMAT_SEGMENT_OFFSET, 0xc8b8be77, 0x869c, 0x431d, 0x81, 0x2e, 0x16, 0x96, 0x93, 0xf6, 0x5a, 0x39 ); +STDAPI MFCreateSequencerSource( + IUnknown *pReserved, + _Outptr_ IMFSequencerSource **ppSequencerSource + ); +STDAPI MFCreateSequencerSegmentOffset( + MFSequencerElementId dwId, + MFTIME hnsOffset, + _Out_ PROPVARIANT *pvarSegmentOffset + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +#if (WINVER >= _WIN32_WINNT_WIN7) +STDAPI MFCreateAggregateSource( + _In_ IMFCollection *pSourceCollection, + _Outptr_ IMFMediaSource **ppAggSource + ); +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0052_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0052_v0_0_s_ifspec; + +#ifndef __IMFMediaSourceTopologyProvider_INTERFACE_DEFINED__ +#define __IMFMediaSourceTopologyProvider_INTERFACE_DEFINED__ + +/* interface IMFMediaSourceTopologyProvider */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaSourceTopologyProvider; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0E1D6009-C9F3-442d-8C51-A42D2D49452F") + IMFMediaSourceTopologyProvider : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetMediaSourceTopology( + /* [in] */ __RPC__in_opt IMFPresentationDescriptor *pPresentationDescriptor, + /* [out] */ __RPC__deref_out_opt IMFTopology **ppTopology) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaSourceTopologyProviderVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaSourceTopologyProvider * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaSourceTopologyProvider * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaSourceTopologyProvider * This); + + HRESULT ( STDMETHODCALLTYPE *GetMediaSourceTopology )( + __RPC__in IMFMediaSourceTopologyProvider * This, + /* [in] */ __RPC__in_opt IMFPresentationDescriptor *pPresentationDescriptor, + /* [out] */ __RPC__deref_out_opt IMFTopology **ppTopology); + + END_INTERFACE + } IMFMediaSourceTopologyProviderVtbl; + + interface IMFMediaSourceTopologyProvider + { + CONST_VTBL struct IMFMediaSourceTopologyProviderVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaSourceTopologyProvider_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaSourceTopologyProvider_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaSourceTopologyProvider_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaSourceTopologyProvider_GetMediaSourceTopology(This,pPresentationDescriptor,ppTopology) \ + ( (This)->lpVtbl -> GetMediaSourceTopology(This,pPresentationDescriptor,ppTopology) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaSourceTopologyProvider_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaSourcePresentationProvider_INTERFACE_DEFINED__ +#define __IMFMediaSourcePresentationProvider_INTERFACE_DEFINED__ + +/* interface IMFMediaSourcePresentationProvider */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaSourcePresentationProvider; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("0E1D600a-C9F3-442d-8C51-A42D2D49452F") + IMFMediaSourcePresentationProvider : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ForceEndOfPresentation( + /* [in] */ __RPC__in_opt IMFPresentationDescriptor *pPresentationDescriptor) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaSourcePresentationProviderVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaSourcePresentationProvider * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaSourcePresentationProvider * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaSourcePresentationProvider * This); + + HRESULT ( STDMETHODCALLTYPE *ForceEndOfPresentation )( + __RPC__in IMFMediaSourcePresentationProvider * This, + /* [in] */ __RPC__in_opt IMFPresentationDescriptor *pPresentationDescriptor); + + END_INTERFACE + } IMFMediaSourcePresentationProviderVtbl; + + interface IMFMediaSourcePresentationProvider + { + CONST_VTBL struct IMFMediaSourcePresentationProviderVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaSourcePresentationProvider_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaSourcePresentationProvider_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaSourcePresentationProvider_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaSourcePresentationProvider_ForceEndOfPresentation(This,pPresentationDescriptor) \ + ( (This)->lpVtbl -> ForceEndOfPresentation(This,pPresentationDescriptor) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaSourcePresentationProvider_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0054 */ +/* [local] */ + +EXTERN_GUID( MF_SOURCE_PRESENTATION_PROVIDER_SERVICE, 0xe002aadc, 0xf4af, 0x4ee5, 0x98, 0x47, 0x05, 0x3e, 0xdf, 0x84, 0x04, 0x26 ); +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +#pragma warning(push) +#pragma warning(disable:4820) // Disable C4820: padding after data member +#endif +typedef struct _MFTOPONODE_ATTRIBUTE_UPDATE + { + TOPOID NodeId; + GUID guidAttributeKey; + MF_ATTRIBUTE_TYPE attrType; + /* [switch_type][switch_is] */ union + { + /* [case()] */ UINT32 u32; + /* [case()] */ UINT64 u64; + /* [case()] */ double d; + /* [default] */ /* Empty union arm */ + } ; + } MFTOPONODE_ATTRIBUTE_UPDATE; + +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +#pragma warning(pop) +#endif + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0054_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0054_v0_0_s_ifspec; + +#ifndef __IMFTopologyNodeAttributeEditor_INTERFACE_DEFINED__ +#define __IMFTopologyNodeAttributeEditor_INTERFACE_DEFINED__ + +/* interface IMFTopologyNodeAttributeEditor */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFTopologyNodeAttributeEditor; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("676aa6dd-238a-410d-bb99-65668d01605a") + IMFTopologyNodeAttributeEditor : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE UpdateNodeAttributes( + /* [in] */ TOPOID TopoId, + /* [in] */ DWORD cUpdates, + /* [size_is][in] */ __RPC__in_ecount_full(cUpdates) MFTOPONODE_ATTRIBUTE_UPDATE *pUpdates) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTopologyNodeAttributeEditorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFTopologyNodeAttributeEditor * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFTopologyNodeAttributeEditor * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFTopologyNodeAttributeEditor * This); + + HRESULT ( STDMETHODCALLTYPE *UpdateNodeAttributes )( + __RPC__in IMFTopologyNodeAttributeEditor * This, + /* [in] */ TOPOID TopoId, + /* [in] */ DWORD cUpdates, + /* [size_is][in] */ __RPC__in_ecount_full(cUpdates) MFTOPONODE_ATTRIBUTE_UPDATE *pUpdates); + + END_INTERFACE + } IMFTopologyNodeAttributeEditorVtbl; + + interface IMFTopologyNodeAttributeEditor + { + CONST_VTBL struct IMFTopologyNodeAttributeEditorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTopologyNodeAttributeEditor_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTopologyNodeAttributeEditor_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTopologyNodeAttributeEditor_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTopologyNodeAttributeEditor_UpdateNodeAttributes(This,TopoId,cUpdates,pUpdates) \ + ( (This)->lpVtbl -> UpdateNodeAttributes(This,TopoId,cUpdates,pUpdates) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTopologyNodeAttributeEditor_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0055 */ +/* [local] */ + +EXTERN_GUID( MF_TOPONODE_ATTRIBUTE_EDITOR_SERVICE, 0x65656e1a, 0x077f, 0x4472, 0x83, 0xef, 0x31, 0x6f, 0x11, 0xd5, 0x08, 0x7a ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef /* [public] */ struct _MF_LEAKY_BUCKET_PAIR + { + DWORD dwBitrate; + DWORD msBufferWindow; + } MF_LEAKY_BUCKET_PAIR; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +#pragma warning(push) +#pragma warning(disable:4820) // Disable C4820: padding after data member +#endif +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef /* [public] */ struct _MFBYTESTREAM_BUFFERING_PARAMS + { + QWORD cbTotalFileSize; + QWORD cbPlayableDataSize; + MF_LEAKY_BUCKET_PAIR *prgBuckets; + DWORD cBuckets; + QWORD qwNetBufferingTime; + QWORD qwExtraBufferingTimeDuringSeek; + QWORD qwPlayDuration; + float dRate; + } MFBYTESTREAM_BUFFERING_PARAMS; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +#pragma warning(pop) +#endif +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0055_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0055_v0_0_s_ifspec; + +#ifndef __IMFByteStreamBuffering_INTERFACE_DEFINED__ +#define __IMFByteStreamBuffering_INTERFACE_DEFINED__ + +/* interface IMFByteStreamBuffering */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFByteStreamBuffering; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6d66d782-1d4f-4db7-8c63-cb8c77f1ef5e") + IMFByteStreamBuffering : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetBufferingParams( + /* [in] */ __RPC__in MFBYTESTREAM_BUFFERING_PARAMS *pParams) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableBuffering( + /* [in] */ BOOL fEnable) = 0; + + virtual HRESULT STDMETHODCALLTYPE StopBuffering( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFByteStreamBufferingVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFByteStreamBuffering * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFByteStreamBuffering * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFByteStreamBuffering * This); + + HRESULT ( STDMETHODCALLTYPE *SetBufferingParams )( + __RPC__in IMFByteStreamBuffering * This, + /* [in] */ __RPC__in MFBYTESTREAM_BUFFERING_PARAMS *pParams); + + HRESULT ( STDMETHODCALLTYPE *EnableBuffering )( + __RPC__in IMFByteStreamBuffering * This, + /* [in] */ BOOL fEnable); + + HRESULT ( STDMETHODCALLTYPE *StopBuffering )( + __RPC__in IMFByteStreamBuffering * This); + + END_INTERFACE + } IMFByteStreamBufferingVtbl; + + interface IMFByteStreamBuffering + { + CONST_VTBL struct IMFByteStreamBufferingVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFByteStreamBuffering_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFByteStreamBuffering_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFByteStreamBuffering_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFByteStreamBuffering_SetBufferingParams(This,pParams) \ + ( (This)->lpVtbl -> SetBufferingParams(This,pParams) ) + +#define IMFByteStreamBuffering_EnableBuffering(This,fEnable) \ + ( (This)->lpVtbl -> EnableBuffering(This,fEnable) ) + +#define IMFByteStreamBuffering_StopBuffering(This) \ + ( (This)->lpVtbl -> StopBuffering(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFByteStreamBuffering_INTERFACE_DEFINED__ */ + + +#ifndef __IMFByteStreamCacheControl_INTERFACE_DEFINED__ +#define __IMFByteStreamCacheControl_INTERFACE_DEFINED__ + +/* interface IMFByteStreamCacheControl */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFByteStreamCacheControl; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F5042EA4-7A96-4a75-AA7B-2BE1EF7F88D5") + IMFByteStreamCacheControl : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE StopBackgroundTransfer( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFByteStreamCacheControlVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFByteStreamCacheControl * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFByteStreamCacheControl * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFByteStreamCacheControl * This); + + HRESULT ( STDMETHODCALLTYPE *StopBackgroundTransfer )( + __RPC__in IMFByteStreamCacheControl * This); + + END_INTERFACE + } IMFByteStreamCacheControlVtbl; + + interface IMFByteStreamCacheControl + { + CONST_VTBL struct IMFByteStreamCacheControlVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFByteStreamCacheControl_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFByteStreamCacheControl_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFByteStreamCacheControl_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFByteStreamCacheControl_StopBackgroundTransfer(This) \ + ( (This)->lpVtbl -> StopBackgroundTransfer(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFByteStreamCacheControl_INTERFACE_DEFINED__ */ + + +#ifndef __IMFByteStreamTimeSeek_INTERFACE_DEFINED__ +#define __IMFByteStreamTimeSeek_INTERFACE_DEFINED__ + +/* interface IMFByteStreamTimeSeek */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFByteStreamTimeSeek; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("64976BFA-FB61-4041-9069-8C9A5F659BEB") + IMFByteStreamTimeSeek : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE IsTimeSeekSupported( + /* [out] */ __RPC__out BOOL *pfTimeSeekIsSupported) = 0; + + virtual HRESULT STDMETHODCALLTYPE TimeSeek( + /* [in] */ QWORD qwTimePosition) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimeSeekResult( + /* [out] */ __RPC__out QWORD *pqwStartTime, + /* [out] */ __RPC__out QWORD *pqwStopTime, + /* [out] */ __RPC__out QWORD *pqwDuration) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFByteStreamTimeSeekVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFByteStreamTimeSeek * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFByteStreamTimeSeek * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFByteStreamTimeSeek * This); + + HRESULT ( STDMETHODCALLTYPE *IsTimeSeekSupported )( + __RPC__in IMFByteStreamTimeSeek * This, + /* [out] */ __RPC__out BOOL *pfTimeSeekIsSupported); + + HRESULT ( STDMETHODCALLTYPE *TimeSeek )( + __RPC__in IMFByteStreamTimeSeek * This, + /* [in] */ QWORD qwTimePosition); + + HRESULT ( STDMETHODCALLTYPE *GetTimeSeekResult )( + __RPC__in IMFByteStreamTimeSeek * This, + /* [out] */ __RPC__out QWORD *pqwStartTime, + /* [out] */ __RPC__out QWORD *pqwStopTime, + /* [out] */ __RPC__out QWORD *pqwDuration); + + END_INTERFACE + } IMFByteStreamTimeSeekVtbl; + + interface IMFByteStreamTimeSeek + { + CONST_VTBL struct IMFByteStreamTimeSeekVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFByteStreamTimeSeek_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFByteStreamTimeSeek_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFByteStreamTimeSeek_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFByteStreamTimeSeek_IsTimeSeekSupported(This,pfTimeSeekIsSupported) \ + ( (This)->lpVtbl -> IsTimeSeekSupported(This,pfTimeSeekIsSupported) ) + +#define IMFByteStreamTimeSeek_TimeSeek(This,qwTimePosition) \ + ( (This)->lpVtbl -> TimeSeek(This,qwTimePosition) ) + +#define IMFByteStreamTimeSeek_GetTimeSeekResult(This,pqwStartTime,pqwStopTime,pqwDuration) \ + ( (This)->lpVtbl -> GetTimeSeekResult(This,pqwStartTime,pqwStopTime,pqwDuration) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFByteStreamTimeSeek_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0058 */ +/* [local] */ + +#if (WINVER >= _WIN32_WINNT_WIN8) +typedef /* [public][public] */ struct __MIDL___MIDL_itf_mfidl_0000_0058_0001 + { + QWORD qwStartOffset; + QWORD qwEndOffset; + } MF_BYTE_STREAM_CACHE_RANGE; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0058_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0058_v0_0_s_ifspec; + +#ifndef __IMFByteStreamCacheControl2_INTERFACE_DEFINED__ +#define __IMFByteStreamCacheControl2_INTERFACE_DEFINED__ + +/* interface IMFByteStreamCacheControl2 */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFByteStreamCacheControl2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("71CE469C-F34B-49EA-A56B-2D2A10E51149") + IMFByteStreamCacheControl2 : public IMFByteStreamCacheControl + { + public: + virtual HRESULT STDMETHODCALLTYPE GetByteRanges( + /* [out] */ __RPC__out DWORD *pcRanges, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcRanges) MF_BYTE_STREAM_CACHE_RANGE **ppRanges) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCacheLimit( + /* [in] */ QWORD qwBytes) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsBackgroundTransferActive( + /* [out] */ __RPC__out BOOL *pfActive) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFByteStreamCacheControl2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFByteStreamCacheControl2 * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFByteStreamCacheControl2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFByteStreamCacheControl2 * This); + + HRESULT ( STDMETHODCALLTYPE *StopBackgroundTransfer )( + __RPC__in IMFByteStreamCacheControl2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetByteRanges )( + __RPC__in IMFByteStreamCacheControl2 * This, + /* [out] */ __RPC__out DWORD *pcRanges, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcRanges) MF_BYTE_STREAM_CACHE_RANGE **ppRanges); + + HRESULT ( STDMETHODCALLTYPE *SetCacheLimit )( + __RPC__in IMFByteStreamCacheControl2 * This, + /* [in] */ QWORD qwBytes); + + HRESULT ( STDMETHODCALLTYPE *IsBackgroundTransferActive )( + __RPC__in IMFByteStreamCacheControl2 * This, + /* [out] */ __RPC__out BOOL *pfActive); + + END_INTERFACE + } IMFByteStreamCacheControl2Vtbl; + + interface IMFByteStreamCacheControl2 + { + CONST_VTBL struct IMFByteStreamCacheControl2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFByteStreamCacheControl2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFByteStreamCacheControl2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFByteStreamCacheControl2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFByteStreamCacheControl2_StopBackgroundTransfer(This) \ + ( (This)->lpVtbl -> StopBackgroundTransfer(This) ) + + +#define IMFByteStreamCacheControl2_GetByteRanges(This,pcRanges,ppRanges) \ + ( (This)->lpVtbl -> GetByteRanges(This,pcRanges,ppRanges) ) + +#define IMFByteStreamCacheControl2_SetCacheLimit(This,qwBytes) \ + ( (This)->lpVtbl -> SetCacheLimit(This,qwBytes) ) + +#define IMFByteStreamCacheControl2_IsBackgroundTransferActive(This,pfActive) \ + ( (This)->lpVtbl -> IsBackgroundTransferActive(This,pfActive) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFByteStreamCacheControl2_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0059 */ +/* [local] */ + +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0059_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0059_v0_0_s_ifspec; + +#ifndef __IMFNetCredential_INTERFACE_DEFINED__ +#define __IMFNetCredential_INTERFACE_DEFINED__ + +/* interface IMFNetCredential */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFNetCredential; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5b87ef6a-7ed8-434f-ba0e-184fac1628d1") + IMFNetCredential : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetUser( + /* [annotation][size_is][in] */ + _In_reads_bytes_(cbData) BYTE *pbData, + /* [in] */ DWORD cbData, + /* [in] */ BOOL fDataIsEncrypted) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPassword( + /* [annotation][size_is][in] */ + _In_reads_bytes_(cbData) BYTE *pbData, + /* [in] */ DWORD cbData, + /* [in] */ BOOL fDataIsEncrypted) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetUser( + /* [annotation][size_is][out] */ + _Out_writes_to_opt_(*pcbData,*pcbData) BYTE *pbData, + /* [annotation][out][in] */ + _Inout_ DWORD *pcbData, + /* [in] */ BOOL fEncryptData) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPassword( + /* [annotation][size_is][out] */ + _Out_writes_to_opt_(*pcbData,*pcbData) BYTE *pbData, + /* [annotation][out][in] */ + _Inout_ DWORD *pcbData, + /* [in] */ BOOL fEncryptData) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoggedOnUser( + /* [annotation][out] */ + _Out_ BOOL *pfLoggedOnUser) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFNetCredentialVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFNetCredential * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFNetCredential * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFNetCredential * This); + + HRESULT ( STDMETHODCALLTYPE *SetUser )( + IMFNetCredential * This, + /* [annotation][size_is][in] */ + _In_reads_bytes_(cbData) BYTE *pbData, + /* [in] */ DWORD cbData, + /* [in] */ BOOL fDataIsEncrypted); + + HRESULT ( STDMETHODCALLTYPE *SetPassword )( + IMFNetCredential * This, + /* [annotation][size_is][in] */ + _In_reads_bytes_(cbData) BYTE *pbData, + /* [in] */ DWORD cbData, + /* [in] */ BOOL fDataIsEncrypted); + + HRESULT ( STDMETHODCALLTYPE *GetUser )( + IMFNetCredential * This, + /* [annotation][size_is][out] */ + _Out_writes_to_opt_(*pcbData,*pcbData) BYTE *pbData, + /* [annotation][out][in] */ + _Inout_ DWORD *pcbData, + /* [in] */ BOOL fEncryptData); + + HRESULT ( STDMETHODCALLTYPE *GetPassword )( + IMFNetCredential * This, + /* [annotation][size_is][out] */ + _Out_writes_to_opt_(*pcbData,*pcbData) BYTE *pbData, + /* [annotation][out][in] */ + _Inout_ DWORD *pcbData, + /* [in] */ BOOL fEncryptData); + + HRESULT ( STDMETHODCALLTYPE *LoggedOnUser )( + IMFNetCredential * This, + /* [annotation][out] */ + _Out_ BOOL *pfLoggedOnUser); + + END_INTERFACE + } IMFNetCredentialVtbl; + + interface IMFNetCredential + { + CONST_VTBL struct IMFNetCredentialVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFNetCredential_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFNetCredential_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFNetCredential_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFNetCredential_SetUser(This,pbData,cbData,fDataIsEncrypted) \ + ( (This)->lpVtbl -> SetUser(This,pbData,cbData,fDataIsEncrypted) ) + +#define IMFNetCredential_SetPassword(This,pbData,cbData,fDataIsEncrypted) \ + ( (This)->lpVtbl -> SetPassword(This,pbData,cbData,fDataIsEncrypted) ) + +#define IMFNetCredential_GetUser(This,pbData,pcbData,fEncryptData) \ + ( (This)->lpVtbl -> GetUser(This,pbData,pcbData,fEncryptData) ) + +#define IMFNetCredential_GetPassword(This,pbData,pcbData,fEncryptData) \ + ( (This)->lpVtbl -> GetPassword(This,pbData,pcbData,fEncryptData) ) + +#define IMFNetCredential_LoggedOnUser(This,pfLoggedOnUser) \ + ( (This)->lpVtbl -> LoggedOnUser(This,pfLoggedOnUser) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFNetCredential_INTERFACE_DEFINED__ */ + + +#ifndef __IMFNetCredentialManager_INTERFACE_DEFINED__ +#define __IMFNetCredentialManager_INTERFACE_DEFINED__ + +/* interface IMFNetCredentialManager */ +/* [local][uuid][object] */ + +typedef struct _MFNetCredentialManagerGetParam + { + HRESULT hrOp; + BOOL fAllowLoggedOnUser; + BOOL fClearTextPackage; + LPCWSTR pszUrl; + LPCWSTR pszSite; + LPCWSTR pszRealm; + LPCWSTR pszPackage; + LONG nRetries; + } MFNetCredentialManagerGetParam; + + +EXTERN_C const IID IID_IMFNetCredentialManager; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5b87ef6b-7ed8-434f-ba0e-184fac1628d1") + IMFNetCredentialManager : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE BeginGetCredentials( + /* [in] */ MFNetCredentialManagerGetParam *pParam, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndGetCredentials( + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Outptr_ IMFNetCredential **ppCred) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetGood( + /* [in] */ IMFNetCredential *pCred, + /* [in] */ BOOL fGood) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFNetCredentialManagerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFNetCredentialManager * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFNetCredentialManager * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFNetCredentialManager * This); + + HRESULT ( STDMETHODCALLTYPE *BeginGetCredentials )( + IMFNetCredentialManager * This, + /* [in] */ MFNetCredentialManagerGetParam *pParam, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + HRESULT ( STDMETHODCALLTYPE *EndGetCredentials )( + IMFNetCredentialManager * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Outptr_ IMFNetCredential **ppCred); + + HRESULT ( STDMETHODCALLTYPE *SetGood )( + IMFNetCredentialManager * This, + /* [in] */ IMFNetCredential *pCred, + /* [in] */ BOOL fGood); + + END_INTERFACE + } IMFNetCredentialManagerVtbl; + + interface IMFNetCredentialManager + { + CONST_VTBL struct IMFNetCredentialManagerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFNetCredentialManager_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFNetCredentialManager_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFNetCredentialManager_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFNetCredentialManager_BeginGetCredentials(This,pParam,pCallback,pState) \ + ( (This)->lpVtbl -> BeginGetCredentials(This,pParam,pCallback,pState) ) + +#define IMFNetCredentialManager_EndGetCredentials(This,pResult,ppCred) \ + ( (This)->lpVtbl -> EndGetCredentials(This,pResult,ppCred) ) + +#define IMFNetCredentialManager_SetGood(This,pCred,fGood) \ + ( (This)->lpVtbl -> SetGood(This,pCred,fGood) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFNetCredentialManager_INTERFACE_DEFINED__ */ + + +#ifndef __IMFNetCredentialCache_INTERFACE_DEFINED__ +#define __IMFNetCredentialCache_INTERFACE_DEFINED__ + +/* interface IMFNetCredentialCache */ +/* [local][uuid][object] */ + +typedef +enum _MFNetCredentialRequirements + { + REQUIRE_PROMPT = 0x1, + REQUIRE_SAVE_SELECTED = 0x2 + } MFNetCredentialRequirements; + +typedef +enum _MFNetCredentialOptions + { + MFNET_CREDENTIAL_SAVE = 0x1, + MFNET_CREDENTIAL_DONT_CACHE = 0x2, + MFNET_CREDENTIAL_ALLOW_CLEAR_TEXT = 0x4 + } MFNetCredentialOptions; + +typedef +enum _MFNetAuthenticationFlags + { + MFNET_AUTHENTICATION_PROXY = 0x1, + MFNET_AUTHENTICATION_CLEAR_TEXT = 0x2, + MFNET_AUTHENTICATION_LOGGED_ON_USER = 0x4 + } MFNetAuthenticationFlags; + + +EXTERN_C const IID IID_IMFNetCredentialCache; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5b87ef6c-7ed8-434f-ba0e-184fac1628d1") + IMFNetCredentialCache : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetCredential( + /* [in] */ LPCWSTR pszUrl, + /* [in] */ LPCWSTR pszRealm, + /* [in] */ DWORD dwAuthenticationFlags, + /* [annotation][out] */ + _Outptr_ IMFNetCredential **ppCred, + /* [annotation][out] */ + _Out_ DWORD *pdwRequirementsFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetGood( + /* [in] */ IMFNetCredential *pCred, + /* [in] */ BOOL fGood) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetUserOptions( + /* [in] */ IMFNetCredential *pCred, + /* [in] */ DWORD dwOptionsFlags) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFNetCredentialCacheVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFNetCredentialCache * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFNetCredentialCache * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFNetCredentialCache * This); + + HRESULT ( STDMETHODCALLTYPE *GetCredential )( + IMFNetCredentialCache * This, + /* [in] */ LPCWSTR pszUrl, + /* [in] */ LPCWSTR pszRealm, + /* [in] */ DWORD dwAuthenticationFlags, + /* [annotation][out] */ + _Outptr_ IMFNetCredential **ppCred, + /* [annotation][out] */ + _Out_ DWORD *pdwRequirementsFlags); + + HRESULT ( STDMETHODCALLTYPE *SetGood )( + IMFNetCredentialCache * This, + /* [in] */ IMFNetCredential *pCred, + /* [in] */ BOOL fGood); + + HRESULT ( STDMETHODCALLTYPE *SetUserOptions )( + IMFNetCredentialCache * This, + /* [in] */ IMFNetCredential *pCred, + /* [in] */ DWORD dwOptionsFlags); + + END_INTERFACE + } IMFNetCredentialCacheVtbl; + + interface IMFNetCredentialCache + { + CONST_VTBL struct IMFNetCredentialCacheVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFNetCredentialCache_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFNetCredentialCache_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFNetCredentialCache_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFNetCredentialCache_GetCredential(This,pszUrl,pszRealm,dwAuthenticationFlags,ppCred,pdwRequirementsFlags) \ + ( (This)->lpVtbl -> GetCredential(This,pszUrl,pszRealm,dwAuthenticationFlags,ppCred,pdwRequirementsFlags) ) + +#define IMFNetCredentialCache_SetGood(This,pCred,fGood) \ + ( (This)->lpVtbl -> SetGood(This,pCred,fGood) ) + +#define IMFNetCredentialCache_SetUserOptions(This,pCred,dwOptionsFlags) \ + ( (This)->lpVtbl -> SetUserOptions(This,pCred,dwOptionsFlags) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFNetCredentialCache_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0062 */ +/* [local] */ + +STDAPI +MFCreateCredentialCache( + _Outptr_ IMFNetCredentialCache ** ppCache); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0062_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0062_v0_0_s_ifspec; + +#ifndef __IMFSSLCertificateManager_INTERFACE_DEFINED__ +#define __IMFSSLCertificateManager_INTERFACE_DEFINED__ + +/* interface IMFSSLCertificateManager */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSSLCertificateManager; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("61f7d887-1230-4a8b-aeba-8ad434d1a64d") + IMFSSLCertificateManager : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetClientCertificate( + /* [in] */ LPCWSTR pszURL, + /* [annotation][size_is][size_is][out] */ + _Outptr_result_bytebuffer_(*pcbData) BYTE **ppbData, + /* [annotation][out] */ + _Out_ DWORD *pcbData) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginGetClientCertificate( + /* [in] */ LPCWSTR pszURL, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndGetClientCertificate( + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][size_is][size_is][out] */ + _Outptr_result_bytebuffer_(*pcbData) BYTE **ppbData, + /* [annotation][out] */ + _Out_ DWORD *pcbData) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCertificatePolicy( + /* [in] */ LPCWSTR pszURL, + /* [out] */ BOOL *pfOverrideAutomaticCheck, + /* [out] */ BOOL *pfClientCertificateAvailable) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnServerCertificate( + /* [in] */ LPCWSTR pszURL, + /* [annotation][size_is][in] */ + _In_reads_bytes_(cbData) BYTE *pbData, + /* [in] */ DWORD cbData, + /* [out] */ BOOL *pfIsGood) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSSLCertificateManagerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSSLCertificateManager * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSSLCertificateManager * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSSLCertificateManager * This); + + HRESULT ( STDMETHODCALLTYPE *GetClientCertificate )( + IMFSSLCertificateManager * This, + /* [in] */ LPCWSTR pszURL, + /* [annotation][size_is][size_is][out] */ + _Outptr_result_bytebuffer_(*pcbData) BYTE **ppbData, + /* [annotation][out] */ + _Out_ DWORD *pcbData); + + HRESULT ( STDMETHODCALLTYPE *BeginGetClientCertificate )( + IMFSSLCertificateManager * This, + /* [in] */ LPCWSTR pszURL, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + HRESULT ( STDMETHODCALLTYPE *EndGetClientCertificate )( + IMFSSLCertificateManager * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][size_is][size_is][out] */ + _Outptr_result_bytebuffer_(*pcbData) BYTE **ppbData, + /* [annotation][out] */ + _Out_ DWORD *pcbData); + + HRESULT ( STDMETHODCALLTYPE *GetCertificatePolicy )( + IMFSSLCertificateManager * This, + /* [in] */ LPCWSTR pszURL, + /* [out] */ BOOL *pfOverrideAutomaticCheck, + /* [out] */ BOOL *pfClientCertificateAvailable); + + HRESULT ( STDMETHODCALLTYPE *OnServerCertificate )( + IMFSSLCertificateManager * This, + /* [in] */ LPCWSTR pszURL, + /* [annotation][size_is][in] */ + _In_reads_bytes_(cbData) BYTE *pbData, + /* [in] */ DWORD cbData, + /* [out] */ BOOL *pfIsGood); + + END_INTERFACE + } IMFSSLCertificateManagerVtbl; + + interface IMFSSLCertificateManager + { + CONST_VTBL struct IMFSSLCertificateManagerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSSLCertificateManager_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSSLCertificateManager_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSSLCertificateManager_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSSLCertificateManager_GetClientCertificate(This,pszURL,ppbData,pcbData) \ + ( (This)->lpVtbl -> GetClientCertificate(This,pszURL,ppbData,pcbData) ) + +#define IMFSSLCertificateManager_BeginGetClientCertificate(This,pszURL,pCallback,pState) \ + ( (This)->lpVtbl -> BeginGetClientCertificate(This,pszURL,pCallback,pState) ) + +#define IMFSSLCertificateManager_EndGetClientCertificate(This,pResult,ppbData,pcbData) \ + ( (This)->lpVtbl -> EndGetClientCertificate(This,pResult,ppbData,pcbData) ) + +#define IMFSSLCertificateManager_GetCertificatePolicy(This,pszURL,pfOverrideAutomaticCheck,pfClientCertificateAvailable) \ + ( (This)->lpVtbl -> GetCertificatePolicy(This,pszURL,pfOverrideAutomaticCheck,pfClientCertificateAvailable) ) + +#define IMFSSLCertificateManager_OnServerCertificate(This,pszURL,pbData,cbData,pfIsGood) \ + ( (This)->lpVtbl -> OnServerCertificate(This,pszURL,pbData,cbData,pfIsGood) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSSLCertificateManager_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0063 */ +/* [local] */ + +EXTERN_GUID( MFNETSOURCE_SSLCERTIFICATE_MANAGER, 0x55e6cb27, 0xe69b, 0x4267, 0x94, 0x0c, 0x2d, 0x7e, 0xc5, 0xbb, 0x8a, 0x0f ); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0063_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0063_v0_0_s_ifspec; + +#ifndef __IMFNetResourceFilter_INTERFACE_DEFINED__ +#define __IMFNetResourceFilter_INTERFACE_DEFINED__ + +/* interface IMFNetResourceFilter */ +/* [local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFNetResourceFilter; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("091878a3-bf11-4a5c-bc9f-33995b06ef2d") + IMFNetResourceFilter : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE OnRedirect( + /* [annotation][in] */ + _In_ LPCWSTR pszUrl, + /* [annotation][out] */ + _Out_ VARIANT_BOOL *pvbCancel) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnSendingRequest( + /* [annotation][in] */ + _In_ LPCWSTR pszUrl) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFNetResourceFilterVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFNetResourceFilter * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFNetResourceFilter * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFNetResourceFilter * This); + + HRESULT ( STDMETHODCALLTYPE *OnRedirect )( + IMFNetResourceFilter * This, + /* [annotation][in] */ + _In_ LPCWSTR pszUrl, + /* [annotation][out] */ + _Out_ VARIANT_BOOL *pvbCancel); + + HRESULT ( STDMETHODCALLTYPE *OnSendingRequest )( + IMFNetResourceFilter * This, + /* [annotation][in] */ + _In_ LPCWSTR pszUrl); + + END_INTERFACE + } IMFNetResourceFilterVtbl; + + interface IMFNetResourceFilter + { + CONST_VTBL struct IMFNetResourceFilterVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFNetResourceFilter_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFNetResourceFilter_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFNetResourceFilter_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFNetResourceFilter_OnRedirect(This,pszUrl,pvbCancel) \ + ( (This)->lpVtbl -> OnRedirect(This,pszUrl,pvbCancel) ) + +#define IMFNetResourceFilter_OnSendingRequest(This,pszUrl) \ + ( (This)->lpVtbl -> OnSendingRequest(This,pszUrl) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFNetResourceFilter_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0064 */ +/* [local] */ + +EXTERN_GUID( MFNETSOURCE_RESOURCE_FILTER, 0x815d0ff6, 0x265a, 0x4477, 0x9e, 0x46, 0x7b, 0x80, 0xad, 0x80, 0xb5, 0xfb); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0064_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0064_v0_0_s_ifspec; + +#ifndef __IMFSourceOpenMonitor_INTERFACE_DEFINED__ +#define __IMFSourceOpenMonitor_INTERFACE_DEFINED__ + +/* interface IMFSourceOpenMonitor */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFSourceOpenMonitor; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("059054B3-027C-494C-A27D-9113291CF87F") + IMFSourceOpenMonitor : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE OnSourceEvent( + /* [in] */ __RPC__in_opt IMFMediaEvent *pEvent) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSourceOpenMonitorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFSourceOpenMonitor * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFSourceOpenMonitor * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFSourceOpenMonitor * This); + + HRESULT ( STDMETHODCALLTYPE *OnSourceEvent )( + __RPC__in IMFSourceOpenMonitor * This, + /* [in] */ __RPC__in_opt IMFMediaEvent *pEvent); + + END_INTERFACE + } IMFSourceOpenMonitorVtbl; + + interface IMFSourceOpenMonitor + { + CONST_VTBL struct IMFSourceOpenMonitorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSourceOpenMonitor_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSourceOpenMonitor_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSourceOpenMonitor_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSourceOpenMonitor_OnSourceEvent(This,pEvent) \ + ( (This)->lpVtbl -> OnSourceEvent(This,pEvent) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSourceOpenMonitor_INTERFACE_DEFINED__ */ + + +#ifndef __IMFNetProxyLocator_INTERFACE_DEFINED__ +#define __IMFNetProxyLocator_INTERFACE_DEFINED__ + +/* interface IMFNetProxyLocator */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFNetProxyLocator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e9cd0383-a268-4bb4-82de-658d53574d41") + IMFNetProxyLocator : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE FindFirstProxy( + /* [in] */ LPCWSTR pszHost, + /* [in] */ LPCWSTR pszUrl, + /* [in] */ BOOL fReserved) = 0; + + virtual HRESULT STDMETHODCALLTYPE FindNextProxy( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE RegisterProxyResult( + /* [in] */ HRESULT hrOp) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentProxy( + /* [annotation][size_is][out] */ + _Out_writes_opt_(*pcchStr) LPWSTR pszStr, + /* [out][in] */ DWORD *pcchStr) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clone( + /* [out] */ IMFNetProxyLocator **ppProxyLocator) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFNetProxyLocatorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFNetProxyLocator * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFNetProxyLocator * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFNetProxyLocator * This); + + HRESULT ( STDMETHODCALLTYPE *FindFirstProxy )( + IMFNetProxyLocator * This, + /* [in] */ LPCWSTR pszHost, + /* [in] */ LPCWSTR pszUrl, + /* [in] */ BOOL fReserved); + + HRESULT ( STDMETHODCALLTYPE *FindNextProxy )( + IMFNetProxyLocator * This); + + HRESULT ( STDMETHODCALLTYPE *RegisterProxyResult )( + IMFNetProxyLocator * This, + /* [in] */ HRESULT hrOp); + + HRESULT ( STDMETHODCALLTYPE *GetCurrentProxy )( + IMFNetProxyLocator * This, + /* [annotation][size_is][out] */ + _Out_writes_opt_(*pcchStr) LPWSTR pszStr, + /* [out][in] */ DWORD *pcchStr); + + HRESULT ( STDMETHODCALLTYPE *Clone )( + IMFNetProxyLocator * This, + /* [out] */ IMFNetProxyLocator **ppProxyLocator); + + END_INTERFACE + } IMFNetProxyLocatorVtbl; + + interface IMFNetProxyLocator + { + CONST_VTBL struct IMFNetProxyLocatorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFNetProxyLocator_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFNetProxyLocator_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFNetProxyLocator_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFNetProxyLocator_FindFirstProxy(This,pszHost,pszUrl,fReserved) \ + ( (This)->lpVtbl -> FindFirstProxy(This,pszHost,pszUrl,fReserved) ) + +#define IMFNetProxyLocator_FindNextProxy(This) \ + ( (This)->lpVtbl -> FindNextProxy(This) ) + +#define IMFNetProxyLocator_RegisterProxyResult(This,hrOp) \ + ( (This)->lpVtbl -> RegisterProxyResult(This,hrOp) ) + +#define IMFNetProxyLocator_GetCurrentProxy(This,pszStr,pcchStr) \ + ( (This)->lpVtbl -> GetCurrentProxy(This,pszStr,pcchStr) ) + +#define IMFNetProxyLocator_Clone(This,ppProxyLocator) \ + ( (This)->lpVtbl -> Clone(This,ppProxyLocator) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFNetProxyLocator_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0066 */ +/* [local] */ + +STDAPI MFCreateProxyLocator( + LPCWSTR pszProtocol, + IPropertyStore* pProxyConfig, + _Outptr_ IMFNetProxyLocator** ppProxyLocator ); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0066_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0066_v0_0_s_ifspec; + +#ifndef __IMFNetProxyLocatorFactory_INTERFACE_DEFINED__ +#define __IMFNetProxyLocatorFactory_INTERFACE_DEFINED__ + +/* interface IMFNetProxyLocatorFactory */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFNetProxyLocatorFactory; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e9cd0384-a268-4bb4-82de-658d53574d41") + IMFNetProxyLocatorFactory : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateProxyLocator( + /* [in] */ LPCWSTR pszProtocol, + /* [annotation][out] */ + _Outptr_ IMFNetProxyLocator **ppProxyLocator) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFNetProxyLocatorFactoryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFNetProxyLocatorFactory * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFNetProxyLocatorFactory * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFNetProxyLocatorFactory * This); + + HRESULT ( STDMETHODCALLTYPE *CreateProxyLocator )( + IMFNetProxyLocatorFactory * This, + /* [in] */ LPCWSTR pszProtocol, + /* [annotation][out] */ + _Outptr_ IMFNetProxyLocator **ppProxyLocator); + + END_INTERFACE + } IMFNetProxyLocatorFactoryVtbl; + + interface IMFNetProxyLocatorFactory + { + CONST_VTBL struct IMFNetProxyLocatorFactoryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFNetProxyLocatorFactory_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFNetProxyLocatorFactory_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFNetProxyLocatorFactory_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFNetProxyLocatorFactory_CreateProxyLocator(This,pszProtocol,ppProxyLocator) \ + ( (This)->lpVtbl -> CreateProxyLocator(This,pszProtocol,ppProxyLocator) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFNetProxyLocatorFactory_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSaveJob_INTERFACE_DEFINED__ +#define __IMFSaveJob_INTERFACE_DEFINED__ + +/* interface IMFSaveJob */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSaveJob; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e9931663-80bf-4c6e-98af-5dcf58747d1f") + IMFSaveJob : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE BeginSave( + /* [in] */ IMFByteStream *pStream, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndSave( + /* [in] */ IMFAsyncResult *pResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE CancelSave( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetProgress( + /* [annotation][out] */ + _Out_ DWORD *pdwPercentComplete) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSaveJobVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSaveJob * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSaveJob * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSaveJob * This); + + HRESULT ( STDMETHODCALLTYPE *BeginSave )( + IMFSaveJob * This, + /* [in] */ IMFByteStream *pStream, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + HRESULT ( STDMETHODCALLTYPE *EndSave )( + IMFSaveJob * This, + /* [in] */ IMFAsyncResult *pResult); + + HRESULT ( STDMETHODCALLTYPE *CancelSave )( + IMFSaveJob * This); + + HRESULT ( STDMETHODCALLTYPE *GetProgress )( + IMFSaveJob * This, + /* [annotation][out] */ + _Out_ DWORD *pdwPercentComplete); + + END_INTERFACE + } IMFSaveJobVtbl; + + interface IMFSaveJob + { + CONST_VTBL struct IMFSaveJobVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSaveJob_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSaveJob_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSaveJob_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSaveJob_BeginSave(This,pStream,pCallback,pState) \ + ( (This)->lpVtbl -> BeginSave(This,pStream,pCallback,pState) ) + +#define IMFSaveJob_EndSave(This,pResult) \ + ( (This)->lpVtbl -> EndSave(This,pResult) ) + +#define IMFSaveJob_CancelSave(This) \ + ( (This)->lpVtbl -> CancelSave(This) ) + +#define IMFSaveJob_GetProgress(This,pdwPercentComplete) \ + ( (This)->lpVtbl -> GetProgress(This,pdwPercentComplete) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSaveJob_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0068 */ +/* [local] */ + +EXTERN_GUID( MFNET_SAVEJOB_SERVICE, 0xb85a587f, 0x3d02, 0x4e52, 0x95, 0x65, 0x55, 0xd3, 0xec, 0x1e, 0x7f, 0xf7 ); +typedef +enum _MFNETSOURCE_PROTOCOL_TYPE + { + MFNETSOURCE_UNDEFINED = 0, + MFNETSOURCE_HTTP = 0x1, + MFNETSOURCE_RTSP = 0x2, + MFNETSOURCE_FILE = 0x3, + MFNETSOURCE_MULTICAST = 0x4 + } MFNETSOURCE_PROTOCOL_TYPE; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0068_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0068_v0_0_s_ifspec; + +#ifndef __IMFNetSchemeHandlerConfig_INTERFACE_DEFINED__ +#define __IMFNetSchemeHandlerConfig_INTERFACE_DEFINED__ + +/* interface IMFNetSchemeHandlerConfig */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFNetSchemeHandlerConfig; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7BE19E73-C9BF-468a-AC5A-A5E8653BEC87") + IMFNetSchemeHandlerConfig : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetNumberOfSupportedProtocols( + /* [annotation][out] */ + _Out_ ULONG *pcProtocols) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSupportedProtocolType( + /* [in] */ ULONG nProtocolIndex, + /* [annotation][out] */ + _Out_ MFNETSOURCE_PROTOCOL_TYPE *pnProtocolType) = 0; + + virtual HRESULT STDMETHODCALLTYPE ResetProtocolRolloverSettings( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFNetSchemeHandlerConfigVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFNetSchemeHandlerConfig * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFNetSchemeHandlerConfig * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFNetSchemeHandlerConfig * This); + + HRESULT ( STDMETHODCALLTYPE *GetNumberOfSupportedProtocols )( + IMFNetSchemeHandlerConfig * This, + /* [annotation][out] */ + _Out_ ULONG *pcProtocols); + + HRESULT ( STDMETHODCALLTYPE *GetSupportedProtocolType )( + IMFNetSchemeHandlerConfig * This, + /* [in] */ ULONG nProtocolIndex, + /* [annotation][out] */ + _Out_ MFNETSOURCE_PROTOCOL_TYPE *pnProtocolType); + + HRESULT ( STDMETHODCALLTYPE *ResetProtocolRolloverSettings )( + IMFNetSchemeHandlerConfig * This); + + END_INTERFACE + } IMFNetSchemeHandlerConfigVtbl; + + interface IMFNetSchemeHandlerConfig + { + CONST_VTBL struct IMFNetSchemeHandlerConfigVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFNetSchemeHandlerConfig_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFNetSchemeHandlerConfig_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFNetSchemeHandlerConfig_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFNetSchemeHandlerConfig_GetNumberOfSupportedProtocols(This,pcProtocols) \ + ( (This)->lpVtbl -> GetNumberOfSupportedProtocols(This,pcProtocols) ) + +#define IMFNetSchemeHandlerConfig_GetSupportedProtocolType(This,nProtocolIndex,pnProtocolType) \ + ( (This)->lpVtbl -> GetSupportedProtocolType(This,nProtocolIndex,pnProtocolType) ) + +#define IMFNetSchemeHandlerConfig_ResetProtocolRolloverSettings(This) \ + ( (This)->lpVtbl -> ResetProtocolRolloverSettings(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFNetSchemeHandlerConfig_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0069 */ +/* [local] */ + +STDAPI MFCreateNetSchemePlugin( + REFIID riid, + LPVOID *ppvHandler ); +typedef +enum _MFNETSOURCE_TRANSPORT_TYPE + { + MFNETSOURCE_UDP = 0, + MFNETSOURCE_TCP = ( MFNETSOURCE_UDP + 1 ) + } MFNETSOURCE_TRANSPORT_TYPE; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef +enum _MFNETSOURCE_CACHE_STATE + { + MFNETSOURCE_CACHE_UNAVAILABLE = 0, + MFNETSOURCE_CACHE_ACTIVE_WRITING = ( MFNETSOURCE_CACHE_UNAVAILABLE + 1 ) , + MFNETSOURCE_CACHE_ACTIVE_COMPLETE = ( MFNETSOURCE_CACHE_ACTIVE_WRITING + 1 ) + } MFNETSOURCE_CACHE_STATE; + +typedef +enum _MFNETSOURCE_STATISTICS_IDS + { + MFNETSOURCE_RECVPACKETS_ID = 0, + MFNETSOURCE_LOSTPACKETS_ID = ( MFNETSOURCE_RECVPACKETS_ID + 1 ) , + MFNETSOURCE_RESENDSREQUESTED_ID = ( MFNETSOURCE_LOSTPACKETS_ID + 1 ) , + MFNETSOURCE_RESENDSRECEIVED_ID = ( MFNETSOURCE_RESENDSREQUESTED_ID + 1 ) , + MFNETSOURCE_RECOVEREDBYECCPACKETS_ID = ( MFNETSOURCE_RESENDSRECEIVED_ID + 1 ) , + MFNETSOURCE_RECOVEREDBYRTXPACKETS_ID = ( MFNETSOURCE_RECOVEREDBYECCPACKETS_ID + 1 ) , + MFNETSOURCE_OUTPACKETS_ID = ( MFNETSOURCE_RECOVEREDBYRTXPACKETS_ID + 1 ) , + MFNETSOURCE_RECVRATE_ID = ( MFNETSOURCE_OUTPACKETS_ID + 1 ) , + MFNETSOURCE_AVGBANDWIDTHBPS_ID = ( MFNETSOURCE_RECVRATE_ID + 1 ) , + MFNETSOURCE_BYTESRECEIVED_ID = ( MFNETSOURCE_AVGBANDWIDTHBPS_ID + 1 ) , + MFNETSOURCE_PROTOCOL_ID = ( MFNETSOURCE_BYTESRECEIVED_ID + 1 ) , + MFNETSOURCE_TRANSPORT_ID = ( MFNETSOURCE_PROTOCOL_ID + 1 ) , + MFNETSOURCE_CACHE_STATE_ID = ( MFNETSOURCE_TRANSPORT_ID + 1 ) , + MFNETSOURCE_LINKBANDWIDTH_ID = ( MFNETSOURCE_CACHE_STATE_ID + 1 ) , + MFNETSOURCE_CONTENTBITRATE_ID = ( MFNETSOURCE_LINKBANDWIDTH_ID + 1 ) , + MFNETSOURCE_SPEEDFACTOR_ID = ( MFNETSOURCE_CONTENTBITRATE_ID + 1 ) , + MFNETSOURCE_BUFFERSIZE_ID = ( MFNETSOURCE_SPEEDFACTOR_ID + 1 ) , + MFNETSOURCE_BUFFERPROGRESS_ID = ( MFNETSOURCE_BUFFERSIZE_ID + 1 ) , + MFNETSOURCE_LASTBWSWITCHTS_ID = ( MFNETSOURCE_BUFFERPROGRESS_ID + 1 ) , + MFNETSOURCE_SEEKRANGESTART_ID = ( MFNETSOURCE_LASTBWSWITCHTS_ID + 1 ) , + MFNETSOURCE_SEEKRANGEEND_ID = ( MFNETSOURCE_SEEKRANGESTART_ID + 1 ) , + MFNETSOURCE_BUFFERINGCOUNT_ID = ( MFNETSOURCE_SEEKRANGEEND_ID + 1 ) , + MFNETSOURCE_INCORRECTLYSIGNEDPACKETS_ID = ( MFNETSOURCE_BUFFERINGCOUNT_ID + 1 ) , + MFNETSOURCE_SIGNEDSESSION_ID = ( MFNETSOURCE_INCORRECTLYSIGNEDPACKETS_ID + 1 ) , + MFNETSOURCE_MAXBITRATE_ID = ( MFNETSOURCE_SIGNEDSESSION_ID + 1 ) , + MFNETSOURCE_RECEPTION_QUALITY_ID = ( MFNETSOURCE_MAXBITRATE_ID + 1 ) , + MFNETSOURCE_RECOVEREDPACKETS_ID = ( MFNETSOURCE_RECEPTION_QUALITY_ID + 1 ) , + MFNETSOURCE_VBR_ID = ( MFNETSOURCE_RECOVEREDPACKETS_ID + 1 ) , + MFNETSOURCE_DOWNLOADPROGRESS_ID = ( MFNETSOURCE_VBR_ID + 1 ) , + MFNETSOURCE_UNPREDEFINEDPROTOCOLNAME_ID = ( MFNETSOURCE_DOWNLOADPROGRESS_ID + 1 ) + } MFNETSOURCE_STATISTICS_IDS; + +EXTERN_GUID( MFNETSOURCE_STATISTICS_SERVICE, 0x3cb1f275, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_STATISTICS, 0x3cb1f274, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +EXTERN_GUID( MFNETSOURCE_BUFFERINGTIME, 0x3cb1f276, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_ACCELERATEDSTREAMINGDURATION, 0x3cb1f277, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_MAXUDPACCELERATEDSTREAMINGDURATION, 0x4aab2879, 0xbbe1, 0x4994, 0x9f, 0xf0, 0x54, 0x95, 0xbd, 0x25, 0x1, 0x29 ); +EXTERN_GUID( MFNETSOURCE_MAXBUFFERTIMEMS, 0x408b24e6, 0x4038, 0x4401, 0xb5, 0xb2, 0xfe, 0x70, 0x1a, 0x9e, 0xbf, 0x10 ); +EXTERN_GUID( MFNETSOURCE_CONNECTIONBANDWIDTH, 0x3cb1f278, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_CACHEENABLED, 0x3cb1f279, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_AUTORECONNECTLIMIT, 0x3cb1f27a, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_RESENDSENABLED, 0x3cb1f27b, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_THINNINGENABLED, 0x3cb1f27c, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_PROTOCOL, 0x3cb1f27d, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_TRANSPORT, 0x3cb1f27e, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +#if (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_GUID( MFNETSOURCE_PREVIEWMODEENABLED, 0x3cb1f27f, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +#endif // (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_GUID( MFNETSOURCE_CREDENTIAL_MANAGER, 0x3cb1f280, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_PPBANDWIDTH, 0x3cb1f281, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_AUTORECONNECTPROGRESS, 0x3cb1f282, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_PROXYLOCATORFACTORY, 0x3cb1f283, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_BROWSERUSERAGENT, 0x3cb1f28b, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_BROWSERWEBPAGE, 0x3cb1f28c, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_PLAYERVERSION, 0x3cb1f28d, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_PLAYERID, 0x3cb1f28e, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_HOSTEXE, 0x3cb1f28f, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_HOSTVERSION, 0x3cb1f291, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_PLAYERUSERAGENT, 0x3cb1f292, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +#if (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_GUID( MFNETSOURCE_CLIENTGUID, 0x60a2c4a6, 0xf197, 0x4c14, 0xa5, 0xbf, 0x88, 0x83, 0xd, 0x24, 0x58, 0xaf ); +#endif // (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_GUID( MFNETSOURCE_LOGURL, 0x3cb1f293, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_ENABLE_UDP, 0x3cb1f294, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_ENABLE_TCP, 0x3cb1f295, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_ENABLE_MSB, 0x3cb1f296, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_ENABLE_RTSP, 0x3cb1f298, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_ENABLE_HTTP, 0x3cb1f299, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_ENABLE_STREAMING, 0x3cb1f29c, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_ENABLE_DOWNLOAD, 0x3cb1f29d, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_ENABLE_PRIVATEMODE, 0x824779d8, 0xf18b, 0x4405, 0x8c, 0xf1, 0x46, 0x4f, 0xb5, 0xaa, 0x8f, 0x71 ); +EXTERN_GUID( MFNETSOURCE_UDP_PORT_RANGE, 0x3cb1f29a, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_PROXYINFO, 0x3cb1f29b, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_DRMNET_LICENSE_REPRESENTATION, 0x47eae1bd, 0xbdfe, 0x42e2, 0x82, 0xf3, 0x54, 0xa4, 0x8c, 0x17, 0x96, 0x2d ); +EXTERN_GUID( MFNETSOURCE_PROXYSETTINGS, 0x3cb1f287, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_PROXYHOSTNAME, 0x3cb1f284, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_PROXYPORT, 0x3cb1f288, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_PROXYEXCEPTIONLIST, 0x3cb1f285, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_PROXYBYPASSFORLOCAL, 0x3cb1f286, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +EXTERN_GUID( MFNETSOURCE_PROXYRERUNAUTODETECTION, 0x3cb1f289, 0x0505, 0x4c5d, 0xae, 0x71, 0x0a, 0x55, 0x63, 0x44, 0xef, 0xa1 ); +#if (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_GUID( MFNETSOURCE_STREAM_LANGUAGE, 0x9ab44318, 0xf7cd, 0x4f2d, 0x8d, 0x6d, 0xfa, 0x35, 0xb4, 0x92, 0xce, 0xcb ); +EXTERN_GUID( MFNETSOURCE_LOGPARAMS, 0x64936ae8, 0x9418, 0x453a, 0x8c, 0xda, 0x3e, 0xa, 0x66, 0x8b, 0x35, 0x3b ); +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#if (WINVER >= _WIN32_WINNT_WIN8) +EXTERN_GUID( MFNETSOURCE_PEERMANAGER, 0x48b29adb, 0xfebf, 0x45ee, 0xa9, 0xbf, 0xef, 0xb8, 0x1c, 0x49, 0x2e, 0xfc ); +EXTERN_GUID( MFNETSOURCE_FRIENDLYNAME, 0x5b2a7757, 0xbc6b, 0x447e, 0xaa, 0x06, 0x0d, 0xda, 0x1c, 0x64, 0x6e, 0x2f ); +#endif // (WINVER >= _WIN32_WINNT_WIN8) +typedef +enum _MFNET_PROXYSETTINGS + { + MFNET_PROXYSETTING_NONE = 0, + MFNET_PROXYSETTING_MANUAL = 1, + MFNET_PROXYSETTING_AUTO = 2, + MFNET_PROXYSETTING_BROWSER = 3 + } MFNET_PROXYSETTINGS; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0069_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0069_v0_0_s_ifspec; + +#ifndef __IMFSchemeHandler_INTERFACE_DEFINED__ +#define __IMFSchemeHandler_INTERFACE_DEFINED__ + +/* interface IMFSchemeHandler */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSchemeHandler; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6D4C7B74-52A0-4bb7-B0DB-55F29F47A668") + IMFSchemeHandler : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE BeginCreateObject( + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Outptr_opt_ IUnknown **ppIUnknownCancelCookie, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndCreateObject( + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE CancelObjectCreation( + /* [in] */ IUnknown *pIUnknownCancelCookie) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSchemeHandlerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSchemeHandler * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSchemeHandler * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSchemeHandler * This); + + HRESULT ( STDMETHODCALLTYPE *BeginCreateObject )( + IMFSchemeHandler * This, + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Outptr_opt_ IUnknown **ppIUnknownCancelCookie, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + HRESULT ( STDMETHODCALLTYPE *EndCreateObject )( + IMFSchemeHandler * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject); + + HRESULT ( STDMETHODCALLTYPE *CancelObjectCreation )( + IMFSchemeHandler * This, + /* [in] */ IUnknown *pIUnknownCancelCookie); + + END_INTERFACE + } IMFSchemeHandlerVtbl; + + interface IMFSchemeHandler + { + CONST_VTBL struct IMFSchemeHandlerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSchemeHandler_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSchemeHandler_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSchemeHandler_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSchemeHandler_BeginCreateObject(This,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginCreateObject(This,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState) ) + +#define IMFSchemeHandler_EndCreateObject(This,pResult,pObjectType,ppObject) \ + ( (This)->lpVtbl -> EndCreateObject(This,pResult,pObjectType,ppObject) ) + +#define IMFSchemeHandler_CancelObjectCreation(This,pIUnknownCancelCookie) \ + ( (This)->lpVtbl -> CancelObjectCreation(This,pIUnknownCancelCookie) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSchemeHandler_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0070 */ +/* [local] */ + +#if (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_GUID(MF_BYTESTREAMHANDLER_ACCEPTS_SHARE_WRITE, 0xa6e1f733, 0x3001, 0x4915, 0x81, 0x50, 0x15, 0x58, 0xa2, 0x18, 0xe, 0xc8); +#endif // (WINVER >= _WIN32_WINNT_WIN7) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0070_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0070_v0_0_s_ifspec; + +#ifndef __IMFByteStreamHandler_INTERFACE_DEFINED__ +#define __IMFByteStreamHandler_INTERFACE_DEFINED__ + +/* interface IMFByteStreamHandler */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFByteStreamHandler; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("BB420AA4-765B-4a1f-91FE-D6A8A143924C") + IMFByteStreamHandler : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE BeginCreateObject( + /* [in] */ IMFByteStream *pByteStream, + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Outptr_opt_ IUnknown **ppIUnknownCancelCookie, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndCreateObject( + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE CancelObjectCreation( + /* [in] */ IUnknown *pIUnknownCancelCookie) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMaxNumberOfBytesRequiredForResolution( + /* [annotation][out] */ + _Out_ QWORD *pqwBytes) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFByteStreamHandlerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFByteStreamHandler * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFByteStreamHandler * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFByteStreamHandler * This); + + HRESULT ( STDMETHODCALLTYPE *BeginCreateObject )( + IMFByteStreamHandler * This, + /* [in] */ IMFByteStream *pByteStream, + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Outptr_opt_ IUnknown **ppIUnknownCancelCookie, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + HRESULT ( STDMETHODCALLTYPE *EndCreateObject )( + IMFByteStreamHandler * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject); + + HRESULT ( STDMETHODCALLTYPE *CancelObjectCreation )( + IMFByteStreamHandler * This, + /* [in] */ IUnknown *pIUnknownCancelCookie); + + HRESULT ( STDMETHODCALLTYPE *GetMaxNumberOfBytesRequiredForResolution )( + IMFByteStreamHandler * This, + /* [annotation][out] */ + _Out_ QWORD *pqwBytes); + + END_INTERFACE + } IMFByteStreamHandlerVtbl; + + interface IMFByteStreamHandler + { + CONST_VTBL struct IMFByteStreamHandlerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFByteStreamHandler_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFByteStreamHandler_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFByteStreamHandler_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFByteStreamHandler_BeginCreateObject(This,pByteStream,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginCreateObject(This,pByteStream,pwszURL,dwFlags,pProps,ppIUnknownCancelCookie,pCallback,punkState) ) + +#define IMFByteStreamHandler_EndCreateObject(This,pResult,pObjectType,ppObject) \ + ( (This)->lpVtbl -> EndCreateObject(This,pResult,pObjectType,ppObject) ) + +#define IMFByteStreamHandler_CancelObjectCreation(This,pIUnknownCancelCookie) \ + ( (This)->lpVtbl -> CancelObjectCreation(This,pIUnknownCancelCookie) ) + +#define IMFByteStreamHandler_GetMaxNumberOfBytesRequiredForResolution(This,pqwBytes) \ + ( (This)->lpVtbl -> GetMaxNumberOfBytesRequiredForResolution(This,pqwBytes) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFByteStreamHandler_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0071 */ +/* [local] */ + +EXTERN_GUID( MF_BYTESTREAM_SERVICE, 0xab025e2b, 0x16d9, 0x4180, 0xa1, 0x27, 0xba, 0x6c, 0x70, 0x15, 0x61, 0x61 ); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0071_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0071_v0_0_s_ifspec; + +#ifndef __IMFTrustedInput_INTERFACE_DEFINED__ +#define __IMFTrustedInput_INTERFACE_DEFINED__ + +/* interface IMFTrustedInput */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFTrustedInput; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("542612C4-A1B8-4632-B521-DE11EA64A0B0") + IMFTrustedInput : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetInputTrustAuthority( + /* [in] */ DWORD dwStreamID, + /* [in] */ __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt IUnknown **ppunkObject) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTrustedInputVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFTrustedInput * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFTrustedInput * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFTrustedInput * This); + + HRESULT ( STDMETHODCALLTYPE *GetInputTrustAuthority )( + __RPC__in IMFTrustedInput * This, + /* [in] */ DWORD dwStreamID, + /* [in] */ __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt IUnknown **ppunkObject); + + END_INTERFACE + } IMFTrustedInputVtbl; + + interface IMFTrustedInput + { + CONST_VTBL struct IMFTrustedInputVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTrustedInput_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTrustedInput_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTrustedInput_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTrustedInput_GetInputTrustAuthority(This,dwStreamID,riid,ppunkObject) \ + ( (This)->lpVtbl -> GetInputTrustAuthority(This,dwStreamID,riid,ppunkObject) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTrustedInput_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0072 */ +/* [local] */ + +typedef +enum _MFPOLICYMANAGER_ACTION + { + PEACTION_NO = 0, + PEACTION_PLAY = 1, + PEACTION_COPY = 2, + PEACTION_EXPORT = 3, + PEACTION_EXTRACT = 4, + PEACTION_RESERVED1 = 5, + PEACTION_RESERVED2 = 6, + PEACTION_RESERVED3 = 7, + PEACTION_LAST = 7 + } MFPOLICYMANAGER_ACTION; + +typedef struct _MFINPUTTRUSTAUTHORITY_ACTION + { + MFPOLICYMANAGER_ACTION Action; + BYTE *pbTicket; + DWORD cbTicket; + } MFINPUTTRUSTAUTHORITY_ACCESS_ACTION; + +typedef struct _MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS + { + DWORD dwSize; + DWORD dwVer; + DWORD cbSignatureOffset; + DWORD cbSignatureSize; + DWORD cbExtensionOffset; + DWORD cbExtensionSize; + DWORD cActions; + MFINPUTTRUSTAUTHORITY_ACCESS_ACTION rgOutputActions[ 1 ]; + } MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS; + + +EXTERN_GUID( MF_MEDIA_PROTECTION_MANAGER_PROPERTIES, 0x38BD81A9, 0xACEA, 0x4C73, 0x89, 0xB2, 0x55, 0x32, 0xC0, 0xAE, 0xCA, 0x79 ); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0072_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0072_v0_0_s_ifspec; + +#ifndef __IMFInputTrustAuthority_INTERFACE_DEFINED__ +#define __IMFInputTrustAuthority_INTERFACE_DEFINED__ + +/* interface IMFInputTrustAuthority */ +/* [helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFInputTrustAuthority; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("D19F8E98-B126-4446-890C-5DCB7AD71453") + IMFInputTrustAuthority : public IUnknown + { + public: + virtual /* [local] */ HRESULT STDMETHODCALLTYPE GetDecrypter( + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _Outptr_ void **ppv) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE RequestAccess( + /* [in] */ MFPOLICYMANAGER_ACTION Action, + /* [annotation][out] */ + _Outptr_ IMFActivate **ppContentEnablerActivate) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE GetPolicy( + /* [in] */ MFPOLICYMANAGER_ACTION Action, + /* [annotation][out] */ + _Outptr_ IMFOutputPolicy **ppPolicy) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE BindAccess( + /* [annotation][in] */ + _In_ MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS *pParam) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE UpdateAccess( + /* [annotation][in] */ + _In_ MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS *pParam) = 0; + + virtual HRESULT STDMETHODCALLTYPE Reset( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFInputTrustAuthorityVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFInputTrustAuthority * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFInputTrustAuthority * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFInputTrustAuthority * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *GetDecrypter )( + IMFInputTrustAuthority * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _Outptr_ void **ppv); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *RequestAccess )( + IMFInputTrustAuthority * This, + /* [in] */ MFPOLICYMANAGER_ACTION Action, + /* [annotation][out] */ + _Outptr_ IMFActivate **ppContentEnablerActivate); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *GetPolicy )( + IMFInputTrustAuthority * This, + /* [in] */ MFPOLICYMANAGER_ACTION Action, + /* [annotation][out] */ + _Outptr_ IMFOutputPolicy **ppPolicy); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BindAccess )( + IMFInputTrustAuthority * This, + /* [annotation][in] */ + _In_ MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS *pParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *UpdateAccess )( + IMFInputTrustAuthority * This, + /* [annotation][in] */ + _In_ MFINPUTTRUSTAUTHORITY_ACCESS_PARAMS *pParam); + + HRESULT ( STDMETHODCALLTYPE *Reset )( + __RPC__in IMFInputTrustAuthority * This); + + END_INTERFACE + } IMFInputTrustAuthorityVtbl; + + interface IMFInputTrustAuthority + { + CONST_VTBL struct IMFInputTrustAuthorityVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFInputTrustAuthority_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFInputTrustAuthority_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFInputTrustAuthority_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFInputTrustAuthority_GetDecrypter(This,riid,ppv) \ + ( (This)->lpVtbl -> GetDecrypter(This,riid,ppv) ) + +#define IMFInputTrustAuthority_RequestAccess(This,Action,ppContentEnablerActivate) \ + ( (This)->lpVtbl -> RequestAccess(This,Action,ppContentEnablerActivate) ) + +#define IMFInputTrustAuthority_GetPolicy(This,Action,ppPolicy) \ + ( (This)->lpVtbl -> GetPolicy(This,Action,ppPolicy) ) + +#define IMFInputTrustAuthority_BindAccess(This,pParam) \ + ( (This)->lpVtbl -> BindAccess(This,pParam) ) + +#define IMFInputTrustAuthority_UpdateAccess(This,pParam) \ + ( (This)->lpVtbl -> UpdateAccess(This,pParam) ) + +#define IMFInputTrustAuthority_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFInputTrustAuthority_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0073 */ +/* [local] */ + + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0073_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0073_v0_0_s_ifspec; + +#ifndef __IMFTrustedOutput_INTERFACE_DEFINED__ +#define __IMFTrustedOutput_INTERFACE_DEFINED__ + +/* interface IMFTrustedOutput */ +/* [local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFTrustedOutput; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("D19F8E95-B126-4446-890C-5DCB7AD71453") + IMFTrustedOutput : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetOutputTrustAuthorityCount( + /* [annotation][out] */ + _Out_ DWORD *pcOutputTrustAuthorities) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputTrustAuthorityByIndex( + /* [in] */ DWORD dwIndex, + /* [annotation][out] */ + _Outptr_ IMFOutputTrustAuthority **ppauthority) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsFinal( + /* [annotation][out] */ + _Out_ BOOL *pfIsFinal) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTrustedOutputVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTrustedOutput * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTrustedOutput * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTrustedOutput * This); + + HRESULT ( STDMETHODCALLTYPE *GetOutputTrustAuthorityCount )( + IMFTrustedOutput * This, + /* [annotation][out] */ + _Out_ DWORD *pcOutputTrustAuthorities); + + HRESULT ( STDMETHODCALLTYPE *GetOutputTrustAuthorityByIndex )( + IMFTrustedOutput * This, + /* [in] */ DWORD dwIndex, + /* [annotation][out] */ + _Outptr_ IMFOutputTrustAuthority **ppauthority); + + HRESULT ( STDMETHODCALLTYPE *IsFinal )( + IMFTrustedOutput * This, + /* [annotation][out] */ + _Out_ BOOL *pfIsFinal); + + END_INTERFACE + } IMFTrustedOutputVtbl; + + interface IMFTrustedOutput + { + CONST_VTBL struct IMFTrustedOutputVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTrustedOutput_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTrustedOutput_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTrustedOutput_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTrustedOutput_GetOutputTrustAuthorityCount(This,pcOutputTrustAuthorities) \ + ( (This)->lpVtbl -> GetOutputTrustAuthorityCount(This,pcOutputTrustAuthorities) ) + +#define IMFTrustedOutput_GetOutputTrustAuthorityByIndex(This,dwIndex,ppauthority) \ + ( (This)->lpVtbl -> GetOutputTrustAuthorityByIndex(This,dwIndex,ppauthority) ) + +#define IMFTrustedOutput_IsFinal(This,pfIsFinal) \ + ( (This)->lpVtbl -> IsFinal(This,pfIsFinal) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTrustedOutput_INTERFACE_DEFINED__ */ + + +#ifndef __IMFOutputTrustAuthority_INTERFACE_DEFINED__ +#define __IMFOutputTrustAuthority_INTERFACE_DEFINED__ + +/* interface IMFOutputTrustAuthority */ +/* [local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFOutputTrustAuthority; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("D19F8E94-B126-4446-890C-5DCB7AD71453") + IMFOutputTrustAuthority : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetAction( + /* [annotation][out] */ + _Out_ MFPOLICYMANAGER_ACTION *pAction) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPolicy( + /* [annotation][in] */ + _In_reads_opt_(nPolicy) IMFOutputPolicy **ppPolicy, + /* [in] */ DWORD nPolicy, + /* [annotation][size_is][size_is][unique][out] */ + _Outptr_opt_result_bytebuffer_(*pcbTicket) BYTE **ppbTicket, + /* [annotation][out] */ + _Out_opt_ DWORD *pcbTicket) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFOutputTrustAuthorityVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFOutputTrustAuthority * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFOutputTrustAuthority * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFOutputTrustAuthority * This); + + HRESULT ( STDMETHODCALLTYPE *GetAction )( + IMFOutputTrustAuthority * This, + /* [annotation][out] */ + _Out_ MFPOLICYMANAGER_ACTION *pAction); + + HRESULT ( STDMETHODCALLTYPE *SetPolicy )( + IMFOutputTrustAuthority * This, + /* [annotation][in] */ + _In_reads_opt_(nPolicy) IMFOutputPolicy **ppPolicy, + /* [in] */ DWORD nPolicy, + /* [annotation][size_is][size_is][unique][out] */ + _Outptr_opt_result_bytebuffer_(*pcbTicket) BYTE **ppbTicket, + /* [annotation][out] */ + _Out_opt_ DWORD *pcbTicket); + + END_INTERFACE + } IMFOutputTrustAuthorityVtbl; + + interface IMFOutputTrustAuthority + { + CONST_VTBL struct IMFOutputTrustAuthorityVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFOutputTrustAuthority_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFOutputTrustAuthority_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFOutputTrustAuthority_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFOutputTrustAuthority_GetAction(This,pAction) \ + ( (This)->lpVtbl -> GetAction(This,pAction) ) + +#define IMFOutputTrustAuthority_SetPolicy(This,ppPolicy,nPolicy,ppbTicket,pcbTicket) \ + ( (This)->lpVtbl -> SetPolicy(This,ppPolicy,nPolicy,ppbTicket,pcbTicket) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFOutputTrustAuthority_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0075 */ +/* [local] */ + + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0075_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0075_v0_0_s_ifspec; + +#ifndef __IMFOutputPolicy_INTERFACE_DEFINED__ +#define __IMFOutputPolicy_INTERFACE_DEFINED__ + +/* interface IMFOutputPolicy */ +/* [local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFOutputPolicy; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7F00F10A-DAED-41AF-AB26-5FDFA4DFBA3C") + IMFOutputPolicy : public IMFAttributes + { + public: + virtual HRESULT STDMETHODCALLTYPE GenerateRequiredSchemas( + /* [in] */ DWORD dwAttributes, + /* [in] */ GUID guidOutputSubType, + /* [in] */ GUID *rgGuidProtectionSchemasSupported, + /* [in] */ DWORD cProtectionSchemasSupported, + /* [annotation][out] */ + _Outptr_ IMFCollection **ppRequiredProtectionSchemas) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOriginatorID( + /* [annotation][out] */ + _Out_ GUID *pguidOriginatorID) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMinimumGRLVersion( + /* [annotation][out] */ + _Out_ DWORD *pdwMinimumGRLVersion) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFOutputPolicyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFOutputPolicy * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFOutputPolicy * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFOutputPolicy * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [full][out][in] */ PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [out] */ MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + IMFOutputPolicy * This, + REFGUID guidKey, + REFPROPVARIANT Value, + /* [out] */ BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + IMFOutputPolicy * This, + IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [out] */ UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [out] */ UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [out] */ double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [out] */ GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [out] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [size_is][out] */ LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [size_is][size_is][out] */ LPWSTR *ppwszValue, + /* [out] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [out] */ UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [size_is][out] */ UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [size_is][size_is][out] */ UINT8 **ppBuf, + /* [out] */ UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + IMFOutputPolicy * This, + REFGUID guidKey, + REFIID riid, + /* [iid_is][out] */ LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + IMFOutputPolicy * This, + REFGUID guidKey, + REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + IMFOutputPolicy * This, + REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + IMFOutputPolicy * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + IMFOutputPolicy * This, + REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + IMFOutputPolicy * This, + REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + IMFOutputPolicy * This, + REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + IMFOutputPolicy * This, + REFGUID guidKey, + REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [string][in] */ LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [size_is][in] */ const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + IMFOutputPolicy * This, + REFGUID guidKey, + /* [in] */ IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + IMFOutputPolicy * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + IMFOutputPolicy * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + IMFOutputPolicy * This, + /* [out] */ UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + IMFOutputPolicy * This, + UINT32 unIndex, + /* [out] */ GUID *pguidKey, + /* [full][out][in] */ PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + IMFOutputPolicy * This, + /* [in] */ IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *GenerateRequiredSchemas )( + IMFOutputPolicy * This, + /* [in] */ DWORD dwAttributes, + /* [in] */ GUID guidOutputSubType, + /* [in] */ GUID *rgGuidProtectionSchemasSupported, + /* [in] */ DWORD cProtectionSchemasSupported, + /* [annotation][out] */ + _Outptr_ IMFCollection **ppRequiredProtectionSchemas); + + HRESULT ( STDMETHODCALLTYPE *GetOriginatorID )( + IMFOutputPolicy * This, + /* [annotation][out] */ + _Out_ GUID *pguidOriginatorID); + + HRESULT ( STDMETHODCALLTYPE *GetMinimumGRLVersion )( + IMFOutputPolicy * This, + /* [annotation][out] */ + _Out_ DWORD *pdwMinimumGRLVersion); + + END_INTERFACE + } IMFOutputPolicyVtbl; + + interface IMFOutputPolicy + { + CONST_VTBL struct IMFOutputPolicyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFOutputPolicy_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFOutputPolicy_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFOutputPolicy_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFOutputPolicy_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFOutputPolicy_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFOutputPolicy_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFOutputPolicy_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFOutputPolicy_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFOutputPolicy_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFOutputPolicy_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFOutputPolicy_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFOutputPolicy_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFOutputPolicy_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFOutputPolicy_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFOutputPolicy_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFOutputPolicy_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFOutputPolicy_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFOutputPolicy_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFOutputPolicy_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFOutputPolicy_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFOutputPolicy_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFOutputPolicy_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFOutputPolicy_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFOutputPolicy_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFOutputPolicy_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFOutputPolicy_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFOutputPolicy_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFOutputPolicy_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFOutputPolicy_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFOutputPolicy_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFOutputPolicy_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFOutputPolicy_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFOutputPolicy_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFOutputPolicy_GenerateRequiredSchemas(This,dwAttributes,guidOutputSubType,rgGuidProtectionSchemasSupported,cProtectionSchemasSupported,ppRequiredProtectionSchemas) \ + ( (This)->lpVtbl -> GenerateRequiredSchemas(This,dwAttributes,guidOutputSubType,rgGuidProtectionSchemasSupported,cProtectionSchemasSupported,ppRequiredProtectionSchemas) ) + +#define IMFOutputPolicy_GetOriginatorID(This,pguidOriginatorID) \ + ( (This)->lpVtbl -> GetOriginatorID(This,pguidOriginatorID) ) + +#define IMFOutputPolicy_GetMinimumGRLVersion(This,pdwMinimumGRLVersion) \ + ( (This)->lpVtbl -> GetMinimumGRLVersion(This,pdwMinimumGRLVersion) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFOutputPolicy_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0076 */ +/* [local] */ + +#define MFOUTPUTATTRIBUTE_DIGITAL ((DWORD) 0x00000001) +#define MFOUTPUTATTRIBUTE_NONSTANDARDIMPLEMENTATION ((DWORD) 0x00000002) +#define MFOUTPUTATTRIBUTE_VIDEO ((DWORD) 0x00000004) +#define MFOUTPUTATTRIBUTE_COMPRESSED ((DWORD) 0x00000008) +#define MFOUTPUTATTRIBUTE_SOFTWARE ((DWORD) 0x00000010) +#define MFOUTPUTATTRIBUTE_BUS ((DWORD) 0x00000020) +#define MFOUTPUTATTRIBUTE_BUSIMPLEMENTATION ((DWORD) 0x0000FF00) +EXTERN_GUID( MFCONNECTOR_SPDIF, 0xb94a712, 0xad3e, 0x4cee, 0x83, 0xce, 0xce, 0x32, 0xe3, 0xdb, 0x65, 0x22); + +EXTERN_GUID( MFCONNECTOR_UNKNOWN, 0xac3aef5c, 0xce43, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_PCI, 0xac3aef5d, 0xce43, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_PCIX, 0xac3aef5e, 0xce43, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_PCI_Express, 0xac3aef5f, 0xce43, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_AGP, 0xac3aef60, 0xce43, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); + + +EXTERN_GUID( MFCONNECTOR_VGA, 0x57cd5968, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_SVIDEO, 0x57cd5969, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_COMPOSITE, 0x57cd596a, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_COMPONENT, 0x57cd596b, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_DVI, 0x57cd596c, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_HDMI, 0x57cd596d, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_LVDS, 0x57cd596e, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_D_JPN, 0x57cd5970, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_SDI, 0x57cd5971, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_DISPLAYPORT_EXTERNAL, 0x57cd5972, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_DISPLAYPORT_EMBEDDED, 0x57cd5973, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_UDI_EXTERNAL, 0x57cd5974, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_UDI_EMBEDDED, 0x57cd5975, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_MIRACAST, 0x57cd5977, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_TRANSPORT_AGNOSTIC_DIGITAL_MODE_A, 0x57cd5978, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); +EXTERN_GUID( MFCONNECTOR_TRANSPORT_AGNOSTIC_DIGITAL_MODE_B, 0x57cd5979, 0xce47, 0x11d9, 0x92, 0xdb, 0x00, 0x0b, 0xdb, 0x28, 0xff, 0x98); + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0076_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0076_v0_0_s_ifspec; + +#ifndef __IMFOutputSchema_INTERFACE_DEFINED__ +#define __IMFOutputSchema_INTERFACE_DEFINED__ + +/* interface IMFOutputSchema */ +/* [local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFOutputSchema; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7BE0FC5B-ABD9-44FB-A5C8-F50136E71599") + IMFOutputSchema : public IMFAttributes + { + public: + virtual HRESULT STDMETHODCALLTYPE GetSchemaType( + /* [annotation][out] */ + _Out_ GUID *pguidSchemaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetConfigurationData( + /* [annotation][out] */ + _Out_ DWORD *pdwVal) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOriginatorID( + /* [annotation][out] */ + _Out_ GUID *pguidOriginatorID) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFOutputSchemaVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFOutputSchema * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFOutputSchema * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFOutputSchema * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [full][out][in] */ PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [out] */ MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + IMFOutputSchema * This, + REFGUID guidKey, + REFPROPVARIANT Value, + /* [out] */ BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + IMFOutputSchema * This, + IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [out] */ UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [out] */ UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [out] */ double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [out] */ GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [out] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [size_is][out] */ LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [size_is][size_is][out] */ LPWSTR *ppwszValue, + /* [out] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [out] */ UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [size_is][out] */ UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [size_is][size_is][out] */ UINT8 **ppBuf, + /* [out] */ UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + IMFOutputSchema * This, + REFGUID guidKey, + REFIID riid, + /* [iid_is][out] */ LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + IMFOutputSchema * This, + REFGUID guidKey, + REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + IMFOutputSchema * This, + REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + IMFOutputSchema * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + IMFOutputSchema * This, + REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + IMFOutputSchema * This, + REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + IMFOutputSchema * This, + REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + IMFOutputSchema * This, + REFGUID guidKey, + REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [string][in] */ LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [size_is][in] */ const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + IMFOutputSchema * This, + REFGUID guidKey, + /* [in] */ IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + IMFOutputSchema * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + IMFOutputSchema * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + IMFOutputSchema * This, + /* [out] */ UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + IMFOutputSchema * This, + UINT32 unIndex, + /* [out] */ GUID *pguidKey, + /* [full][out][in] */ PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + IMFOutputSchema * This, + /* [in] */ IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *GetSchemaType )( + IMFOutputSchema * This, + /* [annotation][out] */ + _Out_ GUID *pguidSchemaType); + + HRESULT ( STDMETHODCALLTYPE *GetConfigurationData )( + IMFOutputSchema * This, + /* [annotation][out] */ + _Out_ DWORD *pdwVal); + + HRESULT ( STDMETHODCALLTYPE *GetOriginatorID )( + IMFOutputSchema * This, + /* [annotation][out] */ + _Out_ GUID *pguidOriginatorID); + + END_INTERFACE + } IMFOutputSchemaVtbl; + + interface IMFOutputSchema + { + CONST_VTBL struct IMFOutputSchemaVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFOutputSchema_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFOutputSchema_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFOutputSchema_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFOutputSchema_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFOutputSchema_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFOutputSchema_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFOutputSchema_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFOutputSchema_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFOutputSchema_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFOutputSchema_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFOutputSchema_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFOutputSchema_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFOutputSchema_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFOutputSchema_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFOutputSchema_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFOutputSchema_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFOutputSchema_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFOutputSchema_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFOutputSchema_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFOutputSchema_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFOutputSchema_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFOutputSchema_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFOutputSchema_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFOutputSchema_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFOutputSchema_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFOutputSchema_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFOutputSchema_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFOutputSchema_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFOutputSchema_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFOutputSchema_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFOutputSchema_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFOutputSchema_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFOutputSchema_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFOutputSchema_GetSchemaType(This,pguidSchemaType) \ + ( (This)->lpVtbl -> GetSchemaType(This,pguidSchemaType) ) + +#define IMFOutputSchema_GetConfigurationData(This,pdwVal) \ + ( (This)->lpVtbl -> GetConfigurationData(This,pdwVal) ) + +#define IMFOutputSchema_GetOriginatorID(This,pguidOriginatorID) \ + ( (This)->lpVtbl -> GetOriginatorID(This,pguidOriginatorID) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFOutputSchema_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0077 */ +/* [local] */ + + +EXTERN_GUID( MFPROTECTION_DISABLE, 0x8cc6d81b, 0xfec6, 0x4d8f, 0x96, 0x4b, 0xcf, 0xba, 0x0b, 0x0d, 0xad, 0x0d); +EXTERN_GUID( MFPROTECTION_CONSTRICTVIDEO, 0x193370ce, 0xc5e4, 0x4c3a, 0x8a, 0x66, 0x69, 0x59, 0xb4, 0xda, 0x44, 0x42); +EXTERN_GUID( MFPROTECTION_CONSTRICTVIDEO_NOOPM, 0xa580e8cd, 0xc247, 0x4957, 0xb9, 0x83, 0x3c, 0x2e, 0xeb, 0xd1, 0xff, 0x59); +EXTERN_GUID( MFPROTECTION_CONSTRICTAUDIO, 0xffc99b44, 0xdf48, 0x4e16, 0x8e, 0x66, 0x09, 0x68, 0x92, 0xc1, 0x57, 0x8a); +EXTERN_GUID( MFPROTECTION_TRUSTEDAUDIODRIVERS, 0x65bdf3d2, 0x0168, 0x4816, 0xa5, 0x33, 0x55, 0xd4, 0x7b, 0x02, 0x71, 0x01); +EXTERN_GUID( MFPROTECTION_HDCP, 0xAE7CC03D, 0xC828, 0x4021, 0xac, 0xb7, 0xd5, 0x78, 0xd2, 0x7a, 0xaf, 0x13); +EXTERN_GUID( MFPROTECTION_CGMSA, 0xE57E69E9, 0x226B, 0x4d31, 0xB4, 0xE3, 0xD3, 0xDB, 0x00, 0x87, 0x36, 0xDD); +EXTERN_GUID( MFPROTECTION_ACP, 0xc3fd11c6, 0xf8b7, 0x4d20, 0xb0, 0x08, 0x1d, 0xb1, 0x7d, 0x61, 0xf2, 0xda); +EXTERN_GUID( MFPROTECTION_WMDRMOTA, 0xa267a6a1, 0x362e, 0x47d0, 0x88, 0x05, 0x46, 0x28, 0x59, 0x8a, 0x23, 0xe4); +EXTERN_GUID( MFPROTECTION_FFT, 0x462a56b2, 0x2866, 0x4bb6, 0x98, 0x0d, 0x6d, 0x8d, 0x9e, 0xdb, 0x1a, 0x8c); +EXTERN_GUID( MFPROTECTION_PROTECTED_SURFACE, 0x4f5d9566, 0xe742, 0x4a25, 0x8d, 0x1f, 0xd2, 0x87, 0xb5, 0xfa, 0x0a, 0xde); +EXTERN_GUID( MFPROTECTION_DISABLE_SCREEN_SCRAPE, 0xa21179a4, 0xb7cd, 0x40d8, 0x96, 0x14, 0x8e, 0xf2, 0x37, 0x1b, 0xa7, 0x8d); +EXTERN_GUID( MFPROTECTION_VIDEO_FRAMES, 0x36a59cbc, 0x7401, 0x4a8c, 0xbc, 0x20, 0x46, 0xa7, 0xc9, 0xe5, 0x97, 0xf0); +EXTERN_GUID(MFPROTECTION_HARDWARE, 0x4ee7f0c1, 0x9ed7, 0x424f, 0xb6, 0xbe, 0x99, 0x6b, 0x33, 0x52, 0x88, 0x56); +EXTERN_GUID( MFPROTECTION_HDCP_WITH_TYPE_ENFORCEMENT, 0xa4a585e8, 0xed60, 0x442d, 0x81, 0x4d, 0xdb, 0x4d, 0x42, 0x20, 0xa0, 0x6d); +typedef +enum _MF_OPM_CGMSA_PROTECTION_LEVEL + { + MF_OPM_CGMSA_OFF = 0, + MF_OPM_CGMSA_COPY_FREELY = 0x1, + MF_OPM_CGMSA_COPY_NO_MORE = 0x2, + MF_OPM_CGMSA_COPY_ONE_GENERATION = 0x3, + MF_OPM_CGMSA_COPY_NEVER = 0x4, + MF_OPM_CGMSA_REDISTRIBUTION_CONTROL_REQUIRED = 0x8 + } MF_OPM_CGMSA_PROTECTION_LEVEL; + +typedef +enum _MF_OPM_ACP_PROTECTION_LEVEL + { + MF_OPM_ACP_OFF = 0, + MF_OPM_ACP_LEVEL_ONE = 1, + MF_OPM_ACP_LEVEL_TWO = 2, + MF_OPM_ACP_LEVEL_THREE = 3, + MF_OPM_ACP_FORCE_ULONG = 0x7fffffff + } MF_OPM_ACP_PROTECTION_LEVEL; + +EXTERN_GUID( MFPROTECTIONATTRIBUTE_BEST_EFFORT, 0xc8e06331, 0x75f0, 0x4ec1, 0x8e, 0x77, 0x17, 0x57, 0x8f, 0x77, 0x3b, 0x46); + +EXTERN_GUID( MFPROTECTIONATTRIBUTE_FAIL_OVER, 0x8536abc5, 0x38f1, 0x4151, 0x9c, 0xce, 0xf5, 0x5d, 0x94, 0x12, 0x29, 0xac); + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WIN8) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_GUID(MFPROTECTION_GRAPHICS_TRANSFER_AES_ENCRYPTION, 0xc873de64, 0xd8a5, 0x49e6, 0x88, 0xbb, 0xfb, 0x96, 0x3f, 0xd3, 0xd4, 0xce); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +EXTERN_GUID( MFPROTECTIONATTRIBUTE_CONSTRICTVIDEO_IMAGESIZE, 0x8476fc, 0x4b58, 0x4d80, 0xa7, 0x90, 0xe7, 0x29, 0x76, 0x73, 0x16, 0x1d); +EXTERN_GUID( MFPROTECTIONATTRIBUTE_HDCP_SRM, 0x6f302107, 0x3477, 0x4468, 0x8a, 0x8, 0xee, 0xf9, 0xdb, 0x10, 0xe2, 0xf); + + +#define MAKE_MFPROTECTIONDATA_DISABLE(Disable) \ + ((DWORD)(Disable ? 0x00000001 : 0)) + +#define EXTRACT_MFPROTECTIONDATA_DISABLE_ON(Data) \ + (0 != ((Data) & 0x00000001)) + +#define EXTRACT_MFPROTECTIONDATA_DISABLE_RESERVED(Data) \ + (((DWORD)((Data) & 0xFFFFFFFE)) >> 1) + + +#define MAKE_MFPROTECTIONDATA_CONSTRICTAUDIO(Level) \ + ((DWORD)(Level)) + +#define EXTRACT_MFPROTECTIONDATA_CONSTRICTAUDIO_LEVEL(Data) \ + ((DWORD)((Data) & 0x000000FF)) + +#define EXTRACT_MFPROTECTIONDATA_CONSTRICTAUDIO_RESERVED(Data) \ + (((DWORD)((Data) & 0xFFFFFF00)) >> 8) + + +typedef enum _MFAudioConstriction +{ + MFaudioConstrictionOff = 0, + MFaudioConstriction48_16 = ( MFaudioConstrictionOff + 1 ) , + MFaudioConstriction44_16 = ( MFaudioConstriction48_16 + 1 ) , + MFaudioConstriction14_14 = ( MFaudioConstriction44_16 + 1 ) , + MFaudioConstrictionMute = ( MFaudioConstriction14_14 + 1 ) +} MFAudioConstriction; + + +#define MAKE_MFPROTECTIONDATA_TRUSTEDAUDIODRIVERS(TestCertificateEnable, DigitalOutputDisable, DrmLevel) \ + (((DWORD)((TestCertificateEnable) ? 0x00020000 : 0)) | \ + ((DWORD)((DigitalOutputDisable) ? 0x00010000 : 0)) | \ + ((DWORD)(DrmLevel))) + + +#if (WINVER >= _WIN32_WINNT_WIN7) +#define MAKE_MFPROTECTIONDATA_TRUSTEDAUDIODRIVERS2(TestCertificateEnable, DigitalOutputDisable, CopyOK, DrmLevel) \ + (((DWORD)((TestCertificateEnable) ? 0x00020000 : 0)) | \ + ((DWORD)((DigitalOutputDisable) ? 0x00010000 : 0)) | \ + ((DWORD)((CopyOK) ? 0x00040000 : 0)) | \ + ((DWORD)(DrmLevel))) + +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#define EXTRACT_MFPROTECTIONDATA_TRUSTEDAUDIODRIVERS_DRMLEVEL(Data) \ + ((DWORD)((Data) & 0x0000FFFF)) + +#define EXTRACT_MFPROTECTIONDATA_TRUSTEDAUDIODRIVERS_DIGITALOUTPUTDISABLE(Data) \ + (0 != ((Data) & 0x00010000)) + +#define EXTRACT_MFPROTECTIONDATA_TRUSTEDAUDIODRIVERS_TESTCERTIFICATEENABLE(Data) \ + (0 != ((Data) & 0x00020000)) + +#if (WINVER >= _WIN32_WINNT_WIN7) +#define EXTRACT_MFPROTECTIONDATA_TRUSTEDAUDIODRIVERS_COPYOK(Data) \ + (0 != ((Data) & 0x00040000)) + +#define EXTRACT_MFPROTECTIONDATA_TRUSTEDAUDIODRIVERS_RESERVED(Data) \ + (((DWORD)((Data) & 0xFFF80000)) >> 19) + +#else +#define EXTRACT_MFPROTECTIONDATA_TRUSTEDAUDIODRIVERS_RESERVED(Data) \ + (((DWORD)((Data) & 0xFFF80000)) >> 18) + +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0077_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0077_v0_0_s_ifspec; + +#ifndef __IMFSecureChannel_INTERFACE_DEFINED__ +#define __IMFSecureChannel_INTERFACE_DEFINED__ + +/* interface IMFSecureChannel */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSecureChannel; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("d0ae555d-3b12-4d97-b060-0990bc5aeb67") + IMFSecureChannel : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetCertificate( + /* [annotation][out] */ + _Outptr_result_bytebuffer_(*pcbCert) BYTE **ppCert, + /* [annotation][out] */ + _Out_ DWORD *pcbCert) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetupSession( + /* [annotation][in] */ + _In_reads_bytes_(cbSessionKey) BYTE *pbEncryptedSessionKey, + /* [in] */ DWORD cbSessionKey) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSecureChannelVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSecureChannel * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSecureChannel * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSecureChannel * This); + + HRESULT ( STDMETHODCALLTYPE *GetCertificate )( + IMFSecureChannel * This, + /* [annotation][out] */ + _Outptr_result_bytebuffer_(*pcbCert) BYTE **ppCert, + /* [annotation][out] */ + _Out_ DWORD *pcbCert); + + HRESULT ( STDMETHODCALLTYPE *SetupSession )( + IMFSecureChannel * This, + /* [annotation][in] */ + _In_reads_bytes_(cbSessionKey) BYTE *pbEncryptedSessionKey, + /* [in] */ DWORD cbSessionKey); + + END_INTERFACE + } IMFSecureChannelVtbl; + + interface IMFSecureChannel + { + CONST_VTBL struct IMFSecureChannelVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSecureChannel_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSecureChannel_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSecureChannel_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSecureChannel_GetCertificate(This,ppCert,pcbCert) \ + ( (This)->lpVtbl -> GetCertificate(This,ppCert,pcbCert) ) + +#define IMFSecureChannel_SetupSession(This,pbEncryptedSessionKey,cbSessionKey) \ + ( (This)->lpVtbl -> SetupSession(This,pbEncryptedSessionKey,cbSessionKey) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSecureChannel_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0078 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef +enum SAMPLE_PROTECTION_VERSION + { + SAMPLE_PROTECTION_VERSION_NO = 0, + SAMPLE_PROTECTION_VERSION_BASIC_LOKI = 1, + SAMPLE_PROTECTION_VERSION_SCATTER = 2, + SAMPLE_PROTECTION_VERSION_RC4 = 3, + SAMPLE_PROTECTION_VERSION_AES128CTR = 4 + } SAMPLE_PROTECTION_VERSION; + +EXTERN_GUID( MF_SampleProtectionSalt, 0x5403deee, 0xb9ee, 0x438f, 0xaa, 0x83, 0x38, 0x4, 0x99, 0x7e, 0x56, 0x9d); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0078_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0078_v0_0_s_ifspec; + +#ifndef __IMFSampleProtection_INTERFACE_DEFINED__ +#define __IMFSampleProtection_INTERFACE_DEFINED__ + +/* interface IMFSampleProtection */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSampleProtection; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8e36395f-c7b9-43c4-a54d-512b4af63c95") + IMFSampleProtection : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetInputProtectionVersion( + /* [annotation][out] */ + _Out_ DWORD *pdwVersion) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputProtectionVersion( + /* [annotation][out] */ + _Out_ DWORD *pdwVersion) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetProtectionCertificate( + /* [in] */ DWORD dwVersion, + /* [annotation][out] */ + _Outptr_result_bytebuffer_(*pcbCert) BYTE **ppCert, + /* [annotation][out] */ + _Out_ DWORD *pcbCert) = 0; + + virtual HRESULT STDMETHODCALLTYPE InitOutputProtection( + /* [in] */ DWORD dwVersion, + /* [in] */ DWORD dwOutputId, + /* [in] */ BYTE *pbCert, + /* [in] */ DWORD cbCert, + /* [out] */ BYTE **ppbSeed, + /* [out] */ DWORD *pcbSeed) = 0; + + virtual HRESULT STDMETHODCALLTYPE InitInputProtection( + /* [in] */ DWORD dwVersion, + /* [in] */ DWORD dwInputId, + /* [in] */ BYTE *pbSeed, + /* [in] */ DWORD cbSeed) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSampleProtectionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSampleProtection * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSampleProtection * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSampleProtection * This); + + HRESULT ( STDMETHODCALLTYPE *GetInputProtectionVersion )( + IMFSampleProtection * This, + /* [annotation][out] */ + _Out_ DWORD *pdwVersion); + + HRESULT ( STDMETHODCALLTYPE *GetOutputProtectionVersion )( + IMFSampleProtection * This, + /* [annotation][out] */ + _Out_ DWORD *pdwVersion); + + HRESULT ( STDMETHODCALLTYPE *GetProtectionCertificate )( + IMFSampleProtection * This, + /* [in] */ DWORD dwVersion, + /* [annotation][out] */ + _Outptr_result_bytebuffer_(*pcbCert) BYTE **ppCert, + /* [annotation][out] */ + _Out_ DWORD *pcbCert); + + HRESULT ( STDMETHODCALLTYPE *InitOutputProtection )( + IMFSampleProtection * This, + /* [in] */ DWORD dwVersion, + /* [in] */ DWORD dwOutputId, + /* [in] */ BYTE *pbCert, + /* [in] */ DWORD cbCert, + /* [out] */ BYTE **ppbSeed, + /* [out] */ DWORD *pcbSeed); + + HRESULT ( STDMETHODCALLTYPE *InitInputProtection )( + IMFSampleProtection * This, + /* [in] */ DWORD dwVersion, + /* [in] */ DWORD dwInputId, + /* [in] */ BYTE *pbSeed, + /* [in] */ DWORD cbSeed); + + END_INTERFACE + } IMFSampleProtectionVtbl; + + interface IMFSampleProtection + { + CONST_VTBL struct IMFSampleProtectionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSampleProtection_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSampleProtection_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSampleProtection_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSampleProtection_GetInputProtectionVersion(This,pdwVersion) \ + ( (This)->lpVtbl -> GetInputProtectionVersion(This,pdwVersion) ) + +#define IMFSampleProtection_GetOutputProtectionVersion(This,pdwVersion) \ + ( (This)->lpVtbl -> GetOutputProtectionVersion(This,pdwVersion) ) + +#define IMFSampleProtection_GetProtectionCertificate(This,dwVersion,ppCert,pcbCert) \ + ( (This)->lpVtbl -> GetProtectionCertificate(This,dwVersion,ppCert,pcbCert) ) + +#define IMFSampleProtection_InitOutputProtection(This,dwVersion,dwOutputId,pbCert,cbCert,ppbSeed,pcbSeed) \ + ( (This)->lpVtbl -> InitOutputProtection(This,dwVersion,dwOutputId,pbCert,cbCert,ppbSeed,pcbSeed) ) + +#define IMFSampleProtection_InitInputProtection(This,dwVersion,dwInputId,pbSeed,cbSeed) \ + ( (This)->lpVtbl -> InitInputProtection(This,dwVersion,dwInputId,pbSeed,cbSeed) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSampleProtection_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaSinkPreroll_INTERFACE_DEFINED__ +#define __IMFMediaSinkPreroll_INTERFACE_DEFINED__ + +/* interface IMFMediaSinkPreroll */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaSinkPreroll; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5dfd4b2a-7674-4110-a4e6-8a68fd5f3688") + IMFMediaSinkPreroll : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE NotifyPreroll( + /* [in] */ MFTIME hnsUpcomingStartTime) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaSinkPrerollVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaSinkPreroll * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaSinkPreroll * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaSinkPreroll * This); + + HRESULT ( STDMETHODCALLTYPE *NotifyPreroll )( + __RPC__in IMFMediaSinkPreroll * This, + /* [in] */ MFTIME hnsUpcomingStartTime); + + END_INTERFACE + } IMFMediaSinkPrerollVtbl; + + interface IMFMediaSinkPreroll + { + CONST_VTBL struct IMFMediaSinkPrerollVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaSinkPreroll_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaSinkPreroll_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaSinkPreroll_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaSinkPreroll_NotifyPreroll(This,hnsUpcomingStartTime) \ + ( (This)->lpVtbl -> NotifyPreroll(This,hnsUpcomingStartTime) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaSinkPreroll_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0080 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0080_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0080_v0_0_s_ifspec; + +#ifndef __IMFFinalizableMediaSink_INTERFACE_DEFINED__ +#define __IMFFinalizableMediaSink_INTERFACE_DEFINED__ + +/* interface IMFFinalizableMediaSink */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFFinalizableMediaSink; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("EAECB74A-9A50-42ce-9541-6A7F57AA4AD7") + IMFFinalizableMediaSink : public IMFMediaSink + { + public: + virtual HRESULT STDMETHODCALLTYPE BeginFinalize( + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndFinalize( + /* [in] */ IMFAsyncResult *pResult) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFFinalizableMediaSinkVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFFinalizableMediaSink * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFFinalizableMediaSink * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFFinalizableMediaSink * This); + + HRESULT ( STDMETHODCALLTYPE *GetCharacteristics )( + IMFFinalizableMediaSink * This, + /* [out] */ DWORD *pdwCharacteristics); + + HRESULT ( STDMETHODCALLTYPE *AddStreamSink )( + IMFFinalizableMediaSink * This, + /* [in] */ DWORD dwStreamSinkIdentifier, + /* [in] */ IMFMediaType *pMediaType, + /* [out] */ IMFStreamSink **ppStreamSink); + + HRESULT ( STDMETHODCALLTYPE *RemoveStreamSink )( + IMFFinalizableMediaSink * This, + /* [in] */ DWORD dwStreamSinkIdentifier); + + HRESULT ( STDMETHODCALLTYPE *GetStreamSinkCount )( + IMFFinalizableMediaSink * This, + /* [out] */ DWORD *pcStreamSinkCount); + + HRESULT ( STDMETHODCALLTYPE *GetStreamSinkByIndex )( + IMFFinalizableMediaSink * This, + /* [in] */ DWORD dwIndex, + /* [out] */ IMFStreamSink **ppStreamSink); + + HRESULT ( STDMETHODCALLTYPE *GetStreamSinkById )( + IMFFinalizableMediaSink * This, + /* [in] */ DWORD dwStreamSinkIdentifier, + /* [out] */ IMFStreamSink **ppStreamSink); + + HRESULT ( STDMETHODCALLTYPE *SetPresentationClock )( + IMFFinalizableMediaSink * This, + /* [in] */ IMFPresentationClock *pPresentationClock); + + HRESULT ( STDMETHODCALLTYPE *GetPresentationClock )( + IMFFinalizableMediaSink * This, + /* [out] */ IMFPresentationClock **ppPresentationClock); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + IMFFinalizableMediaSink * This); + + HRESULT ( STDMETHODCALLTYPE *BeginFinalize )( + IMFFinalizableMediaSink * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + HRESULT ( STDMETHODCALLTYPE *EndFinalize )( + IMFFinalizableMediaSink * This, + /* [in] */ IMFAsyncResult *pResult); + + END_INTERFACE + } IMFFinalizableMediaSinkVtbl; + + interface IMFFinalizableMediaSink + { + CONST_VTBL struct IMFFinalizableMediaSinkVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFFinalizableMediaSink_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFFinalizableMediaSink_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFFinalizableMediaSink_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFFinalizableMediaSink_GetCharacteristics(This,pdwCharacteristics) \ + ( (This)->lpVtbl -> GetCharacteristics(This,pdwCharacteristics) ) + +#define IMFFinalizableMediaSink_AddStreamSink(This,dwStreamSinkIdentifier,pMediaType,ppStreamSink) \ + ( (This)->lpVtbl -> AddStreamSink(This,dwStreamSinkIdentifier,pMediaType,ppStreamSink) ) + +#define IMFFinalizableMediaSink_RemoveStreamSink(This,dwStreamSinkIdentifier) \ + ( (This)->lpVtbl -> RemoveStreamSink(This,dwStreamSinkIdentifier) ) + +#define IMFFinalizableMediaSink_GetStreamSinkCount(This,pcStreamSinkCount) \ + ( (This)->lpVtbl -> GetStreamSinkCount(This,pcStreamSinkCount) ) + +#define IMFFinalizableMediaSink_GetStreamSinkByIndex(This,dwIndex,ppStreamSink) \ + ( (This)->lpVtbl -> GetStreamSinkByIndex(This,dwIndex,ppStreamSink) ) + +#define IMFFinalizableMediaSink_GetStreamSinkById(This,dwStreamSinkIdentifier,ppStreamSink) \ + ( (This)->lpVtbl -> GetStreamSinkById(This,dwStreamSinkIdentifier,ppStreamSink) ) + +#define IMFFinalizableMediaSink_SetPresentationClock(This,pPresentationClock) \ + ( (This)->lpVtbl -> SetPresentationClock(This,pPresentationClock) ) + +#define IMFFinalizableMediaSink_GetPresentationClock(This,ppPresentationClock) \ + ( (This)->lpVtbl -> GetPresentationClock(This,ppPresentationClock) ) + +#define IMFFinalizableMediaSink_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + + +#define IMFFinalizableMediaSink_BeginFinalize(This,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginFinalize(This,pCallback,punkState) ) + +#define IMFFinalizableMediaSink_EndFinalize(This,pResult) \ + ( (This)->lpVtbl -> EndFinalize(This,pResult) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFFinalizableMediaSink_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0081 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0081_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0081_v0_0_s_ifspec; + +#ifndef __IMFStreamingSinkConfig_INTERFACE_DEFINED__ +#define __IMFStreamingSinkConfig_INTERFACE_DEFINED__ + +/* interface IMFStreamingSinkConfig */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFStreamingSinkConfig; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9db7aa41-3cc5-40d4-8509-555804ad34cc") + IMFStreamingSinkConfig : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE StartStreaming( + /* [in] */ BOOL fSeekOffsetIsByteOffset, + /* [in] */ QWORD qwSeekOffset) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFStreamingSinkConfigVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFStreamingSinkConfig * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFStreamingSinkConfig * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFStreamingSinkConfig * This); + + HRESULT ( STDMETHODCALLTYPE *StartStreaming )( + __RPC__in IMFStreamingSinkConfig * This, + /* [in] */ BOOL fSeekOffsetIsByteOffset, + /* [in] */ QWORD qwSeekOffset); + + END_INTERFACE + } IMFStreamingSinkConfigVtbl; + + interface IMFStreamingSinkConfig + { + CONST_VTBL struct IMFStreamingSinkConfigVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFStreamingSinkConfig_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFStreamingSinkConfig_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFStreamingSinkConfig_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFStreamingSinkConfig_StartStreaming(This,fSeekOffsetIsByteOffset,qwSeekOffset) \ + ( (This)->lpVtbl -> StartStreaming(This,fSeekOffsetIsByteOffset,qwSeekOffset) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFStreamingSinkConfig_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0082 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0082_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0082_v0_0_s_ifspec; + +#ifndef __IMFRemoteProxy_INTERFACE_DEFINED__ +#define __IMFRemoteProxy_INTERFACE_DEFINED__ + +/* interface IMFRemoteProxy */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFRemoteProxy; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("994e23ad-1cc2-493c-b9fa-46f1cb040fa4") + IMFRemoteProxy : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetRemoteObject( + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _Outptr_ void **ppv) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRemoteHost( + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _Outptr_ void **ppv) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFRemoteProxyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFRemoteProxy * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFRemoteProxy * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFRemoteProxy * This); + + HRESULT ( STDMETHODCALLTYPE *GetRemoteObject )( + IMFRemoteProxy * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _Outptr_ void **ppv); + + HRESULT ( STDMETHODCALLTYPE *GetRemoteHost )( + IMFRemoteProxy * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _Outptr_ void **ppv); + + END_INTERFACE + } IMFRemoteProxyVtbl; + + interface IMFRemoteProxy + { + CONST_VTBL struct IMFRemoteProxyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFRemoteProxy_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFRemoteProxy_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFRemoteProxy_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFRemoteProxy_GetRemoteObject(This,riid,ppv) \ + ( (This)->lpVtbl -> GetRemoteObject(This,riid,ppv) ) + +#define IMFRemoteProxy_GetRemoteHost(This,riid,ppv) \ + ( (This)->lpVtbl -> GetRemoteHost(This,riid,ppv) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFRemoteProxy_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0083 */ +/* [local] */ + +EXTERN_GUID( MF_REMOTE_PROXY, 0x2f00c90e, 0xd2cf, 0x4278, 0x8b, 0x6a, 0xd0, 0x77, 0xfa, 0xc3, 0xa2, 0x5f); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0083_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0083_v0_0_s_ifspec; + +#ifndef __IMFObjectReferenceStream_INTERFACE_DEFINED__ +#define __IMFObjectReferenceStream_INTERFACE_DEFINED__ + +/* interface IMFObjectReferenceStream */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFObjectReferenceStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("09EF5BE3-C8A7-469e-8B70-73BF25BB193F") + IMFObjectReferenceStream : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SaveReference( + /* [in] */ REFIID riid, + /* [in] */ IUnknown *pUnk) = 0; + + virtual HRESULT STDMETHODCALLTYPE LoadReference( + /* [in] */ REFIID riid, + /* [out] */ void **ppv) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFObjectReferenceStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFObjectReferenceStream * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFObjectReferenceStream * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFObjectReferenceStream * This); + + HRESULT ( STDMETHODCALLTYPE *SaveReference )( + IMFObjectReferenceStream * This, + /* [in] */ REFIID riid, + /* [in] */ IUnknown *pUnk); + + HRESULT ( STDMETHODCALLTYPE *LoadReference )( + IMFObjectReferenceStream * This, + /* [in] */ REFIID riid, + /* [out] */ void **ppv); + + END_INTERFACE + } IMFObjectReferenceStreamVtbl; + + interface IMFObjectReferenceStream + { + CONST_VTBL struct IMFObjectReferenceStreamVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFObjectReferenceStream_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFObjectReferenceStream_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFObjectReferenceStream_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFObjectReferenceStream_SaveReference(This,riid,pUnk) \ + ( (This)->lpVtbl -> SaveReference(This,riid,pUnk) ) + +#define IMFObjectReferenceStream_LoadReference(This,riid,ppv) \ + ( (This)->lpVtbl -> LoadReference(This,riid,ppv) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFObjectReferenceStream_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0084 */ +/* [local] */ + +EXTERN_GUID( CLSID_CreateMediaExtensionObject, 0xef65a54d, 0x0788, 0x45b8, 0x8b, 0x14, 0xbc, 0x0f, 0x6a, 0x6b, 0x51, 0x37); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0084_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0084_v0_0_s_ifspec; + +#ifndef __IMFPMPHost_INTERFACE_DEFINED__ +#define __IMFPMPHost_INTERFACE_DEFINED__ + +/* interface IMFPMPHost */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFPMPHost; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F70CA1A9-FDC7-4782-B994-ADFFB1C98606") + IMFPMPHost : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE LockProcess( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnlockProcess( void) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE CreateObjectByCLSID( + /* [in] */ REFCLSID clsid, + /* [unique][in] */ IStream *pStream, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppv) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFPMPHostVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFPMPHost * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFPMPHost * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFPMPHost * This); + + HRESULT ( STDMETHODCALLTYPE *LockProcess )( + __RPC__in IMFPMPHost * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockProcess )( + __RPC__in IMFPMPHost * This); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *CreateObjectByCLSID )( + IMFPMPHost * This, + /* [in] */ REFCLSID clsid, + /* [unique][in] */ IStream *pStream, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppv); + + END_INTERFACE + } IMFPMPHostVtbl; + + interface IMFPMPHost + { + CONST_VTBL struct IMFPMPHostVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFPMPHost_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFPMPHost_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFPMPHost_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFPMPHost_LockProcess(This) \ + ( (This)->lpVtbl -> LockProcess(This) ) + +#define IMFPMPHost_UnlockProcess(This) \ + ( (This)->lpVtbl -> UnlockProcess(This) ) + +#define IMFPMPHost_CreateObjectByCLSID(This,clsid,pStream,riid,ppv) \ + ( (This)->lpVtbl -> CreateObjectByCLSID(This,clsid,pStream,riid,ppv) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFPMPHost_RemoteCreateObjectByCLSID_Proxy( + __RPC__in IMFPMPHost * This, + /* [in] */ __RPC__in REFCLSID clsid, + /* [size_is][unique][in] */ __RPC__in_ecount_full_opt(cbData) BYTE *pbData, + /* [in] */ DWORD cbData, + /* [in] */ __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt void **ppv); + + +void __RPC_STUB IMFPMPHost_RemoteCreateObjectByCLSID_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMFPMPHost_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0085 */ +/* [local] */ + +#if (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_C const GUID MF_PMP_SERVICE; +#endif // (WINVER >= _WIN32_WINNT_WIN7) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0085_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0085_v0_0_s_ifspec; + +#ifndef __IMFPMPClient_INTERFACE_DEFINED__ +#define __IMFPMPClient_INTERFACE_DEFINED__ + +/* interface IMFPMPClient */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFPMPClient; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6C4E655D-EAD8-4421-B6B9-54DCDBBDF820") + IMFPMPClient : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetPMPHost( + /* [in] */ IMFPMPHost *pPMPHost) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFPMPClientVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFPMPClient * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFPMPClient * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFPMPClient * This); + + HRESULT ( STDMETHODCALLTYPE *SetPMPHost )( + IMFPMPClient * This, + /* [in] */ IMFPMPHost *pPMPHost); + + END_INTERFACE + } IMFPMPClientVtbl; + + interface IMFPMPClient + { + CONST_VTBL struct IMFPMPClientVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFPMPClient_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFPMPClient_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFPMPClient_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFPMPClient_SetPMPHost(This,pPMPHost) \ + ( (This)->lpVtbl -> SetPMPHost(This,pPMPHost) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFPMPClient_INTERFACE_DEFINED__ */ + + +#ifndef __IMFPMPServer_INTERFACE_DEFINED__ +#define __IMFPMPServer_INTERFACE_DEFINED__ + +/* interface IMFPMPServer */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFPMPServer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("994e23af-1cc2-493c-b9fa-46f1cb040fa4") + IMFPMPServer : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE LockProcess( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnlockProcess( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateObjectByCLSID( + /* [in] */ __RPC__in REFCLSID clsid, + /* [in] */ __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt void **ppObject) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFPMPServerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFPMPServer * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFPMPServer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFPMPServer * This); + + HRESULT ( STDMETHODCALLTYPE *LockProcess )( + __RPC__in IMFPMPServer * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockProcess )( + __RPC__in IMFPMPServer * This); + + HRESULT ( STDMETHODCALLTYPE *CreateObjectByCLSID )( + __RPC__in IMFPMPServer * This, + /* [in] */ __RPC__in REFCLSID clsid, + /* [in] */ __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt void **ppObject); + + END_INTERFACE + } IMFPMPServerVtbl; + + interface IMFPMPServer + { + CONST_VTBL struct IMFPMPServerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFPMPServer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFPMPServer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFPMPServer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFPMPServer_LockProcess(This) \ + ( (This)->lpVtbl -> LockProcess(This) ) + +#define IMFPMPServer_UnlockProcess(This) \ + ( (This)->lpVtbl -> UnlockProcess(This) ) + +#define IMFPMPServer_CreateObjectByCLSID(This,clsid,riid,ppObject) \ + ( (This)->lpVtbl -> CreateObjectByCLSID(This,clsid,riid,ppObject) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFPMPServer_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0087 */ +/* [local] */ + +STDAPI MFCreatePMPServer( + DWORD dwCreationFlags, + _Outptr_ IMFPMPServer** ppPMPServer + ); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0087_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0087_v0_0_s_ifspec; + +#ifndef __IMFRemoteDesktopPlugin_INTERFACE_DEFINED__ +#define __IMFRemoteDesktopPlugin_INTERFACE_DEFINED__ + +/* interface IMFRemoteDesktopPlugin */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFRemoteDesktopPlugin; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("1cde6309-cae0-4940-907e-c1ec9c3d1d4a") + IMFRemoteDesktopPlugin : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE UpdateTopology( + /* [out][in] */ IMFTopology *pTopology) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFRemoteDesktopPluginVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFRemoteDesktopPlugin * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFRemoteDesktopPlugin * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFRemoteDesktopPlugin * This); + + HRESULT ( STDMETHODCALLTYPE *UpdateTopology )( + IMFRemoteDesktopPlugin * This, + /* [out][in] */ IMFTopology *pTopology); + + END_INTERFACE + } IMFRemoteDesktopPluginVtbl; + + interface IMFRemoteDesktopPlugin + { + CONST_VTBL struct IMFRemoteDesktopPluginVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFRemoteDesktopPlugin_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFRemoteDesktopPlugin_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFRemoteDesktopPlugin_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFRemoteDesktopPlugin_UpdateTopology(This,pTopology) \ + ( (This)->lpVtbl -> UpdateTopology(This,pTopology) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFRemoteDesktopPlugin_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0088 */ +/* [local] */ + +STDAPI MFCreateRemoteDesktopPlugin( + _Outptr_ IMFRemoteDesktopPlugin** ppPlugin ); +EXTERN_C HRESULT STDAPICALLTYPE CreateNamedPropertyStore( + _Outptr_ INamedPropertyStore **ppStore + ); + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0088_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0088_v0_0_s_ifspec; + +#ifndef __IMFSAMIStyle_INTERFACE_DEFINED__ +#define __IMFSAMIStyle_INTERFACE_DEFINED__ + +/* interface IMFSAMIStyle */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSAMIStyle; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("A7E025DD-5303-4a62-89D6-E747E1EFAC73") + IMFSAMIStyle : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetStyleCount( + /* [annotation][out] */ + _Out_ DWORD *pdwCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStyles( + /* [annotation][out] */ + _Out_ PROPVARIANT *pPropVarStyleArray) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSelectedStyle( + /* [annotation][in] */ + _In_ LPCWSTR pwszStyle) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSelectedStyle( + /* [annotation][out] */ + _Outptr_ LPWSTR *ppwszStyle) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSAMIStyleVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSAMIStyle * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSAMIStyle * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSAMIStyle * This); + + HRESULT ( STDMETHODCALLTYPE *GetStyleCount )( + IMFSAMIStyle * This, + /* [annotation][out] */ + _Out_ DWORD *pdwCount); + + HRESULT ( STDMETHODCALLTYPE *GetStyles )( + IMFSAMIStyle * This, + /* [annotation][out] */ + _Out_ PROPVARIANT *pPropVarStyleArray); + + HRESULT ( STDMETHODCALLTYPE *SetSelectedStyle )( + IMFSAMIStyle * This, + /* [annotation][in] */ + _In_ LPCWSTR pwszStyle); + + HRESULT ( STDMETHODCALLTYPE *GetSelectedStyle )( + IMFSAMIStyle * This, + /* [annotation][out] */ + _Outptr_ LPWSTR *ppwszStyle); + + END_INTERFACE + } IMFSAMIStyleVtbl; + + interface IMFSAMIStyle + { + CONST_VTBL struct IMFSAMIStyleVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSAMIStyle_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSAMIStyle_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSAMIStyle_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSAMIStyle_GetStyleCount(This,pdwCount) \ + ( (This)->lpVtbl -> GetStyleCount(This,pdwCount) ) + +#define IMFSAMIStyle_GetStyles(This,pPropVarStyleArray) \ + ( (This)->lpVtbl -> GetStyles(This,pPropVarStyleArray) ) + +#define IMFSAMIStyle_SetSelectedStyle(This,pwszStyle) \ + ( (This)->lpVtbl -> SetSelectedStyle(This,pwszStyle) ) + +#define IMFSAMIStyle_GetSelectedStyle(This,ppwszStyle) \ + ( (This)->lpVtbl -> GetSelectedStyle(This,ppwszStyle) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSAMIStyle_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0089 */ +/* [local] */ + +EXTERN_GUID( MF_SAMI_SERVICE, 0x49a89ae7, 0xb4d9, 0x4ef2, 0xaa, 0x5c, 0xf6, 0x5a, 0x3e, 0x5, 0xae, 0x4e ); +EXTERN_GUID( MF_PD_SAMI_STYLELIST, 0xe0b73c7f, 0x486d, 0x484e, 0x98, 0x72, 0x4d, 0xe5, 0x19, 0x2a, 0x7b, 0xf8 ); +EXTERN_GUID( MF_SD_SAMI_LANGUAGE, 0x36fcb98a, 0x6cd0, 0x44cb, 0xac, 0xb9, 0xa8, 0xf5, 0x60, 0xd, 0xd0, 0xbb ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +STDAPI MFCreateSampleCopierMFT(_Outptr_ IMFTransform** ppCopierMFT); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0089_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0089_v0_0_s_ifspec; + +#ifndef __IMFTranscodeProfile_INTERFACE_DEFINED__ +#define __IMFTranscodeProfile_INTERFACE_DEFINED__ + +/* interface IMFTranscodeProfile */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFTranscodeProfile; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("4ADFDBA3-7AB0-4953-A62B-461E7FF3DA1E") + IMFTranscodeProfile : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetAudioAttributes( + /* [annotation][in] */ + _In_opt_ IMFAttributes *pAttrs) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAudioAttributes( + /* [annotation][out] */ + _Outptr_result_maybenull_ IMFAttributes **ppAttrs) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVideoAttributes( + /* [annotation][in] */ + _In_opt_ IMFAttributes *pAttrs) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVideoAttributes( + /* [annotation][out] */ + _Outptr_result_maybenull_ IMFAttributes **ppAttrs) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetContainerAttributes( + /* [annotation][in] */ + _In_opt_ IMFAttributes *pAttrs) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetContainerAttributes( + /* [annotation][out] */ + _Outptr_result_maybenull_ IMFAttributes **ppAttrs) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTranscodeProfileVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTranscodeProfile * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTranscodeProfile * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTranscodeProfile * This); + + HRESULT ( STDMETHODCALLTYPE *SetAudioAttributes )( + IMFTranscodeProfile * This, + /* [annotation][in] */ + _In_opt_ IMFAttributes *pAttrs); + + HRESULT ( STDMETHODCALLTYPE *GetAudioAttributes )( + IMFTranscodeProfile * This, + /* [annotation][out] */ + _Outptr_result_maybenull_ IMFAttributes **ppAttrs); + + HRESULT ( STDMETHODCALLTYPE *SetVideoAttributes )( + IMFTranscodeProfile * This, + /* [annotation][in] */ + _In_opt_ IMFAttributes *pAttrs); + + HRESULT ( STDMETHODCALLTYPE *GetVideoAttributes )( + IMFTranscodeProfile * This, + /* [annotation][out] */ + _Outptr_result_maybenull_ IMFAttributes **ppAttrs); + + HRESULT ( STDMETHODCALLTYPE *SetContainerAttributes )( + IMFTranscodeProfile * This, + /* [annotation][in] */ + _In_opt_ IMFAttributes *pAttrs); + + HRESULT ( STDMETHODCALLTYPE *GetContainerAttributes )( + IMFTranscodeProfile * This, + /* [annotation][out] */ + _Outptr_result_maybenull_ IMFAttributes **ppAttrs); + + END_INTERFACE + } IMFTranscodeProfileVtbl; + + interface IMFTranscodeProfile + { + CONST_VTBL struct IMFTranscodeProfileVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTranscodeProfile_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTranscodeProfile_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTranscodeProfile_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTranscodeProfile_SetAudioAttributes(This,pAttrs) \ + ( (This)->lpVtbl -> SetAudioAttributes(This,pAttrs) ) + +#define IMFTranscodeProfile_GetAudioAttributes(This,ppAttrs) \ + ( (This)->lpVtbl -> GetAudioAttributes(This,ppAttrs) ) + +#define IMFTranscodeProfile_SetVideoAttributes(This,pAttrs) \ + ( (This)->lpVtbl -> SetVideoAttributes(This,pAttrs) ) + +#define IMFTranscodeProfile_GetVideoAttributes(This,ppAttrs) \ + ( (This)->lpVtbl -> GetVideoAttributes(This,ppAttrs) ) + +#define IMFTranscodeProfile_SetContainerAttributes(This,pAttrs) \ + ( (This)->lpVtbl -> SetContainerAttributes(This,pAttrs) ) + +#define IMFTranscodeProfile_GetContainerAttributes(This,ppAttrs) \ + ( (This)->lpVtbl -> GetContainerAttributes(This,ppAttrs) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTranscodeProfile_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0090 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_GUID( MF_TRANSCODE_CONTAINERTYPE, 0x150ff23f, 0x4abc, 0x478b, 0xac, 0x4f, 0xe1, 0x91, 0x6f, 0xba, 0x1c, 0xca ); +EXTERN_GUID( MFTranscodeContainerType_ASF, 0x430f6f6e, 0xb6bf, 0x4fc1, 0xa0, 0xbd, 0x9e, 0xe4, 0x6e, 0xee, 0x2a, 0xfb ); +EXTERN_GUID( MFTranscodeContainerType_MPEG4, 0xdc6cd05d, 0xb9d0, 0x40ef, 0xbd, 0x35, 0xfa, 0x62, 0x2c, 0x1a, 0xb2, 0x8a ); +EXTERN_GUID( MFTranscodeContainerType_MP3, 0xe438b912, 0x83f1, 0x4de6, 0x9e, 0x3a, 0x9f, 0xfb, 0xc6, 0xdd, 0x24, 0xd1 ); +EXTERN_GUID( MFTranscodeContainerType_FLAC, 0x31344aa3, 0x05a9, 0x42b5, 0x90, 0x1b, 0x8e, 0x9d, 0x42, 0x57, 0xf7, 0x5e ); +EXTERN_GUID( MFTranscodeContainerType_3GP, 0x34c50167, 0x4472, 0x4f34, 0x9e, 0xa0, 0xc4, 0x9f, 0xba, 0xcf, 0x03, 0x7d ); +EXTERN_GUID( MFTranscodeContainerType_AC3, 0x6d8d91c3, 0x8c91, 0x4ed1, 0x87, 0x42, 0x8c, 0x34, 0x7d, 0x5b, 0x44, 0xd0 ); +EXTERN_GUID( MFTranscodeContainerType_ADTS, 0x132fd27d, 0x0f02, 0x43de, 0xa3, 0x01, 0x38, 0xfb, 0xbb, 0xb3, 0x83, 0x4e ); +EXTERN_GUID( MFTranscodeContainerType_MPEG2, 0xbfc2dbf9, 0x7bb4, 0x4f8f, 0xaf, 0xde, 0xe1, 0x12, 0xc4, 0x4b, 0xa8, 0x82 ); +EXTERN_GUID( MFTranscodeContainerType_WAVE, 0x64c3453c, 0x0f26, 0x4741, 0xbe, 0x63, 0x87, 0xbd, 0xf8, 0xbb, 0x93, 0x5b ); +EXTERN_GUID( MFTranscodeContainerType_AVI, 0x7edfe8af, 0x402f, 0x4d76, 0xa3, 0x3c, 0x61, 0x9f, 0xd1, 0x57, 0xd0, 0xf1 ); +#if (WINVER >= _WIN32_WINNT_WIN8) +EXTERN_GUID( MFTranscodeContainerType_FMPEG4, 0x9ba876f1, 0x419f, 0x4b77, 0xa1, 0xe0, 0x35, 0x95, 0x9d, 0x9d, 0x40, 0x4 ); +#endif // (WINVER >= _WIN32_WINNT_WIN8) +EXTERN_GUID( MFTranscodeContainerType_AMR, 0x25d5ad3, 0x621a, 0x475b, 0x96, 0x4d, 0x66, 0xb1, 0xc8, 0x24, 0xf0, 0x79 ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +EXTERN_GUID( MF_TRANSCODE_SKIP_METADATA_TRANSFER, 0x4e4469ef, 0xb571, 0x4959, 0x8f, 0x83, 0x3d, 0xcf, 0xba, 0x33, 0xa3, 0x93 ); +EXTERN_GUID( MF_TRANSCODE_TOPOLOGYMODE, 0x3e3df610, 0x394a, 0x40b2, 0x9d, 0xea, 0x3b, 0xab, 0x65, 0xb, 0xeb, 0xf2 ); +typedef +enum _MF_TRANSCODE_TOPOLOGYMODE_FLAGS + { + MF_TRANSCODE_TOPOLOGYMODE_SOFTWARE_ONLY = 0, + MF_TRANSCODE_TOPOLOGYMODE_HARDWARE_ALLOWED = 1 + } MF_TRANSCODE_TOPOLOGYMODE_FLAGS; + +EXTERN_GUID( MF_TRANSCODE_ADJUST_PROFILE, 0x9c37c21b, 0x60f, 0x487c, 0xa6, 0x90, 0x80, 0xd7, 0xf5, 0xd, 0x1c, 0x72 ); +typedef +enum _MF_TRANSCODE_ADJUST_PROFILE_FLAGS + { + MF_TRANSCODE_ADJUST_PROFILE_DEFAULT = 0, + MF_TRANSCODE_ADJUST_PROFILE_USE_SOURCE_ATTRIBUTES = 1 + } MF_TRANSCODE_ADJUST_PROFILE_FLAGS; + +EXTERN_GUID( MF_TRANSCODE_ENCODINGPROFILE, 0x6947787c, 0xf508, 0x4ea9, 0xb1, 0xe9, 0xa1, 0xfe, 0x3a, 0x49, 0xfb, 0xc9 ); +EXTERN_GUID( MF_TRANSCODE_QUALITYVSSPEED, 0x98332df8, 0x03cd, 0x476b, 0x89, 0xfa, 0x3f, 0x9e, 0x44, 0x2d, 0xec, 0x9f ); +EXTERN_GUID( MF_TRANSCODE_DONOT_INSERT_ENCODER, 0xf45aa7ce, 0xab24, 0x4012, 0xa1, 0x1b, 0xdc, 0x82, 0x20, 0x20, 0x14, 0x10 ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef +enum _MF_VIDEO_PROCESSOR_ALGORITHM_TYPE + { + MF_VIDEO_PROCESSOR_ALGORITHM_DEFAULT = 0, + MF_VIDEO_PROCESSOR_ALGORITHM_MRF_CRF_444 = 1 + } MF_VIDEO_PROCESSOR_ALGORITHM_TYPE; + +EXTERN_GUID( MF_VIDEO_PROCESSOR_ALGORITHM, 0x4a0a1e1f, 0x272c, 0x4fb6, 0x9e, 0xb1, 0xdb, 0x33, 0xc, 0xbc, 0x97, 0xca); +EXTERN_GUID( MF_XVP_DISABLE_FRC, 0x2c0afa19, 0x7a97, 0x4d5a, 0x9e, 0xe8, 0x16, 0xd4, 0xfc, 0x51, 0x8d, 0x8c ); +#if (WINVER >= _WIN32_WINNT_WINBLUE) +EXTERN_GUID( MF_XVP_CALLER_ALLOCATES_OUTPUT, 0x4a2cabc, 0xcab, 0x40b1, 0xa1, 0xb9, 0x75, 0xbc, 0x36, 0x58, 0xf0, 0x0 ); +#endif // (WINVER >= _WIN32_WINNT_WINBLUE) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +#if (WINVER >= _WIN32_WINNT_WINBLUE) +#if (WINVER < _WIN32_WINNT_WINTHRESHOLD) +EXTERN_GUID(CLSID_VideoProcessorMFT, 0x88753b26, 0x5b24, 0x49bd, 0xb2, 0xe7, 0xc, 0x44, 0x5c, 0x78, 0xc9, 0x82); +#endif // (WINVER < _WIN32_WINNT_WINTHRESHOLD) +#endif // (WINVER >= _WIN32_WINNT_WINBLUE) +STDAPI MFCreateTranscodeProfile( + _Outptr_ IMFTranscodeProfile** ppTranscodeProfile + ); +STDAPI MFCreateTranscodeTopology( + _In_ IMFMediaSource* pSrc, + _In_ LPCWSTR pwszOutputFilePath, + _In_ IMFTranscodeProfile* pProfile, + _Outptr_ IMFTopology** ppTranscodeTopo + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WIN8) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +STDAPI MFCreateTranscodeTopologyFromByteStream( + _In_ IMFMediaSource* pSrc, + _In_ IMFByteStream* pOutputStream, + _In_ IMFTranscodeProfile* pProfile, + _Out_ IMFTopology** ppTranscodeTopo + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +STDAPI MFTranscodeGetAudioOutputAvailableTypes( + _In_ REFGUID guidSubType, + _In_ DWORD dwMFTFlags, + _In_opt_ IMFAttributes* pCodecConfig, + _Outptr_ IMFCollection** ppAvailableTypes ); +typedef struct _MF_TRANSCODE_SINK_INFO + { + DWORD dwVideoStreamID; + IMFMediaType *pVideoMediaType; + DWORD dwAudioStreamID; + IMFMediaType *pAudioMediaType; + } MF_TRANSCODE_SINK_INFO; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0090_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0090_v0_0_s_ifspec; + +#ifndef __IMFTranscodeSinkInfoProvider_INTERFACE_DEFINED__ +#define __IMFTranscodeSinkInfoProvider_INTERFACE_DEFINED__ + +/* interface IMFTranscodeSinkInfoProvider */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFTranscodeSinkInfoProvider; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8CFFCD2E-5A03-4a3a-AFF7-EDCD107C620E") + IMFTranscodeSinkInfoProvider : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetOutputFile( + /* [annotation][in] */ + _In_ LPCWSTR pwszFileName) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetOutputByteStream( + /* [annotation][in] */ + _In_ IMFActivate *pByteStreamActivate) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetProfile( + /* [annotation][in] */ + _In_ IMFTranscodeProfile *pProfile) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSinkInfo( + /* [annotation][out] */ + _Out_ MF_TRANSCODE_SINK_INFO *pSinkInfo) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTranscodeSinkInfoProviderVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTranscodeSinkInfoProvider * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTranscodeSinkInfoProvider * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTranscodeSinkInfoProvider * This); + + HRESULT ( STDMETHODCALLTYPE *SetOutputFile )( + IMFTranscodeSinkInfoProvider * This, + /* [annotation][in] */ + _In_ LPCWSTR pwszFileName); + + HRESULT ( STDMETHODCALLTYPE *SetOutputByteStream )( + IMFTranscodeSinkInfoProvider * This, + /* [annotation][in] */ + _In_ IMFActivate *pByteStreamActivate); + + HRESULT ( STDMETHODCALLTYPE *SetProfile )( + IMFTranscodeSinkInfoProvider * This, + /* [annotation][in] */ + _In_ IMFTranscodeProfile *pProfile); + + HRESULT ( STDMETHODCALLTYPE *GetSinkInfo )( + IMFTranscodeSinkInfoProvider * This, + /* [annotation][out] */ + _Out_ MF_TRANSCODE_SINK_INFO *pSinkInfo); + + END_INTERFACE + } IMFTranscodeSinkInfoProviderVtbl; + + interface IMFTranscodeSinkInfoProvider + { + CONST_VTBL struct IMFTranscodeSinkInfoProviderVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTranscodeSinkInfoProvider_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTranscodeSinkInfoProvider_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTranscodeSinkInfoProvider_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTranscodeSinkInfoProvider_SetOutputFile(This,pwszFileName) \ + ( (This)->lpVtbl -> SetOutputFile(This,pwszFileName) ) + +#define IMFTranscodeSinkInfoProvider_SetOutputByteStream(This,pByteStreamActivate) \ + ( (This)->lpVtbl -> SetOutputByteStream(This,pByteStreamActivate) ) + +#define IMFTranscodeSinkInfoProvider_SetProfile(This,pProfile) \ + ( (This)->lpVtbl -> SetProfile(This,pProfile) ) + +#define IMFTranscodeSinkInfoProvider_GetSinkInfo(This,pSinkInfo) \ + ( (This)->lpVtbl -> GetSinkInfo(This,pSinkInfo) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTranscodeSinkInfoProvider_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0091 */ +/* [local] */ + + STDAPI MFCreateTranscodeSinkActivate( + _Outptr_ IMFActivate** ppActivate ); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0091_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0091_v0_0_s_ifspec; + +#ifndef __IMFFieldOfUseMFTUnlock_INTERFACE_DEFINED__ +#define __IMFFieldOfUseMFTUnlock_INTERFACE_DEFINED__ + +/* interface IMFFieldOfUseMFTUnlock */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFFieldOfUseMFTUnlock; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("508E71D3-EC66-4fc3-8775-B4B9ED6BA847") + IMFFieldOfUseMFTUnlock : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Unlock( + /* [in] */ __RPC__in_opt IUnknown *pUnkMFT) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFFieldOfUseMFTUnlockVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFFieldOfUseMFTUnlock * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFFieldOfUseMFTUnlock * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFFieldOfUseMFTUnlock * This); + + HRESULT ( STDMETHODCALLTYPE *Unlock )( + __RPC__in IMFFieldOfUseMFTUnlock * This, + /* [in] */ __RPC__in_opt IUnknown *pUnkMFT); + + END_INTERFACE + } IMFFieldOfUseMFTUnlockVtbl; + + interface IMFFieldOfUseMFTUnlock + { + CONST_VTBL struct IMFFieldOfUseMFTUnlockVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFFieldOfUseMFTUnlock_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFFieldOfUseMFTUnlock_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFFieldOfUseMFTUnlock_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFFieldOfUseMFTUnlock_Unlock(This,pUnkMFT) \ + ( (This)->lpVtbl -> Unlock(This,pUnkMFT) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFFieldOfUseMFTUnlock_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0092 */ +/* [local] */ + +typedef struct _MFT_REGISTRATION_INFO + { + CLSID clsid; + GUID guidCategory; + UINT32 uiFlags; + LPCWSTR pszName; + DWORD cInTypes; + /* [size_is] */ MFT_REGISTER_TYPE_INFO *pInTypes; + DWORD cOutTypes; + /* [size_is] */ MFT_REGISTER_TYPE_INFO *pOutTypes; + } MFT_REGISTRATION_INFO; + +EXTERN_GUID(MF_LOCAL_MFT_REGISTRATION_SERVICE, 0xddf5cf9c, 0x4506, 0x45aa, 0xab, 0xf0, 0x6d, 0x5d, 0x94, 0xdd, 0x1b, 0x4a); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0092_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0092_v0_0_s_ifspec; + +#ifndef __IMFLocalMFTRegistration_INTERFACE_DEFINED__ +#define __IMFLocalMFTRegistration_INTERFACE_DEFINED__ + +/* interface IMFLocalMFTRegistration */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFLocalMFTRegistration; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("149c4d73-b4be-4f8d-8b87-079e926b6add") + IMFLocalMFTRegistration : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE RegisterMFTs( + /* [size_is][in] */ __RPC__in_ecount_full(cMFTs) MFT_REGISTRATION_INFO *pMFTs, + DWORD cMFTs) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFLocalMFTRegistrationVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFLocalMFTRegistration * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFLocalMFTRegistration * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFLocalMFTRegistration * This); + + HRESULT ( STDMETHODCALLTYPE *RegisterMFTs )( + __RPC__in IMFLocalMFTRegistration * This, + /* [size_is][in] */ __RPC__in_ecount_full(cMFTs) MFT_REGISTRATION_INFO *pMFTs, + DWORD cMFTs); + + END_INTERFACE + } IMFLocalMFTRegistrationVtbl; + + interface IMFLocalMFTRegistration + { + CONST_VTBL struct IMFLocalMFTRegistrationVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFLocalMFTRegistration_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFLocalMFTRegistration_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFLocalMFTRegistration_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFLocalMFTRegistration_RegisterMFTs(This,pMFTs,cMFTs) \ + ( (This)->lpVtbl -> RegisterMFTs(This,pMFTs,cMFTs) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFLocalMFTRegistration_INTERFACE_DEFINED__ */ + + +#ifndef __IMFCapturePhotoConfirmation_INTERFACE_DEFINED__ +#define __IMFCapturePhotoConfirmation_INTERFACE_DEFINED__ + +/* interface IMFCapturePhotoConfirmation */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFCapturePhotoConfirmation; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("19f68549-ca8a-4706-a4ef-481dbc95e12c") + IMFCapturePhotoConfirmation : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetPhotoConfirmationCallback( + /* [annotation][in] */ + _In_ IMFAsyncCallback *pNotificationCallback) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPixelFormat( + /* [annotation][in] */ + _In_ GUID subtype) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPixelFormat( + /* [annotation][out] */ + _Out_ GUID *subtype) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFCapturePhotoConfirmationVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFCapturePhotoConfirmation * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFCapturePhotoConfirmation * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFCapturePhotoConfirmation * This); + + HRESULT ( STDMETHODCALLTYPE *SetPhotoConfirmationCallback )( + IMFCapturePhotoConfirmation * This, + /* [annotation][in] */ + _In_ IMFAsyncCallback *pNotificationCallback); + + HRESULT ( STDMETHODCALLTYPE *SetPixelFormat )( + IMFCapturePhotoConfirmation * This, + /* [annotation][in] */ + _In_ GUID subtype); + + HRESULT ( STDMETHODCALLTYPE *GetPixelFormat )( + IMFCapturePhotoConfirmation * This, + /* [annotation][out] */ + _Out_ GUID *subtype); + + END_INTERFACE + } IMFCapturePhotoConfirmationVtbl; + + interface IMFCapturePhotoConfirmation + { + CONST_VTBL struct IMFCapturePhotoConfirmationVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFCapturePhotoConfirmation_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFCapturePhotoConfirmation_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFCapturePhotoConfirmation_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFCapturePhotoConfirmation_SetPhotoConfirmationCallback(This,pNotificationCallback) \ + ( (This)->lpVtbl -> SetPhotoConfirmationCallback(This,pNotificationCallback) ) + +#define IMFCapturePhotoConfirmation_SetPixelFormat(This,subtype) \ + ( (This)->lpVtbl -> SetPixelFormat(This,subtype) ) + +#define IMFCapturePhotoConfirmation_GetPixelFormat(This,subtype) \ + ( (This)->lpVtbl -> GetPixelFormat(This,subtype) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFCapturePhotoConfirmation_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0094 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +#if (WINVER >= _WIN32_WINNT_WIN8) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0094_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0094_v0_0_s_ifspec; + +#ifndef __IMFPMPHostApp_INTERFACE_DEFINED__ +#define __IMFPMPHostApp_INTERFACE_DEFINED__ + +/* interface IMFPMPHostApp */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFPMPHostApp; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("84d2054a-3aa1-4728-a3b0-440a418cf49c") + IMFPMPHostApp : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE LockProcess( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnlockProcess( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE ActivateClassById( + /* [in] */ __RPC__in LPCWSTR id, + /* [unique][in] */ __RPC__in_opt IStream *pStream, + /* [in] */ __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt void **ppv) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFPMPHostAppVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFPMPHostApp * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFPMPHostApp * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFPMPHostApp * This); + + HRESULT ( STDMETHODCALLTYPE *LockProcess )( + __RPC__in IMFPMPHostApp * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockProcess )( + __RPC__in IMFPMPHostApp * This); + + HRESULT ( STDMETHODCALLTYPE *ActivateClassById )( + __RPC__in IMFPMPHostApp * This, + /* [in] */ __RPC__in LPCWSTR id, + /* [unique][in] */ __RPC__in_opt IStream *pStream, + /* [in] */ __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt void **ppv); + + END_INTERFACE + } IMFPMPHostAppVtbl; + + interface IMFPMPHostApp + { + CONST_VTBL struct IMFPMPHostAppVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFPMPHostApp_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFPMPHostApp_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFPMPHostApp_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFPMPHostApp_LockProcess(This) \ + ( (This)->lpVtbl -> LockProcess(This) ) + +#define IMFPMPHostApp_UnlockProcess(This) \ + ( (This)->lpVtbl -> UnlockProcess(This) ) + +#define IMFPMPHostApp_ActivateClassById(This,id,pStream,riid,ppv) \ + ( (This)->lpVtbl -> ActivateClassById(This,id,pStream,riid,ppv) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFPMPHostApp_INTERFACE_DEFINED__ */ + + +#ifndef __IMFPMPClientApp_INTERFACE_DEFINED__ +#define __IMFPMPClientApp_INTERFACE_DEFINED__ + +/* interface IMFPMPClientApp */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFPMPClientApp; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c004f646-be2c-48f3-93a2-a0983eba1108") + IMFPMPClientApp : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetPMPHost( + /* [in] */ IMFPMPHostApp *pPMPHost) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFPMPClientAppVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFPMPClientApp * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFPMPClientApp * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFPMPClientApp * This); + + HRESULT ( STDMETHODCALLTYPE *SetPMPHost )( + IMFPMPClientApp * This, + /* [in] */ IMFPMPHostApp *pPMPHost); + + END_INTERFACE + } IMFPMPClientAppVtbl; + + interface IMFPMPClientApp + { + CONST_VTBL struct IMFPMPClientAppVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFPMPClientApp_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFPMPClientApp_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFPMPClientApp_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFPMPClientApp_SetPMPHost(This,pPMPHost) \ + ( (This)->lpVtbl -> SetPMPHost(This,pPMPHost) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFPMPClientApp_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0096 */ +/* [local] */ + +#endif +#if (WINVER >= _WIN32_WINNT_WINBLUE) + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0096_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0096_v0_0_s_ifspec; + +#ifndef __IMFMediaStreamSourceSampleRequest_INTERFACE_DEFINED__ +#define __IMFMediaStreamSourceSampleRequest_INTERFACE_DEFINED__ + +/* interface IMFMediaStreamSourceSampleRequest */ +/* [unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaStreamSourceSampleRequest; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("380b9af9-a85b-4e78-a2af-ea5ce645c6b4") + IMFMediaStreamSourceSampleRequest : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetSample( + /* [in] */ __RPC__in_opt IMFSample *value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaStreamSourceSampleRequestVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaStreamSourceSampleRequest * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaStreamSourceSampleRequest * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaStreamSourceSampleRequest * This); + + HRESULT ( STDMETHODCALLTYPE *SetSample )( + __RPC__in IMFMediaStreamSourceSampleRequest * This, + /* [in] */ __RPC__in_opt IMFSample *value); + + END_INTERFACE + } IMFMediaStreamSourceSampleRequestVtbl; + + interface IMFMediaStreamSourceSampleRequest + { + CONST_VTBL struct IMFMediaStreamSourceSampleRequestVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaStreamSourceSampleRequest_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaStreamSourceSampleRequest_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaStreamSourceSampleRequest_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaStreamSourceSampleRequest_SetSample(This,value) \ + ( (This)->lpVtbl -> SetSample(This,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaStreamSourceSampleRequest_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0097 */ +/* [local] */ + +#endif + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0097_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0097_v0_0_s_ifspec; + +#ifndef __IMFTrackedSample_INTERFACE_DEFINED__ +#define __IMFTrackedSample_INTERFACE_DEFINED__ + +/* interface IMFTrackedSample */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFTrackedSample; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("245BF8E9-0755-40f7-88A5-AE0F18D55E17") + IMFTrackedSample : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetAllocator( + /* [annotation][in] */ + _In_ IMFAsyncCallback *pSampleAllocator, + /* [unique][in] */ IUnknown *pUnkState) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTrackedSampleVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTrackedSample * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTrackedSample * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTrackedSample * This); + + HRESULT ( STDMETHODCALLTYPE *SetAllocator )( + IMFTrackedSample * This, + /* [annotation][in] */ + _In_ IMFAsyncCallback *pSampleAllocator, + /* [unique][in] */ IUnknown *pUnkState); + + END_INTERFACE + } IMFTrackedSampleVtbl; + + interface IMFTrackedSample + { + CONST_VTBL struct IMFTrackedSampleVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTrackedSample_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTrackedSample_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTrackedSample_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTrackedSample_SetAllocator(This,pSampleAllocator,pUnkState) \ + ( (This)->lpVtbl -> SetAllocator(This,pSampleAllocator,pUnkState) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTrackedSample_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0098 */ +/* [local] */ + +STDAPI MFCreateTrackedSample( + _Outptr_ IMFTrackedSample** ppMFSample); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +STDAPI MFCreateMFByteStreamOnStream( + IStream* pStream, + _Outptr_ IMFByteStream** ppByteStream); +STDAPI MFCreateStreamOnMFByteStream( + _In_ IMFByteStream* pByteStream, + _Outptr_ IStream** ppStream); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +STDAPI MFCreateMFByteStreamOnStreamEx( + _In_ IUnknown* punkStream, + _Outptr_ IMFByteStream** ppByteStream ); +STDAPI MFCreateStreamOnMFByteStreamEx( + _In_ IMFByteStream* pByteStream, + _In_ REFIID riid, + _Outptr_ void **ppv ); +STDAPI MFCreateMediaTypeFromProperties( + _In_ IUnknown* punkStream, + _Outptr_ IMFMediaType** ppMediaType ); +STDAPI MFCreatePropertiesFromMediaType( + _In_ IMFMediaType* pMediaType, + _In_ REFIID riid, + _Outptr_ void **ppv ); +#if (WINVER >= _WIN32_WINNT_WINBLUE) +DEFINE_GUID(MF_WRAPPED_BUFFER_SERVICE, 0xab544072, 0xc269, 0x4ebc, 0xa5, 0x52, 0x1c, 0x3b, 0x32, 0xbe, 0xd5, 0xca); +EXTERN_GUID(MF_WRAPPED_SAMPLE_SERVICE, 0x31f52bf2, 0xd03e, 0x4048, 0x80, 0xd0, 0x9c, 0x10, 0x46, 0xd8, 0x7c, 0x61); +#endif // (WINVER >= _WIN32_WINNT_WINBLUE) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +EXTERN_GUID( MF_WRAPPED_OBJECT, 0x2b182c4c, 0xd6ac, 0x49f4, 0x89, 0x15, 0xf7, 0x18, 0x87, 0xdb, 0x70, 0xcd); +EXTERN_GUID(CLSID_HttpSchemePlugin, 0x44cb442b, 0x9da9, 0x49df, 0xb3, 0xfd, 0x2, 0x37, 0x77, 0xb1, 0x6e, 0x50); +EXTERN_GUID(CLSID_UrlmonSchemePlugin, 0x9ec4b4f9, 0x3029, 0x45ad, 0x94, 0x7b, 0x34, 0x4d, 0xe2, 0xa2, 0x49, 0xe2); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_GUID(CLSID_NetSchemePlugin, 0xe9f4ebab, 0xd97b, 0x463e, 0xa2, 0xb1, 0xc5, 0x4e, 0xe3, 0xf9, 0x41, 0x4d); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +STDAPI MFEnumDeviceSources( + _In_ IMFAttributes* pAttributes, + _Outptr_result_buffer_(*pcSourceActivate) IMFActivate*** pppSourceActivate, + _Out_ UINT32* pcSourceActivate +); +STDAPI MFCreateDeviceSource( + _In_ IMFAttributes* pAttributes, + _Outptr_ IMFMediaSource** ppSource +); +STDAPI MFCreateDeviceSourceActivate( + _In_ IMFAttributes* pAttributes, + _Outptr_ IMFActivate** ppActivate +); +EXTERN_GUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE, 0xc60ac5fe, 0x252a, 0x478f, 0xa0, 0xef, 0xbc, 0x8f, 0xa5, 0xf7, 0xca, 0xd3); +EXTERN_GUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_HW_SOURCE, 0xde7046ba, 0x54d6, 0x4487, 0xa2, 0xa4, 0xec, 0x7c, 0xd, 0x1b, 0xd1, 0x63); +EXTERN_GUID( MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, 0x60d0e559, 0x52f8, 0x4fa2, 0xbb, 0xce, 0xac, 0xdb, 0x34, 0xa8, 0xec, 0x1); +EXTERN_GUID( MF_DEVSOURCE_ATTRIBUTE_MEDIA_TYPE, 0x56a819ca, 0xc78, 0x4de4, 0xa0, 0xa7, 0x3d, 0xda, 0xba, 0xf, 0x24, 0xd4); +EXTERN_GUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_CATEGORY, 0x77f0ae69, 0xc3bd, 0x4509, 0x94, 0x1d, 0x46, 0x7e, 0x4d, 0x24, 0x89, 0x9e); +EXTERN_GUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, 0x58f0aad8, 0x22bf, 0x4f8a, 0xbb, 0x3d, 0xd2, 0xc4, 0x97, 0x8c, 0x6e, 0x2f); +EXTERN_GUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_SYMBOLIC_LINK, 0x98d24b5e, 0x5930, 0x4614, 0xb5, 0xa1, 0xf6, 0x0, 0xf9, 0x35, 0x5a, 0x78); +EXTERN_GUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_MAX_BUFFERS, 0x7dd9b730, 0x4f2d, 0x41d5, 0x8f, 0x95, 0xc, 0xc9, 0xa9, 0x12, 0xba, 0x26); +EXTERN_GUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ENDPOINT_ID, 0x30da9258, 0xfeb9, 0x47a7, 0xa4, 0x53, 0x76, 0x3a, 0x7a, 0x8e, 0x1c, 0x5f); +EXTERN_GUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_ROLE, 0xbc9d118e, 0x8c67, 0x4a18, 0x85, 0xd4, 0x12, 0xd3, 0x0, 0x40, 0x5, 0x52); +EXTERN_GUID( MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_PROVIDER_DEVICE_ID, 0x36689d42, 0xa06c, 0x40ae, 0x84, 0xcf, 0xf5, 0xa0, 0x34, 0x6, 0x7c, 0xc4); +EXTERN_GUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_AUDCAP_GUID, 0x14dd9a1c, 0x7cff, 0x41be, 0xb1, 0xb9, 0xba, 0x1a, 0xc6, 0xec, 0xb5, 0x71); +EXTERN_GUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID, 0x8ac3587a, 0x4ae7, 0x42d8, 0x99, 0xe0, 0x0a, 0x60, 0x13, 0xee, 0xf9, 0x0f); +EXTERN_GUID( MF_DEVICESTREAM_IMAGE_STREAM, 0xa7ffb865, 0xe7b2, 0x43b0, 0x9f, 0x6f, 0x9a, 0xf2, 0xa0, 0xe5, 0xf, 0xc0); +EXTERN_GUID( MF_DEVICESTREAM_INDEPENDENT_IMAGE_STREAM, 0x3eeec7e, 0xd605, 0x4576, 0x8b, 0x29, 0x65, 0x80, 0xb4, 0x90, 0xd7, 0xd3); +EXTERN_GUID( MF_DEVICESTREAM_STREAM_ID, 0x11bd5120, 0xd124, 0x446b, 0x88, 0xe6, 0x17, 0x6, 0x2, 0x57, 0xff, 0xf9); +EXTERN_GUID( MF_DEVICESTREAM_STREAM_CATEGORY, 0x2939e7b8, 0xa62e, 0x4579, 0xb6, 0x74, 0xd4, 0x7, 0x3d, 0xfa, 0xbb, 0xba); +EXTERN_GUID( MF_DEVICESTREAM_FRAMESERVER_SHARED, 0x1CB378E9, 0xB279, 0x41D4, 0xAF, 0x97, 0x34, 0xA2, 0x43, 0xE6, 0x83, 0x20); +EXTERN_GUID( MF_DEVICESTREAM_TRANSFORM_STREAM_ID, 0xe63937b7, 0xdaaf, 0x4d49, 0x81, 0x5f, 0xd8, 0x26, 0xf8, 0xad, 0x31, 0xe7); +EXTERN_GUID( MF_DEVICESTREAM_EXTENSION_PLUGIN_CLSID, 0x048e6558, 0x60c4, 0x4173, 0xbd, 0x5b, 0x6a, 0x3c, 0xa2, 0x89, 0x6a, 0xee); +EXTERN_GUID( MF_DEVICEMFT_EXTENSION_PLUGIN_CLSID, 0x844dbae, 0x34fa, 0x48a0, 0xa7, 0x83, 0x8e, 0x69, 0x6f, 0xb1, 0xc9, 0xa8); +EXTERN_GUID( MF_DEVICESTREAM_EXTENSION_PLUGIN_CONNECTION_POINT, 0x37f9375c, 0xe664, 0x4ea4, 0xaa, 0xe4, 0xcb, 0x6d, 0x1d, 0xac, 0xa1, 0xf4); +EXTERN_GUID( MF_DEVICESTREAM_TAKEPHOTO_TRIGGER, 0x1d180e34, 0x538c, 0x4fbb, 0xa7, 0x5a, 0x85, 0x9a, 0xf7, 0xd2, 0x61, 0xa6 ); +EXTERN_GUID( MF_DEVICESTREAM_MAX_FRAME_BUFFERS, 0x1684cebe, 0x3175, 0x4985, 0x88, 0x2c, 0x0e, 0xfd, 0x3e, 0x8a, 0xc1, 0x1e ); +EXTERN_GUID( MF_DEVICEMFT_CONNECTED_FILTER_KSCONTROL, 0x6a2c4fa6, 0xd179, 0x41cd, 0x95, 0x23, 0x82, 0x23, 0x71, 0xea, 0x40, 0xe5); +EXTERN_GUID( MF_DEVICEMFT_CONNECTED_PIN_KSCONTROL, 0xe63310f7, 0xb244, 0x4ef8, 0x9a, 0x7d, 0x24, 0xc7, 0x4e, 0x32, 0xeb, 0xd0); +EXTERN_GUID( MF_DEVICE_THERMAL_STATE_CHANGED, 0x70ccd0af, 0xfc9f, 0x4deb, 0xa8, 0x75, 0x9f, 0xec, 0xd1, 0x6c, 0x5b, 0xd4 ); +EXTERN_GUID(MFSampleExtension_DeviceTimestamp, 0x8f3e35e7, 0x2dcd, 0x4887, 0x86, 0x22, 0x2a, 0x58, 0xba, 0xa6, 0x52, 0xb0); +EXTERN_GUID(MFSampleExtension_Spatial_CameraViewTransform , 0x4e251fa4, 0x830f, 0x4770, 0x85, 0x9a, 0x4b, 0x8d, 0x99, 0xaa, 0x80, 0x9b); +EXTERN_GUID(MFSampleExtension_Spatial_CameraCoordinateSystem , 0x9d13c82f, 0x2199, 0x4e67, 0x91, 0xcd, 0xd1, 0xa4, 0x18, 0x1f, 0x25, 0x34); +EXTERN_GUID(MFSampleExtension_Spatial_CameraProjectionTransform , 0x47f9fcb5, 0x2a02, 0x4f26, 0xa4, 0x77, 0x79, 0x2f, 0xdf, 0x95, 0x88, 0x6a); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0098_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0098_v0_0_s_ifspec; + +#ifndef __IMFProtectedEnvironmentAccess_INTERFACE_DEFINED__ +#define __IMFProtectedEnvironmentAccess_INTERFACE_DEFINED__ + +/* interface IMFProtectedEnvironmentAccess */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFProtectedEnvironmentAccess; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ef5dc845-f0d9-4ec9-b00c-cb5183d38434") + IMFProtectedEnvironmentAccess : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Call( + /* [annotation] */ + _In_ UINT32 inputLength, + /* [annotation] */ + _In_reads_bytes_(inputLength) const BYTE *input, + /* [annotation] */ + _In_ UINT32 outputLength, + /* [annotation] */ + _Out_writes_bytes_(outputLength) BYTE *output) = 0; + + virtual HRESULT STDMETHODCALLTYPE ReadGRL( + /* [annotation] */ + _Out_ UINT32 *outputLength, + /* [annotation] */ + _Outptr_result_bytebuffer_(*outputLength) BYTE **output) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFProtectedEnvironmentAccessVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFProtectedEnvironmentAccess * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFProtectedEnvironmentAccess * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFProtectedEnvironmentAccess * This); + + HRESULT ( STDMETHODCALLTYPE *Call )( + IMFProtectedEnvironmentAccess * This, + /* [annotation] */ + _In_ UINT32 inputLength, + /* [annotation] */ + _In_reads_bytes_(inputLength) const BYTE *input, + /* [annotation] */ + _In_ UINT32 outputLength, + /* [annotation] */ + _Out_writes_bytes_(outputLength) BYTE *output); + + HRESULT ( STDMETHODCALLTYPE *ReadGRL )( + IMFProtectedEnvironmentAccess * This, + /* [annotation] */ + _Out_ UINT32 *outputLength, + /* [annotation] */ + _Outptr_result_bytebuffer_(*outputLength) BYTE **output); + + END_INTERFACE + } IMFProtectedEnvironmentAccessVtbl; + + interface IMFProtectedEnvironmentAccess + { + CONST_VTBL struct IMFProtectedEnvironmentAccessVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFProtectedEnvironmentAccess_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFProtectedEnvironmentAccess_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFProtectedEnvironmentAccess_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFProtectedEnvironmentAccess_Call(This,inputLength,input,outputLength,output) \ + ( (This)->lpVtbl -> Call(This,inputLength,input,outputLength,output) ) + +#define IMFProtectedEnvironmentAccess_ReadGRL(This,outputLength,output) \ + ( (This)->lpVtbl -> ReadGRL(This,outputLength,output) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFProtectedEnvironmentAccess_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSignedLibrary_INTERFACE_DEFINED__ +#define __IMFSignedLibrary_INTERFACE_DEFINED__ + +/* interface IMFSignedLibrary */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSignedLibrary; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("4a724bca-ff6a-4c07-8e0d-7a358421cf06") + IMFSignedLibrary : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetProcedureAddress( + /* [annotation] */ + _In_ LPCSTR name, + /* [annotation] */ + _Outptr_ PVOID *address) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSignedLibraryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSignedLibrary * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSignedLibrary * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSignedLibrary * This); + + HRESULT ( STDMETHODCALLTYPE *GetProcedureAddress )( + IMFSignedLibrary * This, + /* [annotation] */ + _In_ LPCSTR name, + /* [annotation] */ + _Outptr_ PVOID *address); + + END_INTERFACE + } IMFSignedLibraryVtbl; + + interface IMFSignedLibrary + { + CONST_VTBL struct IMFSignedLibraryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSignedLibrary_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSignedLibrary_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSignedLibrary_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSignedLibrary_GetProcedureAddress(This,name,address) \ + ( (This)->lpVtbl -> GetProcedureAddress(This,name,address) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSignedLibrary_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSystemId_INTERFACE_DEFINED__ +#define __IMFSystemId_INTERFACE_DEFINED__ + +/* interface IMFSystemId */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSystemId; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("fff4af3a-1fc1-4ef9-a29b-d26c49e2f31a") + IMFSystemId : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetData( + /* [annotation] */ + _Out_ UINT32 *size, + /* [annotation] */ + _Outptr_result_bytebuffer_(*size) BYTE **data) = 0; + + virtual HRESULT STDMETHODCALLTYPE Setup( + UINT32 stage, + UINT32 cbIn, + /* [annotation] */ + _In_reads_bytes_(cbIn) const BYTE *pbIn, + /* [annotation] */ + _Out_ UINT32 *pcbOut, + /* [annotation] */ + _Outptr_result_bytebuffer_(*pcbOut) BYTE **ppbOut) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSystemIdVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSystemId * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSystemId * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSystemId * This); + + HRESULT ( STDMETHODCALLTYPE *GetData )( + IMFSystemId * This, + /* [annotation] */ + _Out_ UINT32 *size, + /* [annotation] */ + _Outptr_result_bytebuffer_(*size) BYTE **data); + + HRESULT ( STDMETHODCALLTYPE *Setup )( + IMFSystemId * This, + UINT32 stage, + UINT32 cbIn, + /* [annotation] */ + _In_reads_bytes_(cbIn) const BYTE *pbIn, + /* [annotation] */ + _Out_ UINT32 *pcbOut, + /* [annotation] */ + _Outptr_result_bytebuffer_(*pcbOut) BYTE **ppbOut); + + END_INTERFACE + } IMFSystemIdVtbl; + + interface IMFSystemId + { + CONST_VTBL struct IMFSystemIdVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSystemId_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSystemId_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSystemId_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSystemId_GetData(This,size,data) \ + ( (This)->lpVtbl -> GetData(This,size,data) ) + +#define IMFSystemId_Setup(This,stage,cbIn,pbIn,pcbOut,ppbOut) \ + ( (This)->lpVtbl -> Setup(This,stage,cbIn,pbIn,pcbOut,ppbOut) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSystemId_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0101 */ +/* [local] */ + +STDAPI MFCreateProtectedEnvironmentAccess( + _Outptr_ IMFProtectedEnvironmentAccess** ppAccess +); +STDAPI MFLoadSignedLibrary( + _In_ LPCWSTR pszName, + _Outptr_ IMFSignedLibrary** ppLib +); +STDAPI MFGetSystemId( + _Outptr_ IMFSystemId** ppId +); +STDAPI MFGetLocalId( + _In_reads_bytes_(size) const BYTE *verifier, + _In_ UINT32 size, + _Outptr_ LPWSTR *id +); +// {40871C59-AB40-471F-8DC3-1F259D862479} +DEFINE_GUID(CLSID_MPEG2ByteStreamPlugin, +0x40871c59, 0xab40, 0x471f, 0x8d, 0xc3, 0x1f, 0x25, 0x9d, 0x86, 0x24, 0x79); +// {f09992f7-9fba-4c4a-a37f-8c47b4e1dfe7} +EXTERN_GUID( MF_MEDIASOURCE_SERVICE, 0xf09992f7, 0x9fba, 0x4c4a, 0xa3, 0x7f, 0x8c, 0x47, 0xb4, 0xe1, 0xdf, 0xe7 ); +// {014A5031-2F05-4C6A-9F9C-7D0DC4EDA5F4} +EXTERN_GUID( MF_ACCESS_CONTROLLED_MEDIASOURCE_SERVICE, 0x14a5031, 0x2f05, 0x4c6a, 0x9f, 0x9c, 0x7d, 0xd, 0xc4, 0xed, 0xa5, 0xf4 ); +typedef struct _MFCONTENTPROTECTIONDEVICE_INPUT_DATA + { + DWORD HWProtectionFunctionID; + DWORD PrivateDataByteCount; + DWORD HWProtectionDataByteCount; + DWORD Reserved; + BYTE InputData[ 4 ]; + } MFCONTENTPROTECTIONDEVICE_INPUT_DATA; + +typedef struct _MFCONTENTPROTECTIONDEVICE_OUTPUT_DATA + { + DWORD PrivateDataByteCount; + DWORD MaxHWProtectionDataByteCount; + DWORD HWProtectionDataByteCount; + HRESULT Status; + LONGLONG TransportTimeInHundredsOfNanoseconds; + LONGLONG ExecutionTimeInHundredsOfNanoseconds; + BYTE OutputData[ 4 ]; + } MFCONTENTPROTECTIONDEVICE_OUTPUT_DATA; + +#define MFCONTENTPROTECTIONDEVICE_FUNCTIONID_START 0x04000000 +#define MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA_FUNCTIONID MFCONTENTPROTECTIONDEVICE_FUNCTIONID_START +typedef struct _MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA { + DWORD TaskIndex; + WCHAR ClassName[MAX_PATH]; + LONG BasePriority; +} MFCONTENTPROTECTIONDEVICE_REALTIMECLIENT_DATA; + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0101_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0101_v0_0_s_ifspec; + +#ifndef __IMFContentProtectionDevice_INTERFACE_DEFINED__ +#define __IMFContentProtectionDevice_INTERFACE_DEFINED__ + +/* interface IMFContentProtectionDevice */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFContentProtectionDevice; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("E6257174-A060-4C9A-A088-3B1B471CAD28") + IMFContentProtectionDevice : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE InvokeFunction( + /* [annotation][in] */ + _In_ DWORD FunctionId, + /* [annotation][in] */ + _In_ DWORD InputBufferByteCount, + /* [annotation][size_is][in] */ + _In_reads_bytes_(InputBufferByteCount) const BYTE *InputBuffer, + /* [annotation][out][in] */ + _Inout_ DWORD *OutputBufferByteCount, + /* [annotation][size_is][out] */ + _Out_writes_bytes_(*OutputBufferByteCount) BYTE *OutputBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPrivateDataByteCount( + /* [annotation][out] */ + _Out_ DWORD *PrivateInputByteCount, + /* [annotation][out] */ + _Out_ DWORD *PrivateOutputByteCount) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFContentProtectionDeviceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFContentProtectionDevice * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFContentProtectionDevice * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFContentProtectionDevice * This); + + HRESULT ( STDMETHODCALLTYPE *InvokeFunction )( + IMFContentProtectionDevice * This, + /* [annotation][in] */ + _In_ DWORD FunctionId, + /* [annotation][in] */ + _In_ DWORD InputBufferByteCount, + /* [annotation][size_is][in] */ + _In_reads_bytes_(InputBufferByteCount) const BYTE *InputBuffer, + /* [annotation][out][in] */ + _Inout_ DWORD *OutputBufferByteCount, + /* [annotation][size_is][out] */ + _Out_writes_bytes_(*OutputBufferByteCount) BYTE *OutputBuffer); + + HRESULT ( STDMETHODCALLTYPE *GetPrivateDataByteCount )( + IMFContentProtectionDevice * This, + /* [annotation][out] */ + _Out_ DWORD *PrivateInputByteCount, + /* [annotation][out] */ + _Out_ DWORD *PrivateOutputByteCount); + + END_INTERFACE + } IMFContentProtectionDeviceVtbl; + + interface IMFContentProtectionDevice + { + CONST_VTBL struct IMFContentProtectionDeviceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFContentProtectionDevice_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFContentProtectionDevice_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFContentProtectionDevice_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFContentProtectionDevice_InvokeFunction(This,FunctionId,InputBufferByteCount,InputBuffer,OutputBufferByteCount,OutputBuffer) \ + ( (This)->lpVtbl -> InvokeFunction(This,FunctionId,InputBufferByteCount,InputBuffer,OutputBufferByteCount,OutputBuffer) ) + +#define IMFContentProtectionDevice_GetPrivateDataByteCount(This,PrivateInputByteCount,PrivateOutputByteCount) \ + ( (This)->lpVtbl -> GetPrivateDataByteCount(This,PrivateInputByteCount,PrivateOutputByteCount) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFContentProtectionDevice_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0102 */ +/* [local] */ + +STDAPI MFCreateContentProtectionDevice( + _In_ REFGUID ProtectionSystemId, + _Outptr_ IMFContentProtectionDevice **ContentProtectionDevice); +STDAPI MFIsContentProtectionDeviceSupported( + _In_ REFGUID ProtectionSystemId, + _Out_ BOOL *isSupported); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0102_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0102_v0_0_s_ifspec; + +#ifndef __IMFContentDecryptorContext_INTERFACE_DEFINED__ +#define __IMFContentDecryptorContext_INTERFACE_DEFINED__ + +/* interface IMFContentDecryptorContext */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFContentDecryptorContext; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7EC4B1BD-43FB-4763-85D2-64FCB5C5F4CB") + IMFContentDecryptorContext : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE InitializeHardwareKey( + /* [annotation][in] */ + _In_ UINT InputPrivateDataByteCount, + /* [annotation][in] */ + _In_reads_opt_(InputPrivateDataByteCount) const void *InputPrivateData, + /* [annotation][out] */ + _Out_ UINT64 *OutputPrivateData) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFContentDecryptorContextVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFContentDecryptorContext * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFContentDecryptorContext * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFContentDecryptorContext * This); + + HRESULT ( STDMETHODCALLTYPE *InitializeHardwareKey )( + IMFContentDecryptorContext * This, + /* [annotation][in] */ + _In_ UINT InputPrivateDataByteCount, + /* [annotation][in] */ + _In_reads_opt_(InputPrivateDataByteCount) const void *InputPrivateData, + /* [annotation][out] */ + _Out_ UINT64 *OutputPrivateData); + + END_INTERFACE + } IMFContentDecryptorContextVtbl; + + interface IMFContentDecryptorContext + { + CONST_VTBL struct IMFContentDecryptorContextVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFContentDecryptorContext_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFContentDecryptorContext_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFContentDecryptorContext_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFContentDecryptorContext_InitializeHardwareKey(This,InputPrivateDataByteCount,InputPrivateData,OutputPrivateData) \ + ( (This)->lpVtbl -> InitializeHardwareKey(This,InputPrivateDataByteCount,InputPrivateData,OutputPrivateData) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFContentDecryptorContext_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0103 */ +/* [local] */ + +EXTERN_GUID( MF_CONTENT_DECRYPTOR_SERVICE, 0x68a72927, 0xfc7b, 0x44ee, 0x85, 0xf4, 0x7c, 0x51, 0xbd, 0x55, 0xa6, 0x59); +EXTERN_GUID( MF_CONTENT_PROTECTION_DEVICE_SERVICE, 0xff58436f, 0x76a0, 0x41fe, 0xb5, 0x66, 0x10, 0xcc, 0x53, 0x96, 0x2e, 0xdd); +STDAPI MFCreateContentDecryptorContext( + _In_ REFGUID guidMediaProtectionSystemId, + _In_opt_ IMFDXGIDeviceManager *pD3DManager, + _In_ IMFContentProtectionDevice *pContentProtectionDevice, + _Outptr_ IMFContentDecryptorContext **ppContentDecryptorContext); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Application Family +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_GUID( MF_SD_AUDIO_ENCODER_DELAY, 0x8e85422c, 0x73de, 0x403f, 0x9a, 0x35, 0x55, 0x0a, 0xd6, 0xe8, 0xb9, 0x51 ); +EXTERN_GUID( MF_SD_AUDIO_ENCODER_PADDING, 0x529c7f2c, 0xac4b, 0x4e3f, 0xbf, 0xc3, 0x09, 0x02, 0x19, 0x49, 0x82, 0xcb ); +EXTERN_GUID(CLSID_MSH264DecoderMFT, 0x62CE7E72, 0x4C71, 0x4d20, 0xB1, 0x5D, 0x45, 0x28, 0x31, 0xA8, 0x7D, 0x9D); +EXTERN_GUID(CLSID_MSH264EncoderMFT, 0x6ca50344, 0x051a, 0x4ded, 0x97, 0x79, 0xa4, 0x33, 0x05, 0x16, 0x5e, 0x35); +EXTERN_GUID(CLSID_MSDDPlusDecMFT, 0x177C0AFE, 0x900B, 0x48d4, 0x9E, 0x4C, 0x57, 0xAD, 0xD2, 0x50, 0xB3, 0xD4); +EXTERN_GUID(CLSID_MP3DecMediaObject, 0xbbeea841, 0x0a63, 0x4f52, 0xa7, 0xab, 0xa9, 0xb3, 0xa8, 0x4e, 0xd3, 0x8a); +EXTERN_GUID(CLSID_MSAACDecMFT, 0x32d186a7, 0x218f, 0x4c75, 0x88, 0x76, 0xdd, 0x77, 0x27, 0x3a, 0x89, 0x99); +EXTERN_GUID(CLSID_MSH265DecoderMFT, 0x420A51A3, 0xD605, 0x430C, 0xB4, 0xFC, 0x45, 0x27, 0x4F, 0xA6, 0xC5, 0x62); +EXTERN_GUID(CLSID_WMVDecoderMFT, 0x82d353df, 0x90bd, 0x4382, 0x8b, 0xc2, 0x3f, 0x61, 0x92, 0xb7, 0x6e, 0x34); +EXTERN_GUID(CLSID_WMADecMediaObject, 0x2eeb4adf, 0x4578, 0x4d10, 0xbc, 0xa7, 0xbb, 0x95, 0x5f, 0x56, 0x32, 0x0a); +EXTERN_GUID(CLSID_MSMPEGAudDecMFT, 0x70707B39, 0xB2CA, 0x4015, 0xAB, 0xEA, 0xF8, 0x44, 0x7D, 0x22, 0xD8, 0x8B); +EXTERN_GUID(CLSID_MSMPEGDecoderMFT, 0x2D709E52, 0x123F, 0x49b5, 0x9C, 0xBC, 0x9A, 0xF5, 0xCD, 0xE2, 0x8F, 0xB9); +EXTERN_GUID(CLSID_AudioResamplerMediaObject, 0xf447b69e, 0x1884, 0x4a7e, 0x80, 0x55, 0x34, 0x6f, 0x74, 0xd6, 0xed, 0xb3); +EXTERN_GUID(CLSID_MSVPxDecoder, 0xE3AAF548, 0xC9A4, 0x4C6E, 0x23, 0x4D, 0x5A, 0xDA, 0x37, 0x4B, 0x00, 0x00); +EXTERN_GUID(CLSID_MSOpusDecoder, 0x63e17c10, 0x2d43, 0x4c42, 0x8f, 0xe3, 0x8d, 0x8b, 0x63, 0xe4, 0x6a, 0x6a); +EXTERN_GUID(CLSID_VideoProcessorMFT, 0x88753b26, 0x5b24, 0x49bd, 0xb2, 0xe7, 0xc, 0x44, 0x5c, 0x78, 0xc9, 0x82); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#pragma endregion +#pragma region EME2 helper types +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +typedef +enum MF_MEDIAKEYSESSION_TYPE + { + MF_MEDIAKEYSESSION_TYPE_TEMPORARY = 0, + MF_MEDIAKEYSESSION_TYPE_PERSISTENT_LICENSE = ( MF_MEDIAKEYSESSION_TYPE_TEMPORARY + 1 ) , + MF_MEDIAKEYSESSION_TYPE_PERSISTENT_RELEASE_MESSAGE = ( MF_MEDIAKEYSESSION_TYPE_PERSISTENT_LICENSE + 1 ) , + MF_MEDIAKEYSESSION_TYPE_PERSISTENT_USAGE_RECORD = ( MF_MEDIAKEYSESSION_TYPE_PERSISTENT_RELEASE_MESSAGE + 1 ) + } MF_MEDIAKEYSESSION_TYPE; + +typedef +enum MF_MEDIAKEY_STATUS + { + MF_MEDIAKEY_STATUS_USABLE = 0, + MF_MEDIAKEY_STATUS_EXPIRED = ( MF_MEDIAKEY_STATUS_USABLE + 1 ) , + MF_MEDIAKEY_STATUS_OUTPUT_DOWNSCALED = ( MF_MEDIAKEY_STATUS_EXPIRED + 1 ) , + MF_MEDIAKEY_STATUS_OUTPUT_NOT_ALLOWED = ( MF_MEDIAKEY_STATUS_OUTPUT_DOWNSCALED + 1 ) , + MF_MEDIAKEY_STATUS_STATUS_PENDING = ( MF_MEDIAKEY_STATUS_OUTPUT_NOT_ALLOWED + 1 ) , + MF_MEDIAKEY_STATUS_INTERNAL_ERROR = ( MF_MEDIAKEY_STATUS_STATUS_PENDING + 1 ) , + MF_MEDIAKEY_STATUS_RELEASED = ( MF_MEDIAKEY_STATUS_INTERNAL_ERROR + 1 ) , + MF_MEDIAKEY_STATUS_OUTPUT_RESTRICTED = ( MF_MEDIAKEY_STATUS_RELEASED + 1 ) + } MF_MEDIAKEY_STATUS; + +typedef struct MFMediaKeyStatus + { + BYTE *pbKeyId; + UINT cbKeyId; + MF_MEDIAKEY_STATUS eMediaKeyStatus; + } MFMediaKeyStatus; + +typedef +enum MF_MEDIAKEYSESSION_MESSAGETYPE + { + MF_MEDIAKEYSESSION_MESSAGETYPE_LICENSE_REQUEST = 0, + MF_MEDIAKEYSESSION_MESSAGETYPE_LICENSE_RENEWAL = 1, + MF_MEDIAKEYSESSION_MESSAGETYPE_LICENSE_RELEASE = 2, + MF_MEDIAKEYSESSION_MESSAGETYPE_INDIVIDUALIZATION_REQUEST = 3 + } MF_MEDIAKEYSESSION_MESSAGETYPE; + +typedef +enum _MF_CROSS_ORIGIN_POLICY + { + MF_CROSS_ORIGIN_POLICY_NONE = 0, + MF_CROSS_ORIGIN_POLICY_ANONYMOUS = 1, + MF_CROSS_ORIGIN_POLICY_USE_CREDENTIALS = 2 + } MF_CROSS_ORIGIN_POLICY; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0103_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0103_v0_0_s_ifspec; + +#ifndef __IMFNetCrossOriginSupport_INTERFACE_DEFINED__ +#define __IMFNetCrossOriginSupport_INTERFACE_DEFINED__ + +/* interface IMFNetCrossOriginSupport */ +/* [local][unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFNetCrossOriginSupport; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("bc2b7d44-a72d-49d5-8376-1480dee58b22") + IMFNetCrossOriginSupport : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetCrossOriginPolicy( + /* [annotation][out] */ + _Out_ MF_CROSS_ORIGIN_POLICY *pPolicy) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSourceOrigin( + /* [annotation][out] */ + _Out_ LPWSTR *wszSourceOrigin) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsSameOrigin( + /* [in] */ LPCWSTR wszURL, + /* [annotation][out] */ + _Out_ BOOL *pfIsSameOrigin) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFNetCrossOriginSupportVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFNetCrossOriginSupport * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFNetCrossOriginSupport * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFNetCrossOriginSupport * This); + + HRESULT ( STDMETHODCALLTYPE *GetCrossOriginPolicy )( + IMFNetCrossOriginSupport * This, + /* [annotation][out] */ + _Out_ MF_CROSS_ORIGIN_POLICY *pPolicy); + + HRESULT ( STDMETHODCALLTYPE *GetSourceOrigin )( + IMFNetCrossOriginSupport * This, + /* [annotation][out] */ + _Out_ LPWSTR *wszSourceOrigin); + + HRESULT ( STDMETHODCALLTYPE *IsSameOrigin )( + IMFNetCrossOriginSupport * This, + /* [in] */ LPCWSTR wszURL, + /* [annotation][out] */ + _Out_ BOOL *pfIsSameOrigin); + + END_INTERFACE + } IMFNetCrossOriginSupportVtbl; + + interface IMFNetCrossOriginSupport + { + CONST_VTBL struct IMFNetCrossOriginSupportVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFNetCrossOriginSupport_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFNetCrossOriginSupport_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFNetCrossOriginSupport_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFNetCrossOriginSupport_GetCrossOriginPolicy(This,pPolicy) \ + ( (This)->lpVtbl -> GetCrossOriginPolicy(This,pPolicy) ) + +#define IMFNetCrossOriginSupport_GetSourceOrigin(This,wszSourceOrigin) \ + ( (This)->lpVtbl -> GetSourceOrigin(This,wszSourceOrigin) ) + +#define IMFNetCrossOriginSupport_IsSameOrigin(This,wszURL,pfIsSameOrigin) \ + ( (This)->lpVtbl -> IsSameOrigin(This,wszURL,pfIsSameOrigin) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFNetCrossOriginSupport_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0104 */ +/* [local] */ + +EXTERN_GUID(MFNETSOURCE_CROSS_ORIGIN_SUPPORT, 0x9842207c, 0xb02c, 0x4271, 0xa2, 0xfc, 0x72, 0xe4, 0x93, 0x8, 0xe5, 0xc2); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0104_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0104_v0_0_s_ifspec; + +#ifndef __IMFHttpDownloadRequest_INTERFACE_DEFINED__ +#define __IMFHttpDownloadRequest_INTERFACE_DEFINED__ + +/* interface IMFHttpDownloadRequest */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFHttpDownloadRequest; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("F779FDDF-26E7-4270-8A8B-B983D1859DE0") + IMFHttpDownloadRequest : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE AddHeader( + /* [annotation][in] */ + _In_ LPCWSTR szHeader) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginSendRequest( + /* [annotation][size_is][in] */ + _In_reads_opt_(cbPayload) const BYTE *pbPayload, + /* [annotation][in] */ + _In_ ULONG cbPayload, + /* [annotation][in] */ + _In_ IMFAsyncCallback *pCallback, + /* [annotation][in] */ + _In_opt_ IUnknown *punkState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndSendRequest( + /* [annotation][in] */ + _In_ IMFAsyncResult *pResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginReceiveResponse( + /* [annotation][in] */ + _In_ IMFAsyncCallback *pCallback, + /* [annotation][in] */ + _In_opt_ IUnknown *punkState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndReceiveResponse( + /* [annotation][in] */ + _In_ IMFAsyncResult *pResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginReadPayload( + /* [annotation][size_is][out] */ + _Out_writes_(cb) BYTE *pb, + /* [annotation][in] */ + _In_ ULONG cb, + /* [annotation][in] */ + _In_ IMFAsyncCallback *pCallback, + /* [annotation][in] */ + _In_opt_ IUnknown *punkState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndReadPayload( + /* [annotation][in] */ + _In_ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ QWORD *pqwOffset, + /* [annotation][out] */ + _Out_ ULONG *pcbRead) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueryHeader( + /* [annotation][in] */ + _In_ LPCWSTR szHeaderName, + /* [annotation][in] */ + _In_ DWORD dwIndex, + /* [annotation][out] */ + _Outptr_ LPWSTR *ppszHeaderValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetURL( + /* [annotation][out] */ + _Outptr_ LPWSTR *ppszURL) = 0; + + virtual HRESULT STDMETHODCALLTYPE HasNullSourceOrigin( + /* [annotation][out] */ + _Out_ BOOL *pfNullSourceOrigin) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimeSeekResult( + /* [annotation][out] */ + _Out_ QWORD *pqwStartTime, + /* [annotation][out] */ + _Out_ QWORD *pqwStopTime, + /* [annotation][out] */ + _Out_ QWORD *pqwDuration) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetHttpStatus( + /* [annotation][out] */ + _Out_ DWORD *pdwHttpStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAtEndOfPayload( + /* [annotation][out] */ + _Out_ BOOL *pfAtEndOfPayload) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTotalLength( + /* [annotation][out] */ + _Out_ QWORD *pqwTotalLength) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRangeEndOffset( + /* [annotation][out] */ + _Out_ QWORD *pqwRangeEnd) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFHttpDownloadRequestVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFHttpDownloadRequest * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFHttpDownloadRequest * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFHttpDownloadRequest * This); + + HRESULT ( STDMETHODCALLTYPE *AddHeader )( + IMFHttpDownloadRequest * This, + /* [annotation][in] */ + _In_ LPCWSTR szHeader); + + HRESULT ( STDMETHODCALLTYPE *BeginSendRequest )( + IMFHttpDownloadRequest * This, + /* [annotation][size_is][in] */ + _In_reads_opt_(cbPayload) const BYTE *pbPayload, + /* [annotation][in] */ + _In_ ULONG cbPayload, + /* [annotation][in] */ + _In_ IMFAsyncCallback *pCallback, + /* [annotation][in] */ + _In_opt_ IUnknown *punkState); + + HRESULT ( STDMETHODCALLTYPE *EndSendRequest )( + IMFHttpDownloadRequest * This, + /* [annotation][in] */ + _In_ IMFAsyncResult *pResult); + + HRESULT ( STDMETHODCALLTYPE *BeginReceiveResponse )( + IMFHttpDownloadRequest * This, + /* [annotation][in] */ + _In_ IMFAsyncCallback *pCallback, + /* [annotation][in] */ + _In_opt_ IUnknown *punkState); + + HRESULT ( STDMETHODCALLTYPE *EndReceiveResponse )( + IMFHttpDownloadRequest * This, + /* [annotation][in] */ + _In_ IMFAsyncResult *pResult); + + HRESULT ( STDMETHODCALLTYPE *BeginReadPayload )( + IMFHttpDownloadRequest * This, + /* [annotation][size_is][out] */ + _Out_writes_(cb) BYTE *pb, + /* [annotation][in] */ + _In_ ULONG cb, + /* [annotation][in] */ + _In_ IMFAsyncCallback *pCallback, + /* [annotation][in] */ + _In_opt_ IUnknown *punkState); + + HRESULT ( STDMETHODCALLTYPE *EndReadPayload )( + IMFHttpDownloadRequest * This, + /* [annotation][in] */ + _In_ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ QWORD *pqwOffset, + /* [annotation][out] */ + _Out_ ULONG *pcbRead); + + HRESULT ( STDMETHODCALLTYPE *QueryHeader )( + IMFHttpDownloadRequest * This, + /* [annotation][in] */ + _In_ LPCWSTR szHeaderName, + /* [annotation][in] */ + _In_ DWORD dwIndex, + /* [annotation][out] */ + _Outptr_ LPWSTR *ppszHeaderValue); + + HRESULT ( STDMETHODCALLTYPE *GetURL )( + IMFHttpDownloadRequest * This, + /* [annotation][out] */ + _Outptr_ LPWSTR *ppszURL); + + HRESULT ( STDMETHODCALLTYPE *HasNullSourceOrigin )( + IMFHttpDownloadRequest * This, + /* [annotation][out] */ + _Out_ BOOL *pfNullSourceOrigin); + + HRESULT ( STDMETHODCALLTYPE *GetTimeSeekResult )( + IMFHttpDownloadRequest * This, + /* [annotation][out] */ + _Out_ QWORD *pqwStartTime, + /* [annotation][out] */ + _Out_ QWORD *pqwStopTime, + /* [annotation][out] */ + _Out_ QWORD *pqwDuration); + + HRESULT ( STDMETHODCALLTYPE *GetHttpStatus )( + IMFHttpDownloadRequest * This, + /* [annotation][out] */ + _Out_ DWORD *pdwHttpStatus); + + HRESULT ( STDMETHODCALLTYPE *GetAtEndOfPayload )( + IMFHttpDownloadRequest * This, + /* [annotation][out] */ + _Out_ BOOL *pfAtEndOfPayload); + + HRESULT ( STDMETHODCALLTYPE *GetTotalLength )( + IMFHttpDownloadRequest * This, + /* [annotation][out] */ + _Out_ QWORD *pqwTotalLength); + + HRESULT ( STDMETHODCALLTYPE *GetRangeEndOffset )( + IMFHttpDownloadRequest * This, + /* [annotation][out] */ + _Out_ QWORD *pqwRangeEnd); + + HRESULT ( STDMETHODCALLTYPE *Close )( + IMFHttpDownloadRequest * This); + + END_INTERFACE + } IMFHttpDownloadRequestVtbl; + + interface IMFHttpDownloadRequest + { + CONST_VTBL struct IMFHttpDownloadRequestVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFHttpDownloadRequest_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFHttpDownloadRequest_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFHttpDownloadRequest_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFHttpDownloadRequest_AddHeader(This,szHeader) \ + ( (This)->lpVtbl -> AddHeader(This,szHeader) ) + +#define IMFHttpDownloadRequest_BeginSendRequest(This,pbPayload,cbPayload,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginSendRequest(This,pbPayload,cbPayload,pCallback,punkState) ) + +#define IMFHttpDownloadRequest_EndSendRequest(This,pResult) \ + ( (This)->lpVtbl -> EndSendRequest(This,pResult) ) + +#define IMFHttpDownloadRequest_BeginReceiveResponse(This,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginReceiveResponse(This,pCallback,punkState) ) + +#define IMFHttpDownloadRequest_EndReceiveResponse(This,pResult) \ + ( (This)->lpVtbl -> EndReceiveResponse(This,pResult) ) + +#define IMFHttpDownloadRequest_BeginReadPayload(This,pb,cb,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginReadPayload(This,pb,cb,pCallback,punkState) ) + +#define IMFHttpDownloadRequest_EndReadPayload(This,pResult,pqwOffset,pcbRead) \ + ( (This)->lpVtbl -> EndReadPayload(This,pResult,pqwOffset,pcbRead) ) + +#define IMFHttpDownloadRequest_QueryHeader(This,szHeaderName,dwIndex,ppszHeaderValue) \ + ( (This)->lpVtbl -> QueryHeader(This,szHeaderName,dwIndex,ppszHeaderValue) ) + +#define IMFHttpDownloadRequest_GetURL(This,ppszURL) \ + ( (This)->lpVtbl -> GetURL(This,ppszURL) ) + +#define IMFHttpDownloadRequest_HasNullSourceOrigin(This,pfNullSourceOrigin) \ + ( (This)->lpVtbl -> HasNullSourceOrigin(This,pfNullSourceOrigin) ) + +#define IMFHttpDownloadRequest_GetTimeSeekResult(This,pqwStartTime,pqwStopTime,pqwDuration) \ + ( (This)->lpVtbl -> GetTimeSeekResult(This,pqwStartTime,pqwStopTime,pqwDuration) ) + +#define IMFHttpDownloadRequest_GetHttpStatus(This,pdwHttpStatus) \ + ( (This)->lpVtbl -> GetHttpStatus(This,pdwHttpStatus) ) + +#define IMFHttpDownloadRequest_GetAtEndOfPayload(This,pfAtEndOfPayload) \ + ( (This)->lpVtbl -> GetAtEndOfPayload(This,pfAtEndOfPayload) ) + +#define IMFHttpDownloadRequest_GetTotalLength(This,pqwTotalLength) \ + ( (This)->lpVtbl -> GetTotalLength(This,pqwTotalLength) ) + +#define IMFHttpDownloadRequest_GetRangeEndOffset(This,pqwRangeEnd) \ + ( (This)->lpVtbl -> GetRangeEndOffset(This,pqwRangeEnd) ) + +#define IMFHttpDownloadRequest_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFHttpDownloadRequest_INTERFACE_DEFINED__ */ + + +#ifndef __IMFHttpDownloadSession_INTERFACE_DEFINED__ +#define __IMFHttpDownloadSession_INTERFACE_DEFINED__ + +/* interface IMFHttpDownloadSession */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFHttpDownloadSession; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("71FA9A2C-53CE-4662-A132-1A7E8CBF62DB") + IMFHttpDownloadSession : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetServer( + /* [annotation][in] */ + _In_ LPCWSTR szServerName, + /* [annotation][in] */ + _In_ DWORD nPort) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateRequest( + /* [annotation][in] */ + _In_ LPCWSTR szObjectName, + /* [annotation][in] */ + _In_ BOOL fBypassProxyCache, + /* [annotation][in] */ + _In_ BOOL fSecure, + /* [annotation][in] */ + _In_opt_ LPCWSTR szVerb, + /* [annotation][in] */ + _In_opt_ LPCWSTR szReferrer, + /* [annotation][out] */ + _COM_Outptr_ IMFHttpDownloadRequest **ppRequest) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFHttpDownloadSessionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFHttpDownloadSession * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFHttpDownloadSession * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFHttpDownloadSession * This); + + HRESULT ( STDMETHODCALLTYPE *SetServer )( + IMFHttpDownloadSession * This, + /* [annotation][in] */ + _In_ LPCWSTR szServerName, + /* [annotation][in] */ + _In_ DWORD nPort); + + HRESULT ( STDMETHODCALLTYPE *CreateRequest )( + IMFHttpDownloadSession * This, + /* [annotation][in] */ + _In_ LPCWSTR szObjectName, + /* [annotation][in] */ + _In_ BOOL fBypassProxyCache, + /* [annotation][in] */ + _In_ BOOL fSecure, + /* [annotation][in] */ + _In_opt_ LPCWSTR szVerb, + /* [annotation][in] */ + _In_opt_ LPCWSTR szReferrer, + /* [annotation][out] */ + _COM_Outptr_ IMFHttpDownloadRequest **ppRequest); + + HRESULT ( STDMETHODCALLTYPE *Close )( + IMFHttpDownloadSession * This); + + END_INTERFACE + } IMFHttpDownloadSessionVtbl; + + interface IMFHttpDownloadSession + { + CONST_VTBL struct IMFHttpDownloadSessionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFHttpDownloadSession_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFHttpDownloadSession_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFHttpDownloadSession_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFHttpDownloadSession_SetServer(This,szServerName,nPort) \ + ( (This)->lpVtbl -> SetServer(This,szServerName,nPort) ) + +#define IMFHttpDownloadSession_CreateRequest(This,szObjectName,fBypassProxyCache,fSecure,szVerb,szReferrer,ppRequest) \ + ( (This)->lpVtbl -> CreateRequest(This,szObjectName,fBypassProxyCache,fSecure,szVerb,szReferrer,ppRequest) ) + +#define IMFHttpDownloadSession_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFHttpDownloadSession_INTERFACE_DEFINED__ */ + + +#ifndef __IMFHttpDownloadSessionProvider_INTERFACE_DEFINED__ +#define __IMFHttpDownloadSessionProvider_INTERFACE_DEFINED__ + +/* interface IMFHttpDownloadSessionProvider */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFHttpDownloadSessionProvider; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("1B4CF4B9-3A16-4115-839D-03CC5C99DF01") + IMFHttpDownloadSessionProvider : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateHttpDownloadSession( + /* [annotation][in] */ + _In_ LPCWSTR wszScheme, + /* [annotation][out] */ + _COM_Outptr_ IMFHttpDownloadSession **ppDownloadSession) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFHttpDownloadSessionProviderVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFHttpDownloadSessionProvider * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFHttpDownloadSessionProvider * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFHttpDownloadSessionProvider * This); + + HRESULT ( STDMETHODCALLTYPE *CreateHttpDownloadSession )( + IMFHttpDownloadSessionProvider * This, + /* [annotation][in] */ + _In_ LPCWSTR wszScheme, + /* [annotation][out] */ + _COM_Outptr_ IMFHttpDownloadSession **ppDownloadSession); + + END_INTERFACE + } IMFHttpDownloadSessionProviderVtbl; + + interface IMFHttpDownloadSessionProvider + { + CONST_VTBL struct IMFHttpDownloadSessionProviderVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFHttpDownloadSessionProvider_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFHttpDownloadSessionProvider_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFHttpDownloadSessionProvider_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFHttpDownloadSessionProvider_CreateHttpDownloadSession(This,wszScheme,ppDownloadSession) \ + ( (This)->lpVtbl -> CreateHttpDownloadSession(This,wszScheme,ppDownloadSession) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFHttpDownloadSessionProvider_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0107 */ +/* [local] */ + +EXTERN_GUID(MFNETSOURCE_HTTP_DOWNLOAD_SESSION_PROVIDER, 0x7d55081e, 0x307d, 0x4d6d, 0xa6, 0x63, 0xa9, 0x3b, 0xe9, 0x7c, 0x4b, 0x5c); +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WIN10) +typedef +enum MF_MEDIASOURCE_STATUS_INFO + { + MF_MEDIASOURCE_STATUS_INFO_FULLYSUPPORTED = 0, + MF_MEDIASOURCE_STATUS_INFO_UNKNOWN = 1 + } MF_MEDIASOURCE_STATUS_INFO; + +EXTERN_GUID(MF_SD_MEDIASOURCE_STATUS, 0x1913678b, 0xfc0f, 0x44da, 0x8f, 0x43, 0x1b, 0xa3, 0xb5, 0x26, 0xf4, 0xae); +typedef struct _MF_VIDEO_SPHERICAL_VIEWDIRECTION + { + int iHeading; + int iPitch; + int iRoll; + } MF_VIDEO_SPHERICAL_VIEWDIRECTION; + +#define MF_UNKNOWN_DURATION 0 +EXTERN_GUID(MF_SD_VIDEO_SPHERICAL, 0xa51da449, 0x3fdc, 0x478c, 0xbc, 0xb5, 0x30, 0xbe, 0x76, 0x59, 0x5f, 0x55); +EXTERN_GUID(MF_SD_VIDEO_SPHERICAL_FORMAT, 0x4a8fc407, 0x6ea1, 0x46c8, 0xb5, 0x67, 0x69, 0x71, 0xd4, 0xa1, 0x39, 0xc3); +EXTERN_GUID(MF_SD_VIDEO_SPHERICAL_INITIAL_VIEWDIRECTION, 0x11d25a49, 0xbb62, 0x467f, 0x9d, 0xb1, 0xc1, 0x71, 0x65, 0x71, 0x6c, 0x49); +EXTERN_GUID(MF_MEDIASOURCE_EXPOSE_ALL_STREAMS, 0xe7f250b8, 0x8fd9, 0x4a09, 0xb6, 0xc1, 0x6a, 0x31, 0x5c, 0x7c, 0x72, 0xe); + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0107_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0107_v0_0_s_ifspec; + +#ifndef __IMFMediaSource2_INTERFACE_DEFINED__ +#define __IMFMediaSource2_INTERFACE_DEFINED__ + +/* interface IMFMediaSource2 */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaSource2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("FBB03414-D13B-4786-8319-5AC51FC0A136") + IMFMediaSource2 : public IMFMediaSourceEx + { + public: + virtual HRESULT STDMETHODCALLTYPE SetMediaType( + /* [annotation][in] */ + _In_ DWORD dwStreamID, + /* [annotation][in] */ + _In_ IMFMediaType *pMediaType) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaSource2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaSource2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaSource2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaSource2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetEvent )( + IMFMediaSource2 * This, + /* [in] */ DWORD dwFlags, + /* [out] */ IMFMediaEvent **ppEvent); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginGetEvent )( + IMFMediaSource2 * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndGetEvent )( + IMFMediaSource2 * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent); + + HRESULT ( STDMETHODCALLTYPE *QueueEvent )( + IMFMediaSource2 * This, + /* [in] */ MediaEventType met, + /* [in] */ REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ const PROPVARIANT *pvValue); + + HRESULT ( STDMETHODCALLTYPE *GetCharacteristics )( + IMFMediaSource2 * This, + /* [out] */ DWORD *pdwCharacteristics); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *CreatePresentationDescriptor )( + IMFMediaSource2 * This, + /* [annotation][out] */ + _Outptr_ IMFPresentationDescriptor **ppPresentationDescriptor); + + HRESULT ( STDMETHODCALLTYPE *Start )( + IMFMediaSource2 * This, + /* [in] */ IMFPresentationDescriptor *pPresentationDescriptor, + /* [unique][in] */ const GUID *pguidTimeFormat, + /* [unique][in] */ const PROPVARIANT *pvarStartPosition); + + HRESULT ( STDMETHODCALLTYPE *Stop )( + IMFMediaSource2 * This); + + HRESULT ( STDMETHODCALLTYPE *Pause )( + IMFMediaSource2 * This); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + IMFMediaSource2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetSourceAttributes )( + IMFMediaSource2 * This, + /* [out] */ IMFAttributes **ppAttributes); + + HRESULT ( STDMETHODCALLTYPE *GetStreamAttributes )( + IMFMediaSource2 * This, + /* [in] */ DWORD dwStreamIdentifier, + /* [out] */ IMFAttributes **ppAttributes); + + HRESULT ( STDMETHODCALLTYPE *SetD3DManager )( + IMFMediaSource2 * This, + /* [in] */ IUnknown *pManager); + + HRESULT ( STDMETHODCALLTYPE *SetMediaType )( + IMFMediaSource2 * This, + /* [annotation][in] */ + _In_ DWORD dwStreamID, + /* [annotation][in] */ + _In_ IMFMediaType *pMediaType); + + END_INTERFACE + } IMFMediaSource2Vtbl; + + interface IMFMediaSource2 + { + CONST_VTBL struct IMFMediaSource2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaSource2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaSource2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaSource2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaSource2_GetEvent(This,dwFlags,ppEvent) \ + ( (This)->lpVtbl -> GetEvent(This,dwFlags,ppEvent) ) + +#define IMFMediaSource2_BeginGetEvent(This,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginGetEvent(This,pCallback,punkState) ) + +#define IMFMediaSource2_EndGetEvent(This,pResult,ppEvent) \ + ( (This)->lpVtbl -> EndGetEvent(This,pResult,ppEvent) ) + +#define IMFMediaSource2_QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) \ + ( (This)->lpVtbl -> QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) ) + + +#define IMFMediaSource2_GetCharacteristics(This,pdwCharacteristics) \ + ( (This)->lpVtbl -> GetCharacteristics(This,pdwCharacteristics) ) + +#define IMFMediaSource2_CreatePresentationDescriptor(This,ppPresentationDescriptor) \ + ( (This)->lpVtbl -> CreatePresentationDescriptor(This,ppPresentationDescriptor) ) + +#define IMFMediaSource2_Start(This,pPresentationDescriptor,pguidTimeFormat,pvarStartPosition) \ + ( (This)->lpVtbl -> Start(This,pPresentationDescriptor,pguidTimeFormat,pvarStartPosition) ) + +#define IMFMediaSource2_Stop(This) \ + ( (This)->lpVtbl -> Stop(This) ) + +#define IMFMediaSource2_Pause(This) \ + ( (This)->lpVtbl -> Pause(This) ) + +#define IMFMediaSource2_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + + +#define IMFMediaSource2_GetSourceAttributes(This,ppAttributes) \ + ( (This)->lpVtbl -> GetSourceAttributes(This,ppAttributes) ) + +#define IMFMediaSource2_GetStreamAttributes(This,dwStreamIdentifier,ppAttributes) \ + ( (This)->lpVtbl -> GetStreamAttributes(This,dwStreamIdentifier,ppAttributes) ) + +#define IMFMediaSource2_SetD3DManager(This,pManager) \ + ( (This)->lpVtbl -> SetD3DManager(This,pManager) ) + + +#define IMFMediaSource2_SetMediaType(This,dwStreamID,pMediaType) \ + ( (This)->lpVtbl -> SetMediaType(This,dwStreamID,pMediaType) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaSource2_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaStream2_INTERFACE_DEFINED__ +#define __IMFMediaStream2_INTERFACE_DEFINED__ + +/* interface IMFMediaStream2 */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaStream2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C5BC37D6-75C7-46A1-A132-81B5F723C20F") + IMFMediaStream2 : public IMFMediaStream + { + public: + virtual HRESULT STDMETHODCALLTYPE SetStreamState( + /* [annotation][in] */ + _In_ MF_STREAM_STATE value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamState( + /* [annotation][out] */ + _Out_ MF_STREAM_STATE *value) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaStream2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaStream2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaStream2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaStream2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetEvent )( + IMFMediaStream2 * This, + /* [in] */ DWORD dwFlags, + /* [out] */ IMFMediaEvent **ppEvent); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginGetEvent )( + IMFMediaStream2 * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndGetEvent )( + IMFMediaStream2 * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent); + + HRESULT ( STDMETHODCALLTYPE *QueueEvent )( + IMFMediaStream2 * This, + /* [in] */ MediaEventType met, + /* [in] */ REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ const PROPVARIANT *pvValue); + + HRESULT ( STDMETHODCALLTYPE *GetMediaSource )( + IMFMediaStream2 * This, + /* [out] */ IMFMediaSource **ppMediaSource); + + HRESULT ( STDMETHODCALLTYPE *GetStreamDescriptor )( + IMFMediaStream2 * This, + /* [out] */ IMFStreamDescriptor **ppStreamDescriptor); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *RequestSample )( + IMFMediaStream2 * This, + /* [in] */ IUnknown *pToken); + + HRESULT ( STDMETHODCALLTYPE *SetStreamState )( + IMFMediaStream2 * This, + /* [annotation][in] */ + _In_ MF_STREAM_STATE value); + + HRESULT ( STDMETHODCALLTYPE *GetStreamState )( + IMFMediaStream2 * This, + /* [annotation][out] */ + _Out_ MF_STREAM_STATE *value); + + END_INTERFACE + } IMFMediaStream2Vtbl; + + interface IMFMediaStream2 + { + CONST_VTBL struct IMFMediaStream2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaStream2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaStream2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaStream2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaStream2_GetEvent(This,dwFlags,ppEvent) \ + ( (This)->lpVtbl -> GetEvent(This,dwFlags,ppEvent) ) + +#define IMFMediaStream2_BeginGetEvent(This,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginGetEvent(This,pCallback,punkState) ) + +#define IMFMediaStream2_EndGetEvent(This,pResult,ppEvent) \ + ( (This)->lpVtbl -> EndGetEvent(This,pResult,ppEvent) ) + +#define IMFMediaStream2_QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) \ + ( (This)->lpVtbl -> QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) ) + + +#define IMFMediaStream2_GetMediaSource(This,ppMediaSource) \ + ( (This)->lpVtbl -> GetMediaSource(This,ppMediaSource) ) + +#define IMFMediaStream2_GetStreamDescriptor(This,ppStreamDescriptor) \ + ( (This)->lpVtbl -> GetStreamDescriptor(This,ppStreamDescriptor) ) + +#define IMFMediaStream2_RequestSample(This,pToken) \ + ( (This)->lpVtbl -> RequestSample(This,pToken) ) + + +#define IMFMediaStream2_SetStreamState(This,value) \ + ( (This)->lpVtbl -> SetStreamState(This,value) ) + +#define IMFMediaStream2_GetStreamState(This,value) \ + ( (This)->lpVtbl -> GetStreamState(This,value) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaStream2_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0109 */ +/* [local] */ + +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_GUID(MF_ST_MEDIASOURCE_COLLECTION, 0x616DE972, 0x83AD, 0x4950, 0x81, 0x70, 0x63, 0x0D, 0x19, 0xCB, 0xE3, 0x07); +EXTERN_GUID(MF_DEVICESTREAM_FILTER_KSCONTROL, 0x46783CCA, 0x3DF5, 0x4923, 0xA9, 0xEF, 0x36, 0xB7, 0x22, 0x3E, 0xDD, 0xE0); +EXTERN_GUID(MF_DEVICESTREAM_PIN_KSCONTROL, 0xEF3EF9A7, 0x87F2, 0x48CA, 0xBE, 0x02, 0x67, 0x48, 0x78, 0x91, 0x8E, 0x98); +EXTERN_GUID(MF_DEVICESTREAM_SOURCE_ATTRIBUTES, 0x2F8CB617, 0x361B, 0x434F, 0x85, 0xEA, 0x99, 0xA0, 0x3E, 0x1C, 0xE4, 0xE0); +EXTERN_GUID( MF_DEVICESTREAM_FRAMESERVER_HIDDEN, 0xF402567B, 0x4D91, 0x4179, 0x96, 0xD1, 0x74, 0xC8, 0x48, 0x0C, 0x20, 0x34); +EXTERN_GUID( MF_STF_VERSION_INFO, 0x6770BD39, 0xEF82, 0x44EE, 0xA4, 0x9B, 0x93, 0x4B, 0xEB, 0x24, 0xAE, 0xF7); +EXTERN_GUID( MF_STF_VERSION_DATE, 0x31A165D5, 0xDF67, 0x4095, 0x8E, 0x44, 0x88, 0x68, 0xFC, 0x20, 0xDB, 0xFD); +EXTERN_GUID( MF_DEVICESTREAM_REQUIRED_CAPABILITIES, 0x6D8B957E, 0x7CF6, 0x43F4, 0xAF, 0x56, 0x9C, 0x0E, 0x1E, 0x4F, 0xCB, 0xE1); +EXTERN_GUID( MF_DEVICESTREAM_REQUIRED_SDDL, 0x331AE85D, 0xC0D3, 0x49BA, 0x83, 0xBA, 0x82, 0xA1, 0x2D, 0x63, 0xCD, 0xD6); +EXTERN_GUID(MF_DEVICEMFT_SENSORPROFILE_COLLECTION, 0x36EBDC44, 0xB12C, 0x441B, 0x89, 0xF4, 0x08, 0xB2, 0xF4, 0x1A, 0x9C, 0xFC ); +EXTERN_GUID(MF_DEVICESTREAM_SENSORSTREAM_ID, 0xE35B9FE4, 0x0659, 0x4CAD, 0xBB, 0x51, 0x33, 0x16, 0x0B, 0xE7, 0xE4, 0x13 ); +typedef /* [public][public] */ +enum __MIDL___MIDL_itf_mfidl_0000_0109_0001 + { + MFSensorDeviceType_Unknown = 0, + MFSensorDeviceType_Device = ( MFSensorDeviceType_Unknown + 1 ) , + MFSensorDeviceType_MediaSource = ( MFSensorDeviceType_Device + 1 ) , + MFSensorDeviceType_FrameProvider = ( MFSensorDeviceType_MediaSource + 1 ) , + MFSensorDeviceType_SensorTransform = ( MFSensorDeviceType_FrameProvider + 1 ) + } MFSensorDeviceType; + +typedef /* [public][public][public] */ +enum __MIDL___MIDL_itf_mfidl_0000_0109_0002 + { + MFSensorStreamType_Unknown = 0, + MFSensorStreamType_Input = ( MFSensorStreamType_Unknown + 1 ) , + MFSensorStreamType_Output = ( MFSensorStreamType_Input + 1 ) + } MFSensorStreamType; + +typedef /* [public][public][public][public] */ +enum __MIDL___MIDL_itf_mfidl_0000_0109_0003 + { + MFSensorDeviceMode_Controller = 0, + MFSensorDeviceMode_Shared = ( MFSensorDeviceMode_Controller + 1 ) + } MFSensorDeviceMode; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0109_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0109_v0_0_s_ifspec; + +#ifndef __IMFSensorDevice_INTERFACE_DEFINED__ +#define __IMFSensorDevice_INTERFACE_DEFINED__ + +/* interface IMFSensorDevice */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFSensorDevice; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("FB9F48F2-2A18-4E28-9730-786F30F04DC4") + IMFSensorDevice : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetDeviceId( + /* [annotation][out] */ + _Out_ ULONGLONG *pDeviceId) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDeviceType( + /* [annotation][out] */ + _Out_ MFSensorDeviceType *pType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlags( + /* [annotation][out] */ + _Out_ ULONGLONG *pFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSymbolicLink( + /* [annotation][size_is][out] */ + _Out_writes_z_(cchSymbolicLink) LPWSTR SymbolicLink, + /* [annotation][in] */ + _In_ LONG cchSymbolicLink, + /* [annotation][out] */ + _Out_ LONG *pcchWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDeviceAttributes( + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFAttributes **ppAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamAttributesCount( + /* [annotation][in] */ + _In_ MFSensorStreamType eType, + /* [annotation][out] */ + _Out_ DWORD *pdwCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamAttributes( + /* [annotation][in] */ + _In_ MFSensorStreamType eType, + /* [annotation][in] */ + _In_ DWORD dwIndex, + /* [annotation][out] */ + _COM_Outptr_ IMFAttributes **ppAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSensorDeviceMode( + /* [annotation][in] */ + _In_ MFSensorDeviceMode eMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSensorDeviceMode( + /* [annotation][out] */ + _Out_ MFSensorDeviceMode *peMode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSensorDeviceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSensorDevice * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSensorDevice * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSensorDevice * This); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceId )( + IMFSensorDevice * This, + /* [annotation][out] */ + _Out_ ULONGLONG *pDeviceId); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceType )( + IMFSensorDevice * This, + /* [annotation][out] */ + _Out_ MFSensorDeviceType *pType); + + HRESULT ( STDMETHODCALLTYPE *GetFlags )( + IMFSensorDevice * This, + /* [annotation][out] */ + _Out_ ULONGLONG *pFlags); + + HRESULT ( STDMETHODCALLTYPE *GetSymbolicLink )( + IMFSensorDevice * This, + /* [annotation][size_is][out] */ + _Out_writes_z_(cchSymbolicLink) LPWSTR SymbolicLink, + /* [annotation][in] */ + _In_ LONG cchSymbolicLink, + /* [annotation][out] */ + _Out_ LONG *pcchWritten); + + HRESULT ( STDMETHODCALLTYPE *GetDeviceAttributes )( + IMFSensorDevice * This, + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFAttributes **ppAttributes); + + HRESULT ( STDMETHODCALLTYPE *GetStreamAttributesCount )( + IMFSensorDevice * This, + /* [annotation][in] */ + _In_ MFSensorStreamType eType, + /* [annotation][out] */ + _Out_ DWORD *pdwCount); + + HRESULT ( STDMETHODCALLTYPE *GetStreamAttributes )( + IMFSensorDevice * This, + /* [annotation][in] */ + _In_ MFSensorStreamType eType, + /* [annotation][in] */ + _In_ DWORD dwIndex, + /* [annotation][out] */ + _COM_Outptr_ IMFAttributes **ppAttributes); + + HRESULT ( STDMETHODCALLTYPE *SetSensorDeviceMode )( + IMFSensorDevice * This, + /* [annotation][in] */ + _In_ MFSensorDeviceMode eMode); + + HRESULT ( STDMETHODCALLTYPE *GetSensorDeviceMode )( + IMFSensorDevice * This, + /* [annotation][out] */ + _Out_ MFSensorDeviceMode *peMode); + + END_INTERFACE + } IMFSensorDeviceVtbl; + + interface IMFSensorDevice + { + CONST_VTBL struct IMFSensorDeviceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSensorDevice_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSensorDevice_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSensorDevice_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSensorDevice_GetDeviceId(This,pDeviceId) \ + ( (This)->lpVtbl -> GetDeviceId(This,pDeviceId) ) + +#define IMFSensorDevice_GetDeviceType(This,pType) \ + ( (This)->lpVtbl -> GetDeviceType(This,pType) ) + +#define IMFSensorDevice_GetFlags(This,pFlags) \ + ( (This)->lpVtbl -> GetFlags(This,pFlags) ) + +#define IMFSensorDevice_GetSymbolicLink(This,SymbolicLink,cchSymbolicLink,pcchWritten) \ + ( (This)->lpVtbl -> GetSymbolicLink(This,SymbolicLink,cchSymbolicLink,pcchWritten) ) + +#define IMFSensorDevice_GetDeviceAttributes(This,ppAttributes) \ + ( (This)->lpVtbl -> GetDeviceAttributes(This,ppAttributes) ) + +#define IMFSensorDevice_GetStreamAttributesCount(This,eType,pdwCount) \ + ( (This)->lpVtbl -> GetStreamAttributesCount(This,eType,pdwCount) ) + +#define IMFSensorDevice_GetStreamAttributes(This,eType,dwIndex,ppAttributes) \ + ( (This)->lpVtbl -> GetStreamAttributes(This,eType,dwIndex,ppAttributes) ) + +#define IMFSensorDevice_SetSensorDeviceMode(This,eMode) \ + ( (This)->lpVtbl -> SetSensorDeviceMode(This,eMode) ) + +#define IMFSensorDevice_GetSensorDeviceMode(This,peMode) \ + ( (This)->lpVtbl -> GetSensorDeviceMode(This,peMode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSensorDevice_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSensorGroup_INTERFACE_DEFINED__ +#define __IMFSensorGroup_INTERFACE_DEFINED__ + +/* interface IMFSensorGroup */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFSensorGroup; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("4110243A-9757-461F-89F1-F22345BCAB4E") + IMFSensorGroup : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetSymbolicLink( + /* [annotation][size_is][out] */ + _Out_writes_z_(cchSymbolicLink) LPWSTR SymbolicLink, + /* [annotation][in] */ + _In_ LONG cchSymbolicLink, + /* [annotation][out] */ + _Out_ LONG *pcchWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFlags( + /* [annotation][out] */ + _Out_ ULONGLONG *pFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSensorGroupAttributes( + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFAttributes **ppAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSensorDeviceCount( + /* [annotation][out] */ + _Out_ DWORD *pdwCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSensorDevice( + /* [annotation][in] */ + _In_ DWORD dwIndex, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorDevice **ppDevice) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDefaultSensorDeviceIndex( + /* [annotation][in] */ + _In_ DWORD dwIndex) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDefaultSensorDeviceIndex( + /* [annotation][out] */ + _Out_ DWORD *pdwIndex) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateMediaSource( + /* [annotation][out] */ + _COM_Outptr_ IMFMediaSource **ppSource) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSensorGroupVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSensorGroup * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSensorGroup * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSensorGroup * This); + + HRESULT ( STDMETHODCALLTYPE *GetSymbolicLink )( + IMFSensorGroup * This, + /* [annotation][size_is][out] */ + _Out_writes_z_(cchSymbolicLink) LPWSTR SymbolicLink, + /* [annotation][in] */ + _In_ LONG cchSymbolicLink, + /* [annotation][out] */ + _Out_ LONG *pcchWritten); + + HRESULT ( STDMETHODCALLTYPE *GetFlags )( + IMFSensorGroup * This, + /* [annotation][out] */ + _Out_ ULONGLONG *pFlags); + + HRESULT ( STDMETHODCALLTYPE *GetSensorGroupAttributes )( + IMFSensorGroup * This, + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFAttributes **ppAttributes); + + HRESULT ( STDMETHODCALLTYPE *GetSensorDeviceCount )( + IMFSensorGroup * This, + /* [annotation][out] */ + _Out_ DWORD *pdwCount); + + HRESULT ( STDMETHODCALLTYPE *GetSensorDevice )( + IMFSensorGroup * This, + /* [annotation][in] */ + _In_ DWORD dwIndex, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorDevice **ppDevice); + + HRESULT ( STDMETHODCALLTYPE *SetDefaultSensorDeviceIndex )( + IMFSensorGroup * This, + /* [annotation][in] */ + _In_ DWORD dwIndex); + + HRESULT ( STDMETHODCALLTYPE *GetDefaultSensorDeviceIndex )( + IMFSensorGroup * This, + /* [annotation][out] */ + _Out_ DWORD *pdwIndex); + + HRESULT ( STDMETHODCALLTYPE *CreateMediaSource )( + IMFSensorGroup * This, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaSource **ppSource); + + END_INTERFACE + } IMFSensorGroupVtbl; + + interface IMFSensorGroup + { + CONST_VTBL struct IMFSensorGroupVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSensorGroup_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSensorGroup_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSensorGroup_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSensorGroup_GetSymbolicLink(This,SymbolicLink,cchSymbolicLink,pcchWritten) \ + ( (This)->lpVtbl -> GetSymbolicLink(This,SymbolicLink,cchSymbolicLink,pcchWritten) ) + +#define IMFSensorGroup_GetFlags(This,pFlags) \ + ( (This)->lpVtbl -> GetFlags(This,pFlags) ) + +#define IMFSensorGroup_GetSensorGroupAttributes(This,ppAttributes) \ + ( (This)->lpVtbl -> GetSensorGroupAttributes(This,ppAttributes) ) + +#define IMFSensorGroup_GetSensorDeviceCount(This,pdwCount) \ + ( (This)->lpVtbl -> GetSensorDeviceCount(This,pdwCount) ) + +#define IMFSensorGroup_GetSensorDevice(This,dwIndex,ppDevice) \ + ( (This)->lpVtbl -> GetSensorDevice(This,dwIndex,ppDevice) ) + +#define IMFSensorGroup_SetDefaultSensorDeviceIndex(This,dwIndex) \ + ( (This)->lpVtbl -> SetDefaultSensorDeviceIndex(This,dwIndex) ) + +#define IMFSensorGroup_GetDefaultSensorDeviceIndex(This,pdwIndex) \ + ( (This)->lpVtbl -> GetDefaultSensorDeviceIndex(This,pdwIndex) ) + +#define IMFSensorGroup_CreateMediaSource(This,ppSource) \ + ( (This)->lpVtbl -> CreateMediaSource(This,ppSource) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSensorGroup_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSensorStream_INTERFACE_DEFINED__ +#define __IMFSensorStream_INTERFACE_DEFINED__ + +/* interface IMFSensorStream */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFSensorStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("E9A42171-C56E-498A-8B39-EDA5A070B7FC") + IMFSensorStream : public IMFAttributes + { + public: + virtual HRESULT STDMETHODCALLTYPE GetMediaTypeCount( + /* [annotation][out] */ + _Out_ DWORD *pdwCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMediaType( + /* [annotation][in] */ + _In_ DWORD dwIndex, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaType **ppMediaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE CloneSensorStream( + /* [annotation][out] */ + _COM_Outptr_ IMFSensorStream **ppStream) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSensorStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSensorStream * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSensorStream * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSensorStream * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + IMFSensorStream * This, + REFGUID guidKey, + /* [full][out][in] */ PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + IMFSensorStream * This, + REFGUID guidKey, + /* [out] */ MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + IMFSensorStream * This, + REFGUID guidKey, + REFPROPVARIANT Value, + /* [out] */ BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + IMFSensorStream * This, + IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + IMFSensorStream * This, + REFGUID guidKey, + /* [out] */ UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + IMFSensorStream * This, + REFGUID guidKey, + /* [out] */ UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + IMFSensorStream * This, + REFGUID guidKey, + /* [out] */ double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + IMFSensorStream * This, + REFGUID guidKey, + /* [out] */ GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + IMFSensorStream * This, + REFGUID guidKey, + /* [out] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IMFSensorStream * This, + REFGUID guidKey, + /* [size_is][out] */ LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + IMFSensorStream * This, + REFGUID guidKey, + /* [size_is][size_is][out] */ LPWSTR *ppwszValue, + /* [out] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + IMFSensorStream * This, + REFGUID guidKey, + /* [out] */ UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + IMFSensorStream * This, + REFGUID guidKey, + /* [size_is][out] */ UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + IMFSensorStream * This, + REFGUID guidKey, + /* [size_is][size_is][out] */ UINT8 **ppBuf, + /* [out] */ UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + IMFSensorStream * This, + REFGUID guidKey, + REFIID riid, + /* [iid_is][out] */ LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + IMFSensorStream * This, + REFGUID guidKey, + REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + IMFSensorStream * This, + REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + IMFSensorStream * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + IMFSensorStream * This, + REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + IMFSensorStream * This, + REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + IMFSensorStream * This, + REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + IMFSensorStream * This, + REFGUID guidKey, + REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + IMFSensorStream * This, + REFGUID guidKey, + /* [string][in] */ LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + IMFSensorStream * This, + REFGUID guidKey, + /* [size_is][in] */ const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + IMFSensorStream * This, + REFGUID guidKey, + /* [in] */ IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + IMFSensorStream * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + IMFSensorStream * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + IMFSensorStream * This, + /* [out] */ UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + IMFSensorStream * This, + UINT32 unIndex, + /* [out] */ GUID *pguidKey, + /* [full][out][in] */ PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + IMFSensorStream * This, + /* [in] */ IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *GetMediaTypeCount )( + IMFSensorStream * This, + /* [annotation][out] */ + _Out_ DWORD *pdwCount); + + HRESULT ( STDMETHODCALLTYPE *GetMediaType )( + IMFSensorStream * This, + /* [annotation][in] */ + _In_ DWORD dwIndex, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaType **ppMediaType); + + HRESULT ( STDMETHODCALLTYPE *CloneSensorStream )( + IMFSensorStream * This, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorStream **ppStream); + + END_INTERFACE + } IMFSensorStreamVtbl; + + interface IMFSensorStream + { + CONST_VTBL struct IMFSensorStreamVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSensorStream_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSensorStream_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSensorStream_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSensorStream_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFSensorStream_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFSensorStream_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFSensorStream_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFSensorStream_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFSensorStream_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFSensorStream_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFSensorStream_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFSensorStream_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFSensorStream_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFSensorStream_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFSensorStream_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFSensorStream_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFSensorStream_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFSensorStream_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFSensorStream_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFSensorStream_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFSensorStream_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFSensorStream_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFSensorStream_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFSensorStream_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFSensorStream_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFSensorStream_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFSensorStream_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFSensorStream_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFSensorStream_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFSensorStream_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFSensorStream_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFSensorStream_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFSensorStream_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFSensorStream_GetMediaTypeCount(This,pdwCount) \ + ( (This)->lpVtbl -> GetMediaTypeCount(This,pdwCount) ) + +#define IMFSensorStream_GetMediaType(This,dwIndex,ppMediaType) \ + ( (This)->lpVtbl -> GetMediaType(This,dwIndex,ppMediaType) ) + +#define IMFSensorStream_CloneSensorStream(This,ppStream) \ + ( (This)->lpVtbl -> CloneSensorStream(This,ppStream) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSensorStream_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSensorTransformFactory_INTERFACE_DEFINED__ +#define __IMFSensorTransformFactory_INTERFACE_DEFINED__ + +/* interface IMFSensorTransformFactory */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFSensorTransformFactory; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("EED9C2EE-66B4-4F18-A697-AC7D3960215C") + IMFSensorTransformFactory : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetFactoryAttributes( + /* [annotation][out] */ + _COM_Outptr_ IMFAttributes **ppAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE InitializeFactory( + /* [annotation][in] */ + _In_ DWORD dwMaxTransformCount, + /* [annotation][in] */ + _In_ IMFCollection *pSensorDevices, + /* [annotation][in] */ + _In_opt_ IMFAttributes *pAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTransformCount( + /* [annotation][out] */ + _Out_ DWORD *pdwCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTransformInformation( + /* [annotation][in] */ + _In_ DWORD TransformIndex, + /* [annotation][out] */ + _Out_ GUID *pguidTransformId, + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFAttributes **ppAttributes, + /* [annotation][out] */ + _COM_Outptr_ IMFCollection **ppStreamInformation) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateTransform( + /* [annotation][in] */ + _In_ REFGUID guidSensorTransformID, + /* [annotation][in] */ + _In_opt_ IMFAttributes *pAttributes, + /* [annotation][out] */ + _COM_Outptr_ IMFDeviceTransform **ppDeviceMFT) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSensorTransformFactoryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSensorTransformFactory * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSensorTransformFactory * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSensorTransformFactory * This); + + HRESULT ( STDMETHODCALLTYPE *GetFactoryAttributes )( + IMFSensorTransformFactory * This, + /* [annotation][out] */ + _COM_Outptr_ IMFAttributes **ppAttributes); + + HRESULT ( STDMETHODCALLTYPE *InitializeFactory )( + IMFSensorTransformFactory * This, + /* [annotation][in] */ + _In_ DWORD dwMaxTransformCount, + /* [annotation][in] */ + _In_ IMFCollection *pSensorDevices, + /* [annotation][in] */ + _In_opt_ IMFAttributes *pAttributes); + + HRESULT ( STDMETHODCALLTYPE *GetTransformCount )( + IMFSensorTransformFactory * This, + /* [annotation][out] */ + _Out_ DWORD *pdwCount); + + HRESULT ( STDMETHODCALLTYPE *GetTransformInformation )( + IMFSensorTransformFactory * This, + /* [annotation][in] */ + _In_ DWORD TransformIndex, + /* [annotation][out] */ + _Out_ GUID *pguidTransformId, + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFAttributes **ppAttributes, + /* [annotation][out] */ + _COM_Outptr_ IMFCollection **ppStreamInformation); + + HRESULT ( STDMETHODCALLTYPE *CreateTransform )( + IMFSensorTransformFactory * This, + /* [annotation][in] */ + _In_ REFGUID guidSensorTransformID, + /* [annotation][in] */ + _In_opt_ IMFAttributes *pAttributes, + /* [annotation][out] */ + _COM_Outptr_ IMFDeviceTransform **ppDeviceMFT); + + END_INTERFACE + } IMFSensorTransformFactoryVtbl; + + interface IMFSensorTransformFactory + { + CONST_VTBL struct IMFSensorTransformFactoryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSensorTransformFactory_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSensorTransformFactory_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSensorTransformFactory_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSensorTransformFactory_GetFactoryAttributes(This,ppAttributes) \ + ( (This)->lpVtbl -> GetFactoryAttributes(This,ppAttributes) ) + +#define IMFSensorTransformFactory_InitializeFactory(This,dwMaxTransformCount,pSensorDevices,pAttributes) \ + ( (This)->lpVtbl -> InitializeFactory(This,dwMaxTransformCount,pSensorDevices,pAttributes) ) + +#define IMFSensorTransformFactory_GetTransformCount(This,pdwCount) \ + ( (This)->lpVtbl -> GetTransformCount(This,pdwCount) ) + +#define IMFSensorTransformFactory_GetTransformInformation(This,TransformIndex,pguidTransformId,ppAttributes,ppStreamInformation) \ + ( (This)->lpVtbl -> GetTransformInformation(This,TransformIndex,pguidTransformId,ppAttributes,ppStreamInformation) ) + +#define IMFSensorTransformFactory_CreateTransform(This,guidSensorTransformID,pAttributes,ppDeviceMFT) \ + ( (This)->lpVtbl -> CreateTransform(This,guidSensorTransformID,pAttributes,ppDeviceMFT) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSensorTransformFactory_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0113 */ +/* [local] */ + +STDAPI +MFCreateSensorGroup( + _In_z_ LPCWSTR SensorGroupSymbolicLink, + _COM_Outptr_ IMFSensorGroup** ppSensorGroup + ); + +STDAPI +MFCreateSensorStream( + _In_ DWORD StreamId, + _In_opt_ IMFAttributes* pAttributes, + _In_ IMFCollection* pMediaTypeCollection, + _COM_Outptr_ IMFSensorStream** ppStream + ); + +typedef /* [public][public][public][public] */ struct __MIDL___MIDL_itf_mfidl_0000_0113_0001 + { + GUID Type; + UINT32 Index; + UINT32 Unused; + } SENSORPROFILEID; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0113_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0113_v0_0_s_ifspec; + +#ifndef __IMFSensorProfile_INTERFACE_DEFINED__ +#define __IMFSensorProfile_INTERFACE_DEFINED__ + +/* interface IMFSensorProfile */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFSensorProfile; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("22F765D1-8DAB-4107-846D-56BAF72215E7") + IMFSensorProfile : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetProfileId( + /* [annotation][out] */ + _Out_ SENSORPROFILEID *pId) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddProfileFilter( + /* [annotation][in] */ + _In_ UINT32 StreamId, + /* [annotation][in] */ + _In_z_ LPCWSTR wzFilterSetString) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsMediaTypeSupported( + /* [annotation][in] */ + _In_ UINT32 StreamId, + /* [annotation][in] */ + _In_ IMFMediaType *pMediaType, + /* [annotation][out] */ + _Out_ BOOL *pfSupported) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddBlockedControl( + /* [annotation][in] */ + _In_z_ LPCWSTR wzBlockedControl) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSensorProfileVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSensorProfile * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSensorProfile * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSensorProfile * This); + + HRESULT ( STDMETHODCALLTYPE *GetProfileId )( + IMFSensorProfile * This, + /* [annotation][out] */ + _Out_ SENSORPROFILEID *pId); + + HRESULT ( STDMETHODCALLTYPE *AddProfileFilter )( + IMFSensorProfile * This, + /* [annotation][in] */ + _In_ UINT32 StreamId, + /* [annotation][in] */ + _In_z_ LPCWSTR wzFilterSetString); + + HRESULT ( STDMETHODCALLTYPE *IsMediaTypeSupported )( + IMFSensorProfile * This, + /* [annotation][in] */ + _In_ UINT32 StreamId, + /* [annotation][in] */ + _In_ IMFMediaType *pMediaType, + /* [annotation][out] */ + _Out_ BOOL *pfSupported); + + HRESULT ( STDMETHODCALLTYPE *AddBlockedControl )( + IMFSensorProfile * This, + /* [annotation][in] */ + _In_z_ LPCWSTR wzBlockedControl); + + END_INTERFACE + } IMFSensorProfileVtbl; + + interface IMFSensorProfile + { + CONST_VTBL struct IMFSensorProfileVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSensorProfile_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSensorProfile_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSensorProfile_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSensorProfile_GetProfileId(This,pId) \ + ( (This)->lpVtbl -> GetProfileId(This,pId) ) + +#define IMFSensorProfile_AddProfileFilter(This,StreamId,wzFilterSetString) \ + ( (This)->lpVtbl -> AddProfileFilter(This,StreamId,wzFilterSetString) ) + +#define IMFSensorProfile_IsMediaTypeSupported(This,StreamId,pMediaType,pfSupported) \ + ( (This)->lpVtbl -> IsMediaTypeSupported(This,StreamId,pMediaType,pfSupported) ) + +#define IMFSensorProfile_AddBlockedControl(This,wzBlockedControl) \ + ( (This)->lpVtbl -> AddBlockedControl(This,wzBlockedControl) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSensorProfile_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSensorProfileCollection_INTERFACE_DEFINED__ +#define __IMFSensorProfileCollection_INTERFACE_DEFINED__ + +/* interface IMFSensorProfileCollection */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFSensorProfileCollection; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C95EA55B-0187-48BE-9353-8D2507662351") + IMFSensorProfileCollection : public IUnknown + { + public: + virtual DWORD STDMETHODCALLTYPE GetProfileCount( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetProfile( + /* [annotation][in] */ + _In_ DWORD Index, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorProfile **ppProfile) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddProfile( + /* [annotation][in] */ + _In_ IMFSensorProfile *pProfile) = 0; + + virtual HRESULT STDMETHODCALLTYPE FindProfile( + /* [annotation][in] */ + _In_ SENSORPROFILEID *ProfileId, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorProfile **ppProfile) = 0; + + virtual void STDMETHODCALLTYPE RemoveProfileByIndex( + /* [annotation][in] */ + _In_ DWORD Index) = 0; + + virtual void STDMETHODCALLTYPE RemoveProfile( + /* [annotation][in] */ + _In_ SENSORPROFILEID *ProfileId) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSensorProfileCollectionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSensorProfileCollection * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSensorProfileCollection * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSensorProfileCollection * This); + + DWORD ( STDMETHODCALLTYPE *GetProfileCount )( + IMFSensorProfileCollection * This); + + HRESULT ( STDMETHODCALLTYPE *GetProfile )( + IMFSensorProfileCollection * This, + /* [annotation][in] */ + _In_ DWORD Index, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorProfile **ppProfile); + + HRESULT ( STDMETHODCALLTYPE *AddProfile )( + IMFSensorProfileCollection * This, + /* [annotation][in] */ + _In_ IMFSensorProfile *pProfile); + + HRESULT ( STDMETHODCALLTYPE *FindProfile )( + IMFSensorProfileCollection * This, + /* [annotation][in] */ + _In_ SENSORPROFILEID *ProfileId, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorProfile **ppProfile); + + void ( STDMETHODCALLTYPE *RemoveProfileByIndex )( + IMFSensorProfileCollection * This, + /* [annotation][in] */ + _In_ DWORD Index); + + void ( STDMETHODCALLTYPE *RemoveProfile )( + IMFSensorProfileCollection * This, + /* [annotation][in] */ + _In_ SENSORPROFILEID *ProfileId); + + END_INTERFACE + } IMFSensorProfileCollectionVtbl; + + interface IMFSensorProfileCollection + { + CONST_VTBL struct IMFSensorProfileCollectionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSensorProfileCollection_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSensorProfileCollection_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSensorProfileCollection_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSensorProfileCollection_GetProfileCount(This) \ + ( (This)->lpVtbl -> GetProfileCount(This) ) + +#define IMFSensorProfileCollection_GetProfile(This,Index,ppProfile) \ + ( (This)->lpVtbl -> GetProfile(This,Index,ppProfile) ) + +#define IMFSensorProfileCollection_AddProfile(This,pProfile) \ + ( (This)->lpVtbl -> AddProfile(This,pProfile) ) + +#define IMFSensorProfileCollection_FindProfile(This,ProfileId,ppProfile) \ + ( (This)->lpVtbl -> FindProfile(This,ProfileId,ppProfile) ) + +#define IMFSensorProfileCollection_RemoveProfileByIndex(This,Index) \ + ( (This)->lpVtbl -> RemoveProfileByIndex(This,Index) ) + +#define IMFSensorProfileCollection_RemoveProfile(This,ProfileId) \ + ( (This)->lpVtbl -> RemoveProfile(This,ProfileId) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSensorProfileCollection_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0115 */ +/* [local] */ + +STDAPI +MFCreateSensorProfile( + _In_ REFGUID ProfileType, + _In_ UINT32 ProfileIndex, + _In_opt_z_ LPCWSTR Constraints, + _COM_Outptr_ IMFSensorProfile** ppProfile + ); +STDAPI +MFCreateSensorProfileCollection( + _COM_Outptr_ IMFSensorProfileCollection** ppSensorProfile + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0115_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0115_v0_0_s_ifspec; + +#ifndef __IMFSensorProcessActivity_INTERFACE_DEFINED__ +#define __IMFSensorProcessActivity_INTERFACE_DEFINED__ + +/* interface IMFSensorProcessActivity */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFSensorProcessActivity; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("39DC7F4A-B141-4719-813C-A7F46162A2B8") + IMFSensorProcessActivity : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetProcessId( + /* [annotation][out] */ + _Out_ ULONG *pPID) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamingState( + /* [annotation][out] */ + _Out_ BOOL *pfStreaming) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamingMode( + /* [annotation][out] */ + _Out_ MFSensorDeviceMode *pMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetReportTime( + /* [annotation][out] */ + _Out_ FILETIME *pft) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSensorProcessActivityVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSensorProcessActivity * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSensorProcessActivity * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSensorProcessActivity * This); + + HRESULT ( STDMETHODCALLTYPE *GetProcessId )( + IMFSensorProcessActivity * This, + /* [annotation][out] */ + _Out_ ULONG *pPID); + + HRESULT ( STDMETHODCALLTYPE *GetStreamingState )( + IMFSensorProcessActivity * This, + /* [annotation][out] */ + _Out_ BOOL *pfStreaming); + + HRESULT ( STDMETHODCALLTYPE *GetStreamingMode )( + IMFSensorProcessActivity * This, + /* [annotation][out] */ + _Out_ MFSensorDeviceMode *pMode); + + HRESULT ( STDMETHODCALLTYPE *GetReportTime )( + IMFSensorProcessActivity * This, + /* [annotation][out] */ + _Out_ FILETIME *pft); + + END_INTERFACE + } IMFSensorProcessActivityVtbl; + + interface IMFSensorProcessActivity + { + CONST_VTBL struct IMFSensorProcessActivityVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSensorProcessActivity_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSensorProcessActivity_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSensorProcessActivity_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSensorProcessActivity_GetProcessId(This,pPID) \ + ( (This)->lpVtbl -> GetProcessId(This,pPID) ) + +#define IMFSensorProcessActivity_GetStreamingState(This,pfStreaming) \ + ( (This)->lpVtbl -> GetStreamingState(This,pfStreaming) ) + +#define IMFSensorProcessActivity_GetStreamingMode(This,pMode) \ + ( (This)->lpVtbl -> GetStreamingMode(This,pMode) ) + +#define IMFSensorProcessActivity_GetReportTime(This,pft) \ + ( (This)->lpVtbl -> GetReportTime(This,pft) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSensorProcessActivity_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSensorActivityReport_INTERFACE_DEFINED__ +#define __IMFSensorActivityReport_INTERFACE_DEFINED__ + +/* interface IMFSensorActivityReport */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFSensorActivityReport; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3E8C4BE1-A8C2-4528-90DE-2851BDE5FEAD") + IMFSensorActivityReport : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetFriendlyName( + /* [annotation][size_is][out] */ + _Out_writes_z_(cchFriendlyName) LPWSTR FriendlyName, + /* [annotation][in] */ + _In_ ULONG cchFriendlyName, + /* [annotation][out] */ + _Out_ ULONG *pcchWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSymbolicLink( + /* [annotation][size_is][out] */ + _Out_writes_z_(cchSymbolicLink) LPWSTR SymbolicLink, + /* [annotation][in] */ + _In_ ULONG cchSymbolicLink, + /* [annotation][out] */ + _Out_ ULONG *pcchWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetProcessCount( + /* [annotation][out] */ + _Out_ ULONG *pcCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetProcessActivity( + /* [annotation][in] */ + _In_ ULONG Index, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorProcessActivity **ppProcessActivity) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSensorActivityReportVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSensorActivityReport * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSensorActivityReport * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSensorActivityReport * This); + + HRESULT ( STDMETHODCALLTYPE *GetFriendlyName )( + IMFSensorActivityReport * This, + /* [annotation][size_is][out] */ + _Out_writes_z_(cchFriendlyName) LPWSTR FriendlyName, + /* [annotation][in] */ + _In_ ULONG cchFriendlyName, + /* [annotation][out] */ + _Out_ ULONG *pcchWritten); + + HRESULT ( STDMETHODCALLTYPE *GetSymbolicLink )( + IMFSensorActivityReport * This, + /* [annotation][size_is][out] */ + _Out_writes_z_(cchSymbolicLink) LPWSTR SymbolicLink, + /* [annotation][in] */ + _In_ ULONG cchSymbolicLink, + /* [annotation][out] */ + _Out_ ULONG *pcchWritten); + + HRESULT ( STDMETHODCALLTYPE *GetProcessCount )( + IMFSensorActivityReport * This, + /* [annotation][out] */ + _Out_ ULONG *pcCount); + + HRESULT ( STDMETHODCALLTYPE *GetProcessActivity )( + IMFSensorActivityReport * This, + /* [annotation][in] */ + _In_ ULONG Index, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorProcessActivity **ppProcessActivity); + + END_INTERFACE + } IMFSensorActivityReportVtbl; + + interface IMFSensorActivityReport + { + CONST_VTBL struct IMFSensorActivityReportVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSensorActivityReport_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSensorActivityReport_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSensorActivityReport_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSensorActivityReport_GetFriendlyName(This,FriendlyName,cchFriendlyName,pcchWritten) \ + ( (This)->lpVtbl -> GetFriendlyName(This,FriendlyName,cchFriendlyName,pcchWritten) ) + +#define IMFSensorActivityReport_GetSymbolicLink(This,SymbolicLink,cchSymbolicLink,pcchWritten) \ + ( (This)->lpVtbl -> GetSymbolicLink(This,SymbolicLink,cchSymbolicLink,pcchWritten) ) + +#define IMFSensorActivityReport_GetProcessCount(This,pcCount) \ + ( (This)->lpVtbl -> GetProcessCount(This,pcCount) ) + +#define IMFSensorActivityReport_GetProcessActivity(This,Index,ppProcessActivity) \ + ( (This)->lpVtbl -> GetProcessActivity(This,Index,ppProcessActivity) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSensorActivityReport_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSensorActivitiesReport_INTERFACE_DEFINED__ +#define __IMFSensorActivitiesReport_INTERFACE_DEFINED__ + +/* interface IMFSensorActivitiesReport */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFSensorActivitiesReport; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("683F7A5E-4A19-43CD-B1A9-DBF4AB3F7777") + IMFSensorActivitiesReport : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetCount( + /* [annotation][out] */ + _Out_ ULONG *pcCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetActivityReport( + /* [annotation][in] */ + _In_ ULONG Index, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorActivityReport **sensorActivityReport) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetActivityReportByDeviceName( + /* [annotation][in] */ + _In_z_ LPCWSTR SymbolicName, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorActivityReport **sensorActivityReport) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSensorActivitiesReportVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSensorActivitiesReport * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSensorActivitiesReport * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSensorActivitiesReport * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + IMFSensorActivitiesReport * This, + /* [annotation][out] */ + _Out_ ULONG *pcCount); + + HRESULT ( STDMETHODCALLTYPE *GetActivityReport )( + IMFSensorActivitiesReport * This, + /* [annotation][in] */ + _In_ ULONG Index, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorActivityReport **sensorActivityReport); + + HRESULT ( STDMETHODCALLTYPE *GetActivityReportByDeviceName )( + IMFSensorActivitiesReport * This, + /* [annotation][in] */ + _In_z_ LPCWSTR SymbolicName, + /* [annotation][out] */ + _COM_Outptr_ IMFSensorActivityReport **sensorActivityReport); + + END_INTERFACE + } IMFSensorActivitiesReportVtbl; + + interface IMFSensorActivitiesReport + { + CONST_VTBL struct IMFSensorActivitiesReportVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSensorActivitiesReport_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSensorActivitiesReport_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSensorActivitiesReport_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSensorActivitiesReport_GetCount(This,pcCount) \ + ( (This)->lpVtbl -> GetCount(This,pcCount) ) + +#define IMFSensorActivitiesReport_GetActivityReport(This,Index,sensorActivityReport) \ + ( (This)->lpVtbl -> GetActivityReport(This,Index,sensorActivityReport) ) + +#define IMFSensorActivitiesReport_GetActivityReportByDeviceName(This,SymbolicName,sensorActivityReport) \ + ( (This)->lpVtbl -> GetActivityReportByDeviceName(This,SymbolicName,sensorActivityReport) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSensorActivitiesReport_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSensorActivitiesReportCallback_INTERFACE_DEFINED__ +#define __IMFSensorActivitiesReportCallback_INTERFACE_DEFINED__ + +/* interface IMFSensorActivitiesReportCallback */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFSensorActivitiesReportCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DE5072EE-DBE3-46DC-8A87-B6F631194751") + IMFSensorActivitiesReportCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE OnActivitiesReport( + /* [annotation][in] */ + _In_ IMFSensorActivitiesReport *sensorActivitiesReport) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSensorActivitiesReportCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSensorActivitiesReportCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSensorActivitiesReportCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSensorActivitiesReportCallback * This); + + HRESULT ( STDMETHODCALLTYPE *OnActivitiesReport )( + IMFSensorActivitiesReportCallback * This, + /* [annotation][in] */ + _In_ IMFSensorActivitiesReport *sensorActivitiesReport); + + END_INTERFACE + } IMFSensorActivitiesReportCallbackVtbl; + + interface IMFSensorActivitiesReportCallback + { + CONST_VTBL struct IMFSensorActivitiesReportCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSensorActivitiesReportCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSensorActivitiesReportCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSensorActivitiesReportCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSensorActivitiesReportCallback_OnActivitiesReport(This,sensorActivitiesReport) \ + ( (This)->lpVtbl -> OnActivitiesReport(This,sensorActivitiesReport) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSensorActivitiesReportCallback_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSensorActivityMonitor_INTERFACE_DEFINED__ +#define __IMFSensorActivityMonitor_INTERFACE_DEFINED__ + +/* interface IMFSensorActivityMonitor */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFSensorActivityMonitor; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("D0CEF145-B3F4-4340-A2E5-7A5080CA05CB") + IMFSensorActivityMonitor : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Start( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Stop( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSensorActivityMonitorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSensorActivityMonitor * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSensorActivityMonitor * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSensorActivityMonitor * This); + + HRESULT ( STDMETHODCALLTYPE *Start )( + IMFSensorActivityMonitor * This); + + HRESULT ( STDMETHODCALLTYPE *Stop )( + IMFSensorActivityMonitor * This); + + END_INTERFACE + } IMFSensorActivityMonitorVtbl; + + interface IMFSensorActivityMonitor + { + CONST_VTBL struct IMFSensorActivityMonitorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSensorActivityMonitor_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSensorActivityMonitor_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSensorActivityMonitor_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSensorActivityMonitor_Start(This) \ + ( (This)->lpVtbl -> Start(This) ) + +#define IMFSensorActivityMonitor_Stop(This) \ + ( (This)->lpVtbl -> Stop(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSensorActivityMonitor_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0120 */ +/* [local] */ + + +STDAPI +MFCreateSensorActivityMonitor( + _In_ IMFSensorActivitiesReportCallback* pCallback, + _COM_Outptr_ IMFSensorActivityMonitor** ppActivityMonitor + ); +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef struct _MFCameraIntrinsic_CameraModel + { + FLOAT FocalLength_x; + FLOAT FocalLength_y; + FLOAT PrincipalPoint_x; + FLOAT PrincipalPoint_y; + } MFCameraIntrinsic_CameraModel; + +typedef struct _MFCameraIntrinsic_DistortionModel6KT + { + FLOAT Radial_k1; + FLOAT Radial_k2; + FLOAT Radial_k3; + FLOAT Radial_k4; + FLOAT Radial_k5; + FLOAT Radial_k6; + FLOAT Tangential_p1; + FLOAT Tangential_p2; + } MFCameraIntrinsic_DistortionModel6KT; + +typedef struct _MFCameraIntrinsic_DistortionModelArcTan + { + FLOAT Radial_k0; + FLOAT DistortionCenter_x; + FLOAT DistortionCenter_y; + FLOAT Tangential_x; + FLOAT Tangential_y; + } MFCameraIntrinsic_DistortionModelArcTan; + +typedef +enum _MFCameraIntrinsic_DistortionModelType + { + MFCameraIntrinsic_DistortionModelType_6KT = 0, + MFCameraIntrinsic_DistortionModelType_ArcTan = ( MFCameraIntrinsic_DistortionModelType_6KT + 1 ) + } MFCameraIntrinsic_DistortionModelType; + +typedef struct _MFExtendedCameraIntrinsic_IntrinsicModel + { + UINT32 Width; + UINT32 Height; + UINT32 SplitFrameId; + MFCameraIntrinsic_CameraModel CameraModel; + } MFExtendedCameraIntrinsic_IntrinsicModel; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0120_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0120_v0_0_s_ifspec; + +#ifndef __IMFExtendedCameraIntrinsicModel_INTERFACE_DEFINED__ +#define __IMFExtendedCameraIntrinsicModel_INTERFACE_DEFINED__ + +/* interface IMFExtendedCameraIntrinsicModel */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFExtendedCameraIntrinsicModel; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5C595E64-4630-4231-855A-12842F733245") + IMFExtendedCameraIntrinsicModel : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetModel( + /* [annotation][out] */ + _Out_ MFExtendedCameraIntrinsic_IntrinsicModel *pIntrinsicModel) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetModel( + /* [annotation][in] */ + _In_ const MFExtendedCameraIntrinsic_IntrinsicModel *pIntrinsicModel) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDistortionModelType( + /* [annotation][out] */ + _Out_ MFCameraIntrinsic_DistortionModelType *pDistortionModelType) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFExtendedCameraIntrinsicModelVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFExtendedCameraIntrinsicModel * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFExtendedCameraIntrinsicModel * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFExtendedCameraIntrinsicModel * This); + + HRESULT ( STDMETHODCALLTYPE *GetModel )( + IMFExtendedCameraIntrinsicModel * This, + /* [annotation][out] */ + _Out_ MFExtendedCameraIntrinsic_IntrinsicModel *pIntrinsicModel); + + HRESULT ( STDMETHODCALLTYPE *SetModel )( + IMFExtendedCameraIntrinsicModel * This, + /* [annotation][in] */ + _In_ const MFExtendedCameraIntrinsic_IntrinsicModel *pIntrinsicModel); + + HRESULT ( STDMETHODCALLTYPE *GetDistortionModelType )( + IMFExtendedCameraIntrinsicModel * This, + /* [annotation][out] */ + _Out_ MFCameraIntrinsic_DistortionModelType *pDistortionModelType); + + END_INTERFACE + } IMFExtendedCameraIntrinsicModelVtbl; + + interface IMFExtendedCameraIntrinsicModel + { + CONST_VTBL struct IMFExtendedCameraIntrinsicModelVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFExtendedCameraIntrinsicModel_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFExtendedCameraIntrinsicModel_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFExtendedCameraIntrinsicModel_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFExtendedCameraIntrinsicModel_GetModel(This,pIntrinsicModel) \ + ( (This)->lpVtbl -> GetModel(This,pIntrinsicModel) ) + +#define IMFExtendedCameraIntrinsicModel_SetModel(This,pIntrinsicModel) \ + ( (This)->lpVtbl -> SetModel(This,pIntrinsicModel) ) + +#define IMFExtendedCameraIntrinsicModel_GetDistortionModelType(This,pDistortionModelType) \ + ( (This)->lpVtbl -> GetDistortionModelType(This,pDistortionModelType) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFExtendedCameraIntrinsicModel_INTERFACE_DEFINED__ */ + + +#ifndef __IMFExtendedCameraIntrinsicsDistortionModel6KT_INTERFACE_DEFINED__ +#define __IMFExtendedCameraIntrinsicsDistortionModel6KT_INTERFACE_DEFINED__ + +/* interface IMFExtendedCameraIntrinsicsDistortionModel6KT */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFExtendedCameraIntrinsicsDistortionModel6KT; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("74C2653B-5F55-4EB1-9F0F-18B8F68B7D3D") + IMFExtendedCameraIntrinsicsDistortionModel6KT : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetDistortionModel( + /* [annotation][out] */ + _Out_ MFCameraIntrinsic_DistortionModel6KT *pDistortionModel) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDistortionModel( + /* [annotation][in] */ + _In_ const MFCameraIntrinsic_DistortionModel6KT *pDistortionModel) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFExtendedCameraIntrinsicsDistortionModel6KTVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFExtendedCameraIntrinsicsDistortionModel6KT * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFExtendedCameraIntrinsicsDistortionModel6KT * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFExtendedCameraIntrinsicsDistortionModel6KT * This); + + HRESULT ( STDMETHODCALLTYPE *GetDistortionModel )( + IMFExtendedCameraIntrinsicsDistortionModel6KT * This, + /* [annotation][out] */ + _Out_ MFCameraIntrinsic_DistortionModel6KT *pDistortionModel); + + HRESULT ( STDMETHODCALLTYPE *SetDistortionModel )( + IMFExtendedCameraIntrinsicsDistortionModel6KT * This, + /* [annotation][in] */ + _In_ const MFCameraIntrinsic_DistortionModel6KT *pDistortionModel); + + END_INTERFACE + } IMFExtendedCameraIntrinsicsDistortionModel6KTVtbl; + + interface IMFExtendedCameraIntrinsicsDistortionModel6KT + { + CONST_VTBL struct IMFExtendedCameraIntrinsicsDistortionModel6KTVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFExtendedCameraIntrinsicsDistortionModel6KT_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFExtendedCameraIntrinsicsDistortionModel6KT_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFExtendedCameraIntrinsicsDistortionModel6KT_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFExtendedCameraIntrinsicsDistortionModel6KT_GetDistortionModel(This,pDistortionModel) \ + ( (This)->lpVtbl -> GetDistortionModel(This,pDistortionModel) ) + +#define IMFExtendedCameraIntrinsicsDistortionModel6KT_SetDistortionModel(This,pDistortionModel) \ + ( (This)->lpVtbl -> SetDistortionModel(This,pDistortionModel) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFExtendedCameraIntrinsicsDistortionModel6KT_INTERFACE_DEFINED__ */ + + +#ifndef __IMFExtendedCameraIntrinsicsDistortionModelArcTan_INTERFACE_DEFINED__ +#define __IMFExtendedCameraIntrinsicsDistortionModelArcTan_INTERFACE_DEFINED__ + +/* interface IMFExtendedCameraIntrinsicsDistortionModelArcTan */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFExtendedCameraIntrinsicsDistortionModelArcTan; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("812D5F95-B572-45DC-BAFC-AE24199DDDA8") + IMFExtendedCameraIntrinsicsDistortionModelArcTan : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetDistortionModel( + /* [annotation][out] */ + _Out_ MFCameraIntrinsic_DistortionModelArcTan *pDistortionModel) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDistortionModel( + /* [annotation][in] */ + _In_ const MFCameraIntrinsic_DistortionModelArcTan *pDistortionModel) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFExtendedCameraIntrinsicsDistortionModelArcTanVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFExtendedCameraIntrinsicsDistortionModelArcTan * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFExtendedCameraIntrinsicsDistortionModelArcTan * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFExtendedCameraIntrinsicsDistortionModelArcTan * This); + + HRESULT ( STDMETHODCALLTYPE *GetDistortionModel )( + IMFExtendedCameraIntrinsicsDistortionModelArcTan * This, + /* [annotation][out] */ + _Out_ MFCameraIntrinsic_DistortionModelArcTan *pDistortionModel); + + HRESULT ( STDMETHODCALLTYPE *SetDistortionModel )( + IMFExtendedCameraIntrinsicsDistortionModelArcTan * This, + /* [annotation][in] */ + _In_ const MFCameraIntrinsic_DistortionModelArcTan *pDistortionModel); + + END_INTERFACE + } IMFExtendedCameraIntrinsicsDistortionModelArcTanVtbl; + + interface IMFExtendedCameraIntrinsicsDistortionModelArcTan + { + CONST_VTBL struct IMFExtendedCameraIntrinsicsDistortionModelArcTanVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFExtendedCameraIntrinsicsDistortionModelArcTan_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFExtendedCameraIntrinsicsDistortionModelArcTan_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFExtendedCameraIntrinsicsDistortionModelArcTan_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFExtendedCameraIntrinsicsDistortionModelArcTan_GetDistortionModel(This,pDistortionModel) \ + ( (This)->lpVtbl -> GetDistortionModel(This,pDistortionModel) ) + +#define IMFExtendedCameraIntrinsicsDistortionModelArcTan_SetDistortionModel(This,pDistortionModel) \ + ( (This)->lpVtbl -> SetDistortionModel(This,pDistortionModel) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFExtendedCameraIntrinsicsDistortionModelArcTan_INTERFACE_DEFINED__ */ + + +#ifndef __IMFExtendedCameraIntrinsics_INTERFACE_DEFINED__ +#define __IMFExtendedCameraIntrinsics_INTERFACE_DEFINED__ + +/* interface IMFExtendedCameraIntrinsics */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFExtendedCameraIntrinsics; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("687F6DAC-6987-4750-A16A-734D1E7A10FE") + IMFExtendedCameraIntrinsics : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE InitializeFromBuffer( + /* [annotation][size_is][in] */ + _In_reads_bytes_(dwBufferSize) BYTE *pbBuffer, + /* [in] */ DWORD dwBufferSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferSize( + /* [annotation][out] */ + _Out_ DWORD *pdwBufferSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE SerializeToBuffer( + /* [annotation][out] */ + _Out_writes_bytes_to_(*pdwBufferSize, *pdwBufferSize) BYTE *pbBuffer, + /* [annotation][out] */ + _Inout_ DWORD *pdwBufferSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetIntrinsicModelCount( + /* [annotation][out] */ + _Out_ DWORD *pdwCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetIntrinsicModelByIndex( + /* [in] */ DWORD dwIndex, + /* [annotation][out] */ + _COM_Outptr_ IMFExtendedCameraIntrinsicModel **ppIntrinsicModel) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddIntrinsicModel( + /* [annotation][in] */ + _In_ IMFExtendedCameraIntrinsicModel *pIntrinsicModel) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFExtendedCameraIntrinsicsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFExtendedCameraIntrinsics * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFExtendedCameraIntrinsics * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFExtendedCameraIntrinsics * This); + + HRESULT ( STDMETHODCALLTYPE *InitializeFromBuffer )( + IMFExtendedCameraIntrinsics * This, + /* [annotation][size_is][in] */ + _In_reads_bytes_(dwBufferSize) BYTE *pbBuffer, + /* [in] */ DWORD dwBufferSize); + + HRESULT ( STDMETHODCALLTYPE *GetBufferSize )( + IMFExtendedCameraIntrinsics * This, + /* [annotation][out] */ + _Out_ DWORD *pdwBufferSize); + + HRESULT ( STDMETHODCALLTYPE *SerializeToBuffer )( + IMFExtendedCameraIntrinsics * This, + /* [annotation][out] */ + _Out_writes_bytes_to_(*pdwBufferSize, *pdwBufferSize) BYTE *pbBuffer, + /* [annotation][out] */ + _Inout_ DWORD *pdwBufferSize); + + HRESULT ( STDMETHODCALLTYPE *GetIntrinsicModelCount )( + IMFExtendedCameraIntrinsics * This, + /* [annotation][out] */ + _Out_ DWORD *pdwCount); + + HRESULT ( STDMETHODCALLTYPE *GetIntrinsicModelByIndex )( + IMFExtendedCameraIntrinsics * This, + /* [in] */ DWORD dwIndex, + /* [annotation][out] */ + _COM_Outptr_ IMFExtendedCameraIntrinsicModel **ppIntrinsicModel); + + HRESULT ( STDMETHODCALLTYPE *AddIntrinsicModel )( + IMFExtendedCameraIntrinsics * This, + /* [annotation][in] */ + _In_ IMFExtendedCameraIntrinsicModel *pIntrinsicModel); + + END_INTERFACE + } IMFExtendedCameraIntrinsicsVtbl; + + interface IMFExtendedCameraIntrinsics + { + CONST_VTBL struct IMFExtendedCameraIntrinsicsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFExtendedCameraIntrinsics_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFExtendedCameraIntrinsics_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFExtendedCameraIntrinsics_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFExtendedCameraIntrinsics_InitializeFromBuffer(This,pbBuffer,dwBufferSize) \ + ( (This)->lpVtbl -> InitializeFromBuffer(This,pbBuffer,dwBufferSize) ) + +#define IMFExtendedCameraIntrinsics_GetBufferSize(This,pdwBufferSize) \ + ( (This)->lpVtbl -> GetBufferSize(This,pdwBufferSize) ) + +#define IMFExtendedCameraIntrinsics_SerializeToBuffer(This,pbBuffer,pdwBufferSize) \ + ( (This)->lpVtbl -> SerializeToBuffer(This,pbBuffer,pdwBufferSize) ) + +#define IMFExtendedCameraIntrinsics_GetIntrinsicModelCount(This,pdwCount) \ + ( (This)->lpVtbl -> GetIntrinsicModelCount(This,pdwCount) ) + +#define IMFExtendedCameraIntrinsics_GetIntrinsicModelByIndex(This,dwIndex,ppIntrinsicModel) \ + ( (This)->lpVtbl -> GetIntrinsicModelByIndex(This,dwIndex,ppIntrinsicModel) ) + +#define IMFExtendedCameraIntrinsics_AddIntrinsicModel(This,pIntrinsicModel) \ + ( (This)->lpVtbl -> AddIntrinsicModel(This,pIntrinsicModel) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFExtendedCameraIntrinsics_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfidl_0000_0124 */ +/* [local] */ + +DEFINE_GUID(MFStreamExtension_ExtendedCameraIntrinsics, + 0xaa74b3df, 0x9a2c, 0x48d6, 0x83, 0x93, 0x5b, 0xd1, 0xc1, 0xa8, 0x1e, 0x6e); +DEFINE_GUID(MFSampleExtension_ExtendedCameraIntrinsics, + 0x560bc4a5, 0x4de0, 0x4113, 0x9c, 0xdc, 0x83, 0x2d, 0xb9, 0x74, 0xf, 0x3d); +#if (NTDDI_VERSION >= NTDDI_WIN10_RS5) +STDAPI +MFCreateExtendedCameraIntrinsics( + _COM_Outptr_ IMFExtendedCameraIntrinsics** ppExtendedCameraIntrinsics + ); +STDAPI +MFCreateExtendedCameraIntrinsicModel( + const MFCameraIntrinsic_DistortionModelType distortionModelType, + _COM_Outptr_ IMFExtendedCameraIntrinsicModel** ppExtendedCameraIntrinsicModel + ); +#endif // (NTDDI_VERSION >= NTDDI_WIN10_RS5) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion + + +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0124_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfidl_0000_0124_v0_0_s_ifspec; + +/* Additional Prototypes for ALL interfaces */ + +unsigned long __RPC_USER BSTR_UserSize( __RPC__in unsigned long *, unsigned long , __RPC__in BSTR * ); +unsigned char * __RPC_USER BSTR_UserMarshal( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * ); +unsigned char * __RPC_USER BSTR_UserUnmarshal(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * ); +void __RPC_USER BSTR_UserFree( __RPC__in unsigned long *, __RPC__in BSTR * ); + +unsigned long __RPC_USER LPSAFEARRAY_UserSize( __RPC__in unsigned long *, unsigned long , __RPC__in LPSAFEARRAY * ); +unsigned char * __RPC_USER LPSAFEARRAY_UserMarshal( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in LPSAFEARRAY * ); +unsigned char * __RPC_USER LPSAFEARRAY_UserUnmarshal(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out LPSAFEARRAY * ); +void __RPC_USER LPSAFEARRAY_UserFree( __RPC__in unsigned long *, __RPC__in LPSAFEARRAY * ); + +unsigned long __RPC_USER BSTR_UserSize64( __RPC__in unsigned long *, unsigned long , __RPC__in BSTR * ); +unsigned char * __RPC_USER BSTR_UserMarshal64( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * ); +unsigned char * __RPC_USER BSTR_UserUnmarshal64(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * ); +void __RPC_USER BSTR_UserFree64( __RPC__in unsigned long *, __RPC__in BSTR * ); + +unsigned long __RPC_USER LPSAFEARRAY_UserSize64( __RPC__in unsigned long *, unsigned long , __RPC__in LPSAFEARRAY * ); +unsigned char * __RPC_USER LPSAFEARRAY_UserMarshal64( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in LPSAFEARRAY * ); +unsigned char * __RPC_USER LPSAFEARRAY_UserUnmarshal64(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out LPSAFEARRAY * ); +void __RPC_USER LPSAFEARRAY_UserFree64( __RPC__in unsigned long *, __RPC__in LPSAFEARRAY * ); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFSourceResolver_BeginCreateObjectFromURL_Proxy( + IMFSourceResolver * This, + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Outptr_opt_ IUnknown **ppIUnknownCancelCookie, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFSourceResolver_BeginCreateObjectFromURL_Stub( + __RPC__in IMFSourceResolver * This, + /* [string][in] */ __RPC__in_string LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ __RPC__in_opt IPropertyStore *pProps, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFSourceResolver_EndCreateObjectFromURL_Proxy( + IMFSourceResolver * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFSourceResolver_EndCreateObjectFromURL_Stub( + __RPC__in IMFSourceResolver * This, + /* [in] */ __RPC__in_opt IUnknown *pResult, + /* [out] */ __RPC__out MF_OBJECT_TYPE *pObjectType, + /* [out] */ __RPC__deref_out_opt IUnknown **ppObject); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFSourceResolver_BeginCreateObjectFromByteStream_Proxy( + IMFSourceResolver * This, + /* [in] */ IMFByteStream *pByteStream, + /* [in] */ LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [in] */ IPropertyStore *pProps, + /* [annotation][out] */ + _Outptr_opt_ IUnknown **ppIUnknownCancelCookie, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFSourceResolver_BeginCreateObjectFromByteStream_Stub( + __RPC__in IMFSourceResolver * This, + /* [in] */ __RPC__in_opt IMFByteStream *pByteStream, + /* [unique][in] */ __RPC__in_opt LPCWSTR pwszURL, + /* [in] */ DWORD dwFlags, + /* [unique][in] */ __RPC__in_opt IPropertyStore *pProps, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFSourceResolver_EndCreateObjectFromByteStream_Proxy( + IMFSourceResolver * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ MF_OBJECT_TYPE *pObjectType, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFSourceResolver_EndCreateObjectFromByteStream_Stub( + __RPC__in IMFSourceResolver * This, + /* [in] */ __RPC__in_opt IUnknown *pResult, + /* [out] */ __RPC__out MF_OBJECT_TYPE *pObjectType, + /* [out] */ __RPC__deref_out_opt IUnknown **ppObject); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFMediaSource_CreatePresentationDescriptor_Proxy( + IMFMediaSource * This, + /* [annotation][out] */ + _Outptr_ IMFPresentationDescriptor **ppPresentationDescriptor); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaSource_CreatePresentationDescriptor_Stub( + __RPC__in IMFMediaSource * This, + /* [out] */ __RPC__out DWORD *pcbPD, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbPD) BYTE **pbPD, + /* [out] */ __RPC__deref_out_opt IMFPresentationDescriptor **ppRemotePD); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFMediaStream_RequestSample_Proxy( + IMFMediaStream * This, + /* [in] */ IUnknown *pToken); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaStream_RequestSample_Stub( + __RPC__in IMFMediaStream * This); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFTopologyNode_GetOutputPrefType_Proxy( + IMFTopologyNode * This, + /* [in] */ DWORD dwOutputIndex, + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppType); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFTopologyNode_GetOutputPrefType_Stub( + __RPC__in IMFTopologyNode * This, + /* [in] */ DWORD dwOutputIndex, + /* [out] */ __RPC__out DWORD *pcbData, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbData) BYTE **ppbData); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFTopologyNode_GetInputPrefType_Proxy( + IMFTopologyNode * This, + /* [in] */ DWORD dwInputIndex, + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppType); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFTopologyNode_GetInputPrefType_Stub( + __RPC__in IMFTopologyNode * This, + /* [in] */ DWORD dwInputIndex, + /* [out] */ __RPC__out DWORD *pcbData, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbData) BYTE **ppbData); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_IsMediaTypeSupported_Proxy( + IMFMediaTypeHandler * This, + /* [in] */ IMFMediaType *pMediaType, + /* [annotation][out] */ + _Outptr_opt_result_maybenull_ IMFMediaType **ppMediaType); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_IsMediaTypeSupported_Stub( + __RPC__in IMFMediaTypeHandler * This, + /* [size_is][in] */ __RPC__in_ecount_full(cbData) BYTE *pbData, + /* [in] */ DWORD cbData, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbBestMatch) BYTE **ppbBestMatch, + /* [out] */ __RPC__out DWORD *pcbBestMatch); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_GetMediaTypeByIndex_Proxy( + IMFMediaTypeHandler * This, + /* [in] */ DWORD dwIndex, + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppType); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_GetMediaTypeByIndex_Stub( + __RPC__in IMFMediaTypeHandler * This, + /* [in] */ DWORD dwIndex, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbData) BYTE **ppbData, + /* [out] */ __RPC__out DWORD *pcbData); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_SetCurrentMediaType_Proxy( + IMFMediaTypeHandler * This, + /* [in] */ IMFMediaType *pMediaType); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_SetCurrentMediaType_Stub( + __RPC__in IMFMediaTypeHandler * This, + /* [size_is][in] */ __RPC__in_ecount_full(cbData) BYTE *pbData, + /* [in] */ DWORD cbData); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_GetCurrentMediaType_Proxy( + IMFMediaTypeHandler * This, + /* [annotation][out] */ + _Outptr_ IMFMediaType **ppMediaType); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaTypeHandler_GetCurrentMediaType_Stub( + __RPC__in IMFMediaTypeHandler * This, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbData) BYTE **ppbData, + /* [out] */ __RPC__out DWORD *pcbData); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFContentProtectionManager_BeginEnableContent_Proxy( + IMFContentProtectionManager * This, + /* [in] */ IMFActivate *pEnablerActivate, + /* [in] */ IMFTopology *pTopo, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFContentProtectionManager_BeginEnableContent_Stub( + __RPC__in IMFContentProtectionManager * This, + /* [in] */ __RPC__in REFCLSID clsidType, + /* [size_is][in] */ __RPC__in_ecount_full(cbData) BYTE *pbData, + /* [in] */ DWORD cbData, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFContentProtectionManager_EndEnableContent_Proxy( + IMFContentProtectionManager * This, + /* [in] */ IMFAsyncResult *pResult); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFContentProtectionManager_EndEnableContent_Stub( + __RPC__in IMFContentProtectionManager * This, + /* [in] */ __RPC__in_opt IUnknown *pResult); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_BeginRegisterTopologyWorkQueuesWithMMCSS_Proxy( + IMFWorkQueueServices * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_BeginRegisterTopologyWorkQueuesWithMMCSS_Stub( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_EndRegisterTopologyWorkQueuesWithMMCSS_Proxy( + IMFWorkQueueServices * This, + /* [in] */ IMFAsyncResult *pResult); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_EndRegisterTopologyWorkQueuesWithMMCSS_Stub( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in_opt IUnknown *pResult); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_BeginUnregisterTopologyWorkQueuesWithMMCSS_Proxy( + IMFWorkQueueServices * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_BeginUnregisterTopologyWorkQueuesWithMMCSS_Stub( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_EndUnregisterTopologyWorkQueuesWithMMCSS_Proxy( + IMFWorkQueueServices * This, + /* [in] */ IMFAsyncResult *pResult); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_EndUnregisterTopologyWorkQueuesWithMMCSS_Stub( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in_opt IUnknown *pResult); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_BeginRegisterPlatformWorkQueueWithMMCSS_Proxy( + IMFWorkQueueServices * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ LPCWSTR wszClass, + /* [in] */ DWORD dwTaskId, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_BeginRegisterPlatformWorkQueueWithMMCSS_Stub( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ __RPC__in LPCWSTR wszClass, + /* [in] */ DWORD dwTaskId, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_EndRegisterPlatformWorkQueueWithMMCSS_Proxy( + IMFWorkQueueServices * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ DWORD *pdwTaskId); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_EndRegisterPlatformWorkQueueWithMMCSS_Stub( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in_opt IUnknown *pResult, + /* [out] */ __RPC__out DWORD *pdwTaskId); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_BeginUnregisterPlatformWorkQueueWithMMCSS_Proxy( + IMFWorkQueueServices * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_BeginUnregisterPlatformWorkQueueWithMMCSS_Stub( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_EndUnregisterPlatformWorkQueueWithMMCSS_Proxy( + IMFWorkQueueServices * This, + /* [in] */ IMFAsyncResult *pResult); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServices_EndUnregisterPlatformWorkQueueWithMMCSS_Stub( + __RPC__in IMFWorkQueueServices * This, + /* [in] */ __RPC__in_opt IUnknown *pResult); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServicesEx_BeginRegisterPlatformWorkQueueWithMMCSSEx_Proxy( + IMFWorkQueueServicesEx * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ LPCWSTR wszClass, + /* [in] */ DWORD dwTaskId, + /* [in] */ LONG lPriority, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *pState); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFWorkQueueServicesEx_BeginRegisterPlatformWorkQueueWithMMCSSEx_Stub( + __RPC__in IMFWorkQueueServicesEx * This, + /* [in] */ DWORD dwPlatformWorkQueue, + /* [in] */ __RPC__in LPCWSTR wszClass, + /* [in] */ DWORD dwTaskId, + /* [in] */ LONG lPriority, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFPMPHost_CreateObjectByCLSID_Proxy( + IMFPMPHost * This, + /* [in] */ REFCLSID clsid, + /* [unique][in] */ IStream *pStream, + /* [in] */ REFIID riid, + /* [iid_is][out] */ void **ppv); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFPMPHost_CreateObjectByCLSID_Stub( + __RPC__in IMFPMPHost * This, + /* [in] */ __RPC__in REFCLSID clsid, + /* [size_is][unique][in] */ __RPC__in_ecount_full_opt(cbData) BYTE *pbData, + /* [in] */ DWORD cbData, + /* [in] */ __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt void **ppv); + + + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/util/test/demos/dx/official/mfmediaengine.h b/util/test/demos/dx/official/mfmediaengine.h new file mode 100644 index 000000000..b6cecc287 --- /dev/null +++ b/util/test/demos/dx/official/mfmediaengine.h @@ -0,0 +1,8806 @@ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0622 */ +/* @@MIDL_FILE_HEADING( ) */ + + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCSAL_H_VERSION__ +#define __REQUIRED_RPCSAL_H_VERSION__ 100 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + +#ifndef COM_NO_WINDOWS_H +#include "windows.h" +#include "ole2.h" +#endif /*COM_NO_WINDOWS_H*/ + +#ifndef __mfmediaengine_h__ +#define __mfmediaengine_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +/* Forward Declarations */ + +#ifndef __IMFMediaError_FWD_DEFINED__ +#define __IMFMediaError_FWD_DEFINED__ +typedef interface IMFMediaError IMFMediaError; + +#endif /* __IMFMediaError_FWD_DEFINED__ */ + + +#ifndef __IMFMediaTimeRange_FWD_DEFINED__ +#define __IMFMediaTimeRange_FWD_DEFINED__ +typedef interface IMFMediaTimeRange IMFMediaTimeRange; + +#endif /* __IMFMediaTimeRange_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineNotify_FWD_DEFINED__ +#define __IMFMediaEngineNotify_FWD_DEFINED__ +typedef interface IMFMediaEngineNotify IMFMediaEngineNotify; + +#endif /* __IMFMediaEngineNotify_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineSrcElements_FWD_DEFINED__ +#define __IMFMediaEngineSrcElements_FWD_DEFINED__ +typedef interface IMFMediaEngineSrcElements IMFMediaEngineSrcElements; + +#endif /* __IMFMediaEngineSrcElements_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngine_FWD_DEFINED__ +#define __IMFMediaEngine_FWD_DEFINED__ +typedef interface IMFMediaEngine IMFMediaEngine; + +#endif /* __IMFMediaEngine_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineEx_FWD_DEFINED__ +#define __IMFMediaEngineEx_FWD_DEFINED__ +typedef interface IMFMediaEngineEx IMFMediaEngineEx; + +#endif /* __IMFMediaEngineEx_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineAudioEndpointId_FWD_DEFINED__ +#define __IMFMediaEngineAudioEndpointId_FWD_DEFINED__ +typedef interface IMFMediaEngineAudioEndpointId IMFMediaEngineAudioEndpointId; + +#endif /* __IMFMediaEngineAudioEndpointId_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineExtension_FWD_DEFINED__ +#define __IMFMediaEngineExtension_FWD_DEFINED__ +typedef interface IMFMediaEngineExtension IMFMediaEngineExtension; + +#endif /* __IMFMediaEngineExtension_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineProtectedContent_FWD_DEFINED__ +#define __IMFMediaEngineProtectedContent_FWD_DEFINED__ +typedef interface IMFMediaEngineProtectedContent IMFMediaEngineProtectedContent; + +#endif /* __IMFMediaEngineProtectedContent_FWD_DEFINED__ */ + + +#ifndef __IAudioSourceProvider_FWD_DEFINED__ +#define __IAudioSourceProvider_FWD_DEFINED__ +typedef interface IAudioSourceProvider IAudioSourceProvider; + +#endif /* __IAudioSourceProvider_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineWebSupport_FWD_DEFINED__ +#define __IMFMediaEngineWebSupport_FWD_DEFINED__ +typedef interface IMFMediaEngineWebSupport IMFMediaEngineWebSupport; + +#endif /* __IMFMediaEngineWebSupport_FWD_DEFINED__ */ + + +#ifndef __IMFMediaSourceExtensionNotify_FWD_DEFINED__ +#define __IMFMediaSourceExtensionNotify_FWD_DEFINED__ +typedef interface IMFMediaSourceExtensionNotify IMFMediaSourceExtensionNotify; + +#endif /* __IMFMediaSourceExtensionNotify_FWD_DEFINED__ */ + + +#ifndef __IMFBufferListNotify_FWD_DEFINED__ +#define __IMFBufferListNotify_FWD_DEFINED__ +typedef interface IMFBufferListNotify IMFBufferListNotify; + +#endif /* __IMFBufferListNotify_FWD_DEFINED__ */ + + +#ifndef __IMFSourceBufferNotify_FWD_DEFINED__ +#define __IMFSourceBufferNotify_FWD_DEFINED__ +typedef interface IMFSourceBufferNotify IMFSourceBufferNotify; + +#endif /* __IMFSourceBufferNotify_FWD_DEFINED__ */ + + +#ifndef __IMFSourceBuffer_FWD_DEFINED__ +#define __IMFSourceBuffer_FWD_DEFINED__ +typedef interface IMFSourceBuffer IMFSourceBuffer; + +#endif /* __IMFSourceBuffer_FWD_DEFINED__ */ + + +#ifndef __IMFSourceBufferAppendMode_FWD_DEFINED__ +#define __IMFSourceBufferAppendMode_FWD_DEFINED__ +typedef interface IMFSourceBufferAppendMode IMFSourceBufferAppendMode; + +#endif /* __IMFSourceBufferAppendMode_FWD_DEFINED__ */ + + +#ifndef __IMFSourceBufferList_FWD_DEFINED__ +#define __IMFSourceBufferList_FWD_DEFINED__ +typedef interface IMFSourceBufferList IMFSourceBufferList; + +#endif /* __IMFSourceBufferList_FWD_DEFINED__ */ + + +#ifndef __IMFMediaSourceExtension_FWD_DEFINED__ +#define __IMFMediaSourceExtension_FWD_DEFINED__ +typedef interface IMFMediaSourceExtension IMFMediaSourceExtension; + +#endif /* __IMFMediaSourceExtension_FWD_DEFINED__ */ + + +#ifndef __IMFMediaSourceExtensionLiveSeekableRange_FWD_DEFINED__ +#define __IMFMediaSourceExtensionLiveSeekableRange_FWD_DEFINED__ +typedef interface IMFMediaSourceExtensionLiveSeekableRange IMFMediaSourceExtensionLiveSeekableRange; + +#endif /* __IMFMediaSourceExtensionLiveSeekableRange_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineEME_FWD_DEFINED__ +#define __IMFMediaEngineEME_FWD_DEFINED__ +typedef interface IMFMediaEngineEME IMFMediaEngineEME; + +#endif /* __IMFMediaEngineEME_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineSrcElementsEx_FWD_DEFINED__ +#define __IMFMediaEngineSrcElementsEx_FWD_DEFINED__ +typedef interface IMFMediaEngineSrcElementsEx IMFMediaEngineSrcElementsEx; + +#endif /* __IMFMediaEngineSrcElementsEx_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineNeedKeyNotify_FWD_DEFINED__ +#define __IMFMediaEngineNeedKeyNotify_FWD_DEFINED__ +typedef interface IMFMediaEngineNeedKeyNotify IMFMediaEngineNeedKeyNotify; + +#endif /* __IMFMediaEngineNeedKeyNotify_FWD_DEFINED__ */ + + +#ifndef __IMFMediaKeys_FWD_DEFINED__ +#define __IMFMediaKeys_FWD_DEFINED__ +typedef interface IMFMediaKeys IMFMediaKeys; + +#endif /* __IMFMediaKeys_FWD_DEFINED__ */ + + +#ifndef __IMFMediaKeySession_FWD_DEFINED__ +#define __IMFMediaKeySession_FWD_DEFINED__ +typedef interface IMFMediaKeySession IMFMediaKeySession; + +#endif /* __IMFMediaKeySession_FWD_DEFINED__ */ + + +#ifndef __IMFMediaKeySessionNotify_FWD_DEFINED__ +#define __IMFMediaKeySessionNotify_FWD_DEFINED__ +typedef interface IMFMediaKeySessionNotify IMFMediaKeySessionNotify; + +#endif /* __IMFMediaKeySessionNotify_FWD_DEFINED__ */ + + +#ifndef __IMFCdmSuspendNotify_FWD_DEFINED__ +#define __IMFCdmSuspendNotify_FWD_DEFINED__ +typedef interface IMFCdmSuspendNotify IMFCdmSuspendNotify; + +#endif /* __IMFCdmSuspendNotify_FWD_DEFINED__ */ + + +#ifndef __IMFHDCPStatus_FWD_DEFINED__ +#define __IMFHDCPStatus_FWD_DEFINED__ +typedef interface IMFHDCPStatus IMFHDCPStatus; + +#endif /* __IMFHDCPStatus_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineOPMInfo_FWD_DEFINED__ +#define __IMFMediaEngineOPMInfo_FWD_DEFINED__ +typedef interface IMFMediaEngineOPMInfo IMFMediaEngineOPMInfo; + +#endif /* __IMFMediaEngineOPMInfo_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineClassFactory_FWD_DEFINED__ +#define __IMFMediaEngineClassFactory_FWD_DEFINED__ +typedef interface IMFMediaEngineClassFactory IMFMediaEngineClassFactory; + +#endif /* __IMFMediaEngineClassFactory_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineClassFactoryEx_FWD_DEFINED__ +#define __IMFMediaEngineClassFactoryEx_FWD_DEFINED__ +typedef interface IMFMediaEngineClassFactoryEx IMFMediaEngineClassFactoryEx; + +#endif /* __IMFMediaEngineClassFactoryEx_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineClassFactory2_FWD_DEFINED__ +#define __IMFMediaEngineClassFactory2_FWD_DEFINED__ +typedef interface IMFMediaEngineClassFactory2 IMFMediaEngineClassFactory2; + +#endif /* __IMFMediaEngineClassFactory2_FWD_DEFINED__ */ + + +#ifndef __IMFExtendedDRMTypeSupport_FWD_DEFINED__ +#define __IMFExtendedDRMTypeSupport_FWD_DEFINED__ +typedef interface IMFExtendedDRMTypeSupport IMFExtendedDRMTypeSupport; + +#endif /* __IMFExtendedDRMTypeSupport_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineSupportsSourceTransfer_FWD_DEFINED__ +#define __IMFMediaEngineSupportsSourceTransfer_FWD_DEFINED__ +typedef interface IMFMediaEngineSupportsSourceTransfer IMFMediaEngineSupportsSourceTransfer; + +#endif /* __IMFMediaEngineSupportsSourceTransfer_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineTransferSource_FWD_DEFINED__ +#define __IMFMediaEngineTransferSource_FWD_DEFINED__ +typedef interface IMFMediaEngineTransferSource IMFMediaEngineTransferSource; + +#endif /* __IMFMediaEngineTransferSource_FWD_DEFINED__ */ + + +#ifndef __IMFTimedText_FWD_DEFINED__ +#define __IMFTimedText_FWD_DEFINED__ +typedef interface IMFTimedText IMFTimedText; + +#endif /* __IMFTimedText_FWD_DEFINED__ */ + + +#ifndef __IMFTimedTextNotify_FWD_DEFINED__ +#define __IMFTimedTextNotify_FWD_DEFINED__ +typedef interface IMFTimedTextNotify IMFTimedTextNotify; + +#endif /* __IMFTimedTextNotify_FWD_DEFINED__ */ + + +#ifndef __IMFTimedTextTrack_FWD_DEFINED__ +#define __IMFTimedTextTrack_FWD_DEFINED__ +typedef interface IMFTimedTextTrack IMFTimedTextTrack; + +#endif /* __IMFTimedTextTrack_FWD_DEFINED__ */ + + +#ifndef __IMFTimedTextTrackList_FWD_DEFINED__ +#define __IMFTimedTextTrackList_FWD_DEFINED__ +typedef interface IMFTimedTextTrackList IMFTimedTextTrackList; + +#endif /* __IMFTimedTextTrackList_FWD_DEFINED__ */ + + +#ifndef __IMFTimedTextCue_FWD_DEFINED__ +#define __IMFTimedTextCue_FWD_DEFINED__ +typedef interface IMFTimedTextCue IMFTimedTextCue; + +#endif /* __IMFTimedTextCue_FWD_DEFINED__ */ + + +#ifndef __IMFTimedTextFormattedText_FWD_DEFINED__ +#define __IMFTimedTextFormattedText_FWD_DEFINED__ +typedef interface IMFTimedTextFormattedText IMFTimedTextFormattedText; + +#endif /* __IMFTimedTextFormattedText_FWD_DEFINED__ */ + + +#ifndef __IMFTimedTextStyle_FWD_DEFINED__ +#define __IMFTimedTextStyle_FWD_DEFINED__ +typedef interface IMFTimedTextStyle IMFTimedTextStyle; + +#endif /* __IMFTimedTextStyle_FWD_DEFINED__ */ + + +#ifndef __IMFTimedTextRegion_FWD_DEFINED__ +#define __IMFTimedTextRegion_FWD_DEFINED__ +typedef interface IMFTimedTextRegion IMFTimedTextRegion; + +#endif /* __IMFTimedTextRegion_FWD_DEFINED__ */ + + +#ifndef __IMFTimedTextBinary_FWD_DEFINED__ +#define __IMFTimedTextBinary_FWD_DEFINED__ +typedef interface IMFTimedTextBinary IMFTimedTextBinary; + +#endif /* __IMFTimedTextBinary_FWD_DEFINED__ */ + + +#ifndef __IMFTimedTextCueList_FWD_DEFINED__ +#define __IMFTimedTextCueList_FWD_DEFINED__ +typedef interface IMFTimedTextCueList IMFTimedTextCueList; + +#endif /* __IMFTimedTextCueList_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineEMENotify_FWD_DEFINED__ +#define __IMFMediaEngineEMENotify_FWD_DEFINED__ +typedef interface IMFMediaEngineEMENotify IMFMediaEngineEMENotify; + +#endif /* __IMFMediaEngineEMENotify_FWD_DEFINED__ */ + + +#ifndef __IMFMediaKeySessionNotify2_FWD_DEFINED__ +#define __IMFMediaKeySessionNotify2_FWD_DEFINED__ +typedef interface IMFMediaKeySessionNotify2 IMFMediaKeySessionNotify2; + +#endif /* __IMFMediaKeySessionNotify2_FWD_DEFINED__ */ + + +#ifndef __IMFMediaKeySystemAccess_FWD_DEFINED__ +#define __IMFMediaKeySystemAccess_FWD_DEFINED__ +typedef interface IMFMediaKeySystemAccess IMFMediaKeySystemAccess; + +#endif /* __IMFMediaKeySystemAccess_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEngineClassFactory3_FWD_DEFINED__ +#define __IMFMediaEngineClassFactory3_FWD_DEFINED__ +typedef interface IMFMediaEngineClassFactory3 IMFMediaEngineClassFactory3; + +#endif /* __IMFMediaEngineClassFactory3_FWD_DEFINED__ */ + + +#ifndef __IMFMediaKeys2_FWD_DEFINED__ +#define __IMFMediaKeys2_FWD_DEFINED__ +typedef interface IMFMediaKeys2 IMFMediaKeys2; + +#endif /* __IMFMediaKeys2_FWD_DEFINED__ */ + + +#ifndef __IMFMediaKeySession2_FWD_DEFINED__ +#define __IMFMediaKeySession2_FWD_DEFINED__ +typedef interface IMFMediaKeySession2 IMFMediaKeySession2; + +#endif /* __IMFMediaKeySession2_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "unknwn.h" +#include "mfidl.h" + +#ifdef __cplusplus +extern "C"{ +#endif + + +/* interface __MIDL_itf_mfmediaengine_0000_0000 */ +/* [local] */ + +#include "winapifamily.h" +#if (WINVER >= _WIN32_WINNT_WIN8) + +// Prevent a name collision +#undef GetCurrentTime + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +#define MF_INVALID_PRESENTATION_TIME 0x8000000000000000 +typedef +enum MF_MEDIA_ENGINE_ERR + { + MF_MEDIA_ENGINE_ERR_NOERROR = 0, + MF_MEDIA_ENGINE_ERR_ABORTED = 1, + MF_MEDIA_ENGINE_ERR_NETWORK = 2, + MF_MEDIA_ENGINE_ERR_DECODE = 3, + MF_MEDIA_ENGINE_ERR_SRC_NOT_SUPPORTED = 4, + MF_MEDIA_ENGINE_ERR_ENCRYPTED = 5 + } MF_MEDIA_ENGINE_ERR; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0000_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0000_v0_0_s_ifspec; + +#ifndef __IMFMediaError_INTERFACE_DEFINED__ +#define __IMFMediaError_INTERFACE_DEFINED__ + +/* interface IMFMediaError */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaError; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("fc0e10d2-ab2a-4501-a951-06bb1075184c") + IMFMediaError : public IUnknown + { + public: + virtual USHORT STDMETHODCALLTYPE GetErrorCode( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetExtendedErrorCode( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetErrorCode( + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_ERR error) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetExtendedErrorCode( + /* [annotation][in] */ + _In_ HRESULT error) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaErrorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaError * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaError * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaError * This); + + USHORT ( STDMETHODCALLTYPE *GetErrorCode )( + IMFMediaError * This); + + HRESULT ( STDMETHODCALLTYPE *GetExtendedErrorCode )( + IMFMediaError * This); + + HRESULT ( STDMETHODCALLTYPE *SetErrorCode )( + IMFMediaError * This, + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_ERR error); + + HRESULT ( STDMETHODCALLTYPE *SetExtendedErrorCode )( + IMFMediaError * This, + /* [annotation][in] */ + _In_ HRESULT error); + + END_INTERFACE + } IMFMediaErrorVtbl; + + interface IMFMediaError + { + CONST_VTBL struct IMFMediaErrorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaError_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaError_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaError_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaError_GetErrorCode(This) \ + ( (This)->lpVtbl -> GetErrorCode(This) ) + +#define IMFMediaError_GetExtendedErrorCode(This) \ + ( (This)->lpVtbl -> GetExtendedErrorCode(This) ) + +#define IMFMediaError_SetErrorCode(This,error) \ + ( (This)->lpVtbl -> SetErrorCode(This,error) ) + +#define IMFMediaError_SetExtendedErrorCode(This,error) \ + ( (This)->lpVtbl -> SetExtendedErrorCode(This,error) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaError_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaTimeRange_INTERFACE_DEFINED__ +#define __IMFMediaTimeRange_INTERFACE_DEFINED__ + +/* interface IMFMediaTimeRange */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaTimeRange; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("db71a2fc-078a-414e-9df9-8c2531b0aa6c") + IMFMediaTimeRange : public IUnknown + { + public: + virtual DWORD STDMETHODCALLTYPE GetLength( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStart( + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ double *pStart) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetEnd( + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ double *pEnd) = 0; + + virtual BOOL STDMETHODCALLTYPE ContainsTime( + /* [annotation][in] */ + _In_ double time) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddRange( + /* [annotation][in] */ + _In_ double startTime, + /* [annotation][in] */ + _In_ double endTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE Clear( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaTimeRangeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaTimeRange * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaTimeRange * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaTimeRange * This); + + DWORD ( STDMETHODCALLTYPE *GetLength )( + IMFMediaTimeRange * This); + + HRESULT ( STDMETHODCALLTYPE *GetStart )( + IMFMediaTimeRange * This, + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ double *pStart); + + HRESULT ( STDMETHODCALLTYPE *GetEnd )( + IMFMediaTimeRange * This, + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ double *pEnd); + + BOOL ( STDMETHODCALLTYPE *ContainsTime )( + IMFMediaTimeRange * This, + /* [annotation][in] */ + _In_ double time); + + HRESULT ( STDMETHODCALLTYPE *AddRange )( + IMFMediaTimeRange * This, + /* [annotation][in] */ + _In_ double startTime, + /* [annotation][in] */ + _In_ double endTime); + + HRESULT ( STDMETHODCALLTYPE *Clear )( + IMFMediaTimeRange * This); + + END_INTERFACE + } IMFMediaTimeRangeVtbl; + + interface IMFMediaTimeRange + { + CONST_VTBL struct IMFMediaTimeRangeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaTimeRange_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaTimeRange_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaTimeRange_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaTimeRange_GetLength(This) \ + ( (This)->lpVtbl -> GetLength(This) ) + +#define IMFMediaTimeRange_GetStart(This,index,pStart) \ + ( (This)->lpVtbl -> GetStart(This,index,pStart) ) + +#define IMFMediaTimeRange_GetEnd(This,index,pEnd) \ + ( (This)->lpVtbl -> GetEnd(This,index,pEnd) ) + +#define IMFMediaTimeRange_ContainsTime(This,time) \ + ( (This)->lpVtbl -> ContainsTime(This,time) ) + +#define IMFMediaTimeRange_AddRange(This,startTime,endTime) \ + ( (This)->lpVtbl -> AddRange(This,startTime,endTime) ) + +#define IMFMediaTimeRange_Clear(This) \ + ( (This)->lpVtbl -> Clear(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaTimeRange_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0002 */ +/* [local] */ + +typedef +enum MF_MEDIA_ENGINE_EVENT + { + MF_MEDIA_ENGINE_EVENT_LOADSTART = 1, + MF_MEDIA_ENGINE_EVENT_PROGRESS = 2, + MF_MEDIA_ENGINE_EVENT_SUSPEND = 3, + MF_MEDIA_ENGINE_EVENT_ABORT = 4, + MF_MEDIA_ENGINE_EVENT_ERROR = 5, + MF_MEDIA_ENGINE_EVENT_EMPTIED = 6, + MF_MEDIA_ENGINE_EVENT_STALLED = 7, + MF_MEDIA_ENGINE_EVENT_PLAY = 8, + MF_MEDIA_ENGINE_EVENT_PAUSE = 9, + MF_MEDIA_ENGINE_EVENT_LOADEDMETADATA = 10, + MF_MEDIA_ENGINE_EVENT_LOADEDDATA = 11, + MF_MEDIA_ENGINE_EVENT_WAITING = 12, + MF_MEDIA_ENGINE_EVENT_PLAYING = 13, + MF_MEDIA_ENGINE_EVENT_CANPLAY = 14, + MF_MEDIA_ENGINE_EVENT_CANPLAYTHROUGH = 15, + MF_MEDIA_ENGINE_EVENT_SEEKING = 16, + MF_MEDIA_ENGINE_EVENT_SEEKED = 17, + MF_MEDIA_ENGINE_EVENT_TIMEUPDATE = 18, + MF_MEDIA_ENGINE_EVENT_ENDED = 19, + MF_MEDIA_ENGINE_EVENT_RATECHANGE = 20, + MF_MEDIA_ENGINE_EVENT_DURATIONCHANGE = 21, + MF_MEDIA_ENGINE_EVENT_VOLUMECHANGE = 22, + MF_MEDIA_ENGINE_EVENT_FORMATCHANGE = 1000, + MF_MEDIA_ENGINE_EVENT_PURGEQUEUEDEVENTS = 1001, + MF_MEDIA_ENGINE_EVENT_TIMELINE_MARKER = 1002, + MF_MEDIA_ENGINE_EVENT_BALANCECHANGE = 1003, + MF_MEDIA_ENGINE_EVENT_DOWNLOADCOMPLETE = 1004, + MF_MEDIA_ENGINE_EVENT_BUFFERINGSTARTED = 1005, + MF_MEDIA_ENGINE_EVENT_BUFFERINGENDED = 1006, + MF_MEDIA_ENGINE_EVENT_FRAMESTEPCOMPLETED = 1007, + MF_MEDIA_ENGINE_EVENT_NOTIFYSTABLESTATE = 1008, + MF_MEDIA_ENGINE_EVENT_FIRSTFRAMEREADY = 1009, + MF_MEDIA_ENGINE_EVENT_TRACKSCHANGE = 1010, + MF_MEDIA_ENGINE_EVENT_OPMINFO = 1011, + MF_MEDIA_ENGINE_EVENT_RESOURCELOST = 1012, + MF_MEDIA_ENGINE_EVENT_DELAYLOADEVENT_CHANGED = 1013, + MF_MEDIA_ENGINE_EVENT_STREAMRENDERINGERROR = 1014, + MF_MEDIA_ENGINE_EVENT_SUPPORTEDRATES_CHANGED = 1015, + MF_MEDIA_ENGINE_EVENT_AUDIOENDPOINTCHANGE = 1016 + } MF_MEDIA_ENGINE_EVENT; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0002_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0002_v0_0_s_ifspec; + +#ifndef __IMFMediaEngineNotify_INTERFACE_DEFINED__ +#define __IMFMediaEngineNotify_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineNotify */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineNotify; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("fee7c112-e776-42b5-9bbf-0048524e2bd5") + IMFMediaEngineNotify : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE EventNotify( + /* [annotation][in] */ + _In_ DWORD event, + /* [annotation][in] */ + _In_ DWORD_PTR param1, + /* [annotation][in] */ + _In_ DWORD param2) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineNotifyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineNotify * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineNotify * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineNotify * This); + + HRESULT ( STDMETHODCALLTYPE *EventNotify )( + IMFMediaEngineNotify * This, + /* [annotation][in] */ + _In_ DWORD event, + /* [annotation][in] */ + _In_ DWORD_PTR param1, + /* [annotation][in] */ + _In_ DWORD param2); + + END_INTERFACE + } IMFMediaEngineNotifyVtbl; + + interface IMFMediaEngineNotify + { + CONST_VTBL struct IMFMediaEngineNotifyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineNotify_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineNotify_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineNotify_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineNotify_EventNotify(This,event,param1,param2) \ + ( (This)->lpVtbl -> EventNotify(This,event,param1,param2) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineNotify_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaEngineSrcElements_INTERFACE_DEFINED__ +#define __IMFMediaEngineSrcElements_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineSrcElements */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineSrcElements; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7a5e5354-b114-4c72-b991-3131d75032ea") + IMFMediaEngineSrcElements : public IUnknown + { + public: + virtual DWORD STDMETHODCALLTYPE GetLength( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetURL( + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ BSTR *pURL) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetType( + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ BSTR *pType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMedia( + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ BSTR *pMedia) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddElement( + /* [annotation][in] */ + _In_opt_ BSTR pURL, + /* [annotation][in] */ + _In_opt_ BSTR pType, + /* [annotation][in] */ + _In_opt_ BSTR pMedia) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveAllElements( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineSrcElementsVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineSrcElements * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineSrcElements * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineSrcElements * This); + + DWORD ( STDMETHODCALLTYPE *GetLength )( + IMFMediaEngineSrcElements * This); + + HRESULT ( STDMETHODCALLTYPE *GetURL )( + IMFMediaEngineSrcElements * This, + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ BSTR *pURL); + + HRESULT ( STDMETHODCALLTYPE *GetType )( + IMFMediaEngineSrcElements * This, + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ BSTR *pType); + + HRESULT ( STDMETHODCALLTYPE *GetMedia )( + IMFMediaEngineSrcElements * This, + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ BSTR *pMedia); + + HRESULT ( STDMETHODCALLTYPE *AddElement )( + IMFMediaEngineSrcElements * This, + /* [annotation][in] */ + _In_opt_ BSTR pURL, + /* [annotation][in] */ + _In_opt_ BSTR pType, + /* [annotation][in] */ + _In_opt_ BSTR pMedia); + + HRESULT ( STDMETHODCALLTYPE *RemoveAllElements )( + IMFMediaEngineSrcElements * This); + + END_INTERFACE + } IMFMediaEngineSrcElementsVtbl; + + interface IMFMediaEngineSrcElements + { + CONST_VTBL struct IMFMediaEngineSrcElementsVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineSrcElements_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineSrcElements_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineSrcElements_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineSrcElements_GetLength(This) \ + ( (This)->lpVtbl -> GetLength(This) ) + +#define IMFMediaEngineSrcElements_GetURL(This,index,pURL) \ + ( (This)->lpVtbl -> GetURL(This,index,pURL) ) + +#define IMFMediaEngineSrcElements_GetType(This,index,pType) \ + ( (This)->lpVtbl -> GetType(This,index,pType) ) + +#define IMFMediaEngineSrcElements_GetMedia(This,index,pMedia) \ + ( (This)->lpVtbl -> GetMedia(This,index,pMedia) ) + +#define IMFMediaEngineSrcElements_AddElement(This,pURL,pType,pMedia) \ + ( (This)->lpVtbl -> AddElement(This,pURL,pType,pMedia) ) + +#define IMFMediaEngineSrcElements_RemoveAllElements(This) \ + ( (This)->lpVtbl -> RemoveAllElements(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineSrcElements_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0004 */ +/* [local] */ + +typedef +enum MF_MEDIA_ENGINE_NETWORK + { + MF_MEDIA_ENGINE_NETWORK_EMPTY = 0, + MF_MEDIA_ENGINE_NETWORK_IDLE = 1, + MF_MEDIA_ENGINE_NETWORK_LOADING = 2, + MF_MEDIA_ENGINE_NETWORK_NO_SOURCE = 3 + } MF_MEDIA_ENGINE_NETWORK; + +typedef +enum MF_MEDIA_ENGINE_READY + { + MF_MEDIA_ENGINE_READY_HAVE_NOTHING = 0, + MF_MEDIA_ENGINE_READY_HAVE_METADATA = 1, + MF_MEDIA_ENGINE_READY_HAVE_CURRENT_DATA = 2, + MF_MEDIA_ENGINE_READY_HAVE_FUTURE_DATA = 3, + MF_MEDIA_ENGINE_READY_HAVE_ENOUGH_DATA = 4 + } MF_MEDIA_ENGINE_READY; + +typedef +enum MF_MEDIA_ENGINE_CANPLAY + { + MF_MEDIA_ENGINE_CANPLAY_NOT_SUPPORTED = 0, + MF_MEDIA_ENGINE_CANPLAY_MAYBE = 1, + MF_MEDIA_ENGINE_CANPLAY_PROBABLY = 2 + } MF_MEDIA_ENGINE_CANPLAY; + +typedef +enum MF_MEDIA_ENGINE_PRELOAD + { + MF_MEDIA_ENGINE_PRELOAD_MISSING = 0, + MF_MEDIA_ENGINE_PRELOAD_EMPTY = 1, + MF_MEDIA_ENGINE_PRELOAD_NONE = 2, + MF_MEDIA_ENGINE_PRELOAD_METADATA = 3, + MF_MEDIA_ENGINE_PRELOAD_AUTOMATIC = 4 + } MF_MEDIA_ENGINE_PRELOAD; + +#ifndef _MFVideoNormalizedRect_ +#define _MFVideoNormalizedRect_ +typedef struct MFVideoNormalizedRect + { + float left; + float top; + float right; + float bottom; + } MFVideoNormalizedRect; + +#endif + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0004_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0004_v0_0_s_ifspec; + +#ifndef __IMFMediaEngine_INTERFACE_DEFINED__ +#define __IMFMediaEngine_INTERFACE_DEFINED__ + +/* interface IMFMediaEngine */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngine; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("98a1b0bb-03eb-4935-ae7c-93c1fa0e1c93") + IMFMediaEngine : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetError( + /* [annotation][out] */ + _Outptr_ IMFMediaError **ppError) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetErrorCode( + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_ERR error) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSourceElements( + /* [annotation][in] */ + _In_ IMFMediaEngineSrcElements *pSrcElements) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSource( + /* [annotation][in] */ + _In_ BSTR pUrl) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentSource( + /* [annotation][out] */ + _Out_ BSTR *ppUrl) = 0; + + virtual USHORT STDMETHODCALLTYPE GetNetworkState( void) = 0; + + virtual MF_MEDIA_ENGINE_PRELOAD STDMETHODCALLTYPE GetPreload( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPreload( + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_PRELOAD Preload) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBuffered( + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppBuffered) = 0; + + virtual HRESULT STDMETHODCALLTYPE Load( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE CanPlayType( + /* [annotation][in] */ + _In_ BSTR type, + /* [annotation][out] */ + _Out_ MF_MEDIA_ENGINE_CANPLAY *pAnswer) = 0; + + virtual USHORT STDMETHODCALLTYPE GetReadyState( void) = 0; + + virtual BOOL STDMETHODCALLTYPE IsSeeking( void) = 0; + + virtual double STDMETHODCALLTYPE GetCurrentTime( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCurrentTime( + /* [annotation][in] */ + _In_ double seekTime) = 0; + + virtual double STDMETHODCALLTYPE GetStartTime( void) = 0; + + virtual double STDMETHODCALLTYPE GetDuration( void) = 0; + + virtual BOOL STDMETHODCALLTYPE IsPaused( void) = 0; + + virtual double STDMETHODCALLTYPE GetDefaultPlaybackRate( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDefaultPlaybackRate( + /* [annotation][in] */ + _In_ double Rate) = 0; + + virtual double STDMETHODCALLTYPE GetPlaybackRate( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPlaybackRate( + /* [annotation][in] */ + _In_ double Rate) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPlayed( + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppPlayed) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSeekable( + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppSeekable) = 0; + + virtual BOOL STDMETHODCALLTYPE IsEnded( void) = 0; + + virtual BOOL STDMETHODCALLTYPE GetAutoPlay( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAutoPlay( + /* [annotation][in] */ + _In_ BOOL AutoPlay) = 0; + + virtual BOOL STDMETHODCALLTYPE GetLoop( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetLoop( + /* [annotation][in] */ + _In_ BOOL Loop) = 0; + + virtual HRESULT STDMETHODCALLTYPE Play( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Pause( void) = 0; + + virtual BOOL STDMETHODCALLTYPE GetMuted( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMuted( + /* [annotation][in] */ + _In_ BOOL Muted) = 0; + + virtual double STDMETHODCALLTYPE GetVolume( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetVolume( + /* [annotation][in] */ + _In_ double Volume) = 0; + + virtual BOOL STDMETHODCALLTYPE HasVideo( void) = 0; + + virtual BOOL STDMETHODCALLTYPE HasAudio( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetNativeVideoSize( + /* [annotation][out] */ + _Out_opt_ DWORD *cx, + /* [annotation][out] */ + _Out_opt_ DWORD *cy) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVideoAspectRatio( + /* [annotation][out] */ + _Out_opt_ DWORD *cx, + /* [annotation][out] */ + _Out_opt_ DWORD *cy) = 0; + + virtual HRESULT STDMETHODCALLTYPE Shutdown( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE TransferVideoFrame( + /* [annotation][in] */ + _In_ IUnknown *pDstSurf, + /* [annotation][in] */ + _In_opt_ const MFVideoNormalizedRect *pSrc, + /* [annotation][in] */ + _In_ const RECT *pDst, + /* [annotation][in] */ + _In_opt_ const MFARGB *pBorderClr) = 0; + + virtual HRESULT STDMETHODCALLTYPE OnVideoStreamTick( + /* [annotation][out] */ + _Out_ LONGLONG *pPts) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngine * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngine * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *GetError )( + IMFMediaEngine * This, + /* [annotation][out] */ + _Outptr_ IMFMediaError **ppError); + + HRESULT ( STDMETHODCALLTYPE *SetErrorCode )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_ERR error); + + HRESULT ( STDMETHODCALLTYPE *SetSourceElements )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ IMFMediaEngineSrcElements *pSrcElements); + + HRESULT ( STDMETHODCALLTYPE *SetSource )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ BSTR pUrl); + + HRESULT ( STDMETHODCALLTYPE *GetCurrentSource )( + IMFMediaEngine * This, + /* [annotation][out] */ + _Out_ BSTR *ppUrl); + + USHORT ( STDMETHODCALLTYPE *GetNetworkState )( + IMFMediaEngine * This); + + MF_MEDIA_ENGINE_PRELOAD ( STDMETHODCALLTYPE *GetPreload )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *SetPreload )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_PRELOAD Preload); + + HRESULT ( STDMETHODCALLTYPE *GetBuffered )( + IMFMediaEngine * This, + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppBuffered); + + HRESULT ( STDMETHODCALLTYPE *Load )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *CanPlayType )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ BSTR type, + /* [annotation][out] */ + _Out_ MF_MEDIA_ENGINE_CANPLAY *pAnswer); + + USHORT ( STDMETHODCALLTYPE *GetReadyState )( + IMFMediaEngine * This); + + BOOL ( STDMETHODCALLTYPE *IsSeeking )( + IMFMediaEngine * This); + + double ( STDMETHODCALLTYPE *GetCurrentTime )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *SetCurrentTime )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ double seekTime); + + double ( STDMETHODCALLTYPE *GetStartTime )( + IMFMediaEngine * This); + + double ( STDMETHODCALLTYPE *GetDuration )( + IMFMediaEngine * This); + + BOOL ( STDMETHODCALLTYPE *IsPaused )( + IMFMediaEngine * This); + + double ( STDMETHODCALLTYPE *GetDefaultPlaybackRate )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *SetDefaultPlaybackRate )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ double Rate); + + double ( STDMETHODCALLTYPE *GetPlaybackRate )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *SetPlaybackRate )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ double Rate); + + HRESULT ( STDMETHODCALLTYPE *GetPlayed )( + IMFMediaEngine * This, + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppPlayed); + + HRESULT ( STDMETHODCALLTYPE *GetSeekable )( + IMFMediaEngine * This, + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppSeekable); + + BOOL ( STDMETHODCALLTYPE *IsEnded )( + IMFMediaEngine * This); + + BOOL ( STDMETHODCALLTYPE *GetAutoPlay )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *SetAutoPlay )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ BOOL AutoPlay); + + BOOL ( STDMETHODCALLTYPE *GetLoop )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *SetLoop )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ BOOL Loop); + + HRESULT ( STDMETHODCALLTYPE *Play )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *Pause )( + IMFMediaEngine * This); + + BOOL ( STDMETHODCALLTYPE *GetMuted )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *SetMuted )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ BOOL Muted); + + double ( STDMETHODCALLTYPE *GetVolume )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *SetVolume )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ double Volume); + + BOOL ( STDMETHODCALLTYPE *HasVideo )( + IMFMediaEngine * This); + + BOOL ( STDMETHODCALLTYPE *HasAudio )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *GetNativeVideoSize )( + IMFMediaEngine * This, + /* [annotation][out] */ + _Out_opt_ DWORD *cx, + /* [annotation][out] */ + _Out_opt_ DWORD *cy); + + HRESULT ( STDMETHODCALLTYPE *GetVideoAspectRatio )( + IMFMediaEngine * This, + /* [annotation][out] */ + _Out_opt_ DWORD *cx, + /* [annotation][out] */ + _Out_opt_ DWORD *cy); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + IMFMediaEngine * This); + + HRESULT ( STDMETHODCALLTYPE *TransferVideoFrame )( + IMFMediaEngine * This, + /* [annotation][in] */ + _In_ IUnknown *pDstSurf, + /* [annotation][in] */ + _In_opt_ const MFVideoNormalizedRect *pSrc, + /* [annotation][in] */ + _In_ const RECT *pDst, + /* [annotation][in] */ + _In_opt_ const MFARGB *pBorderClr); + + HRESULT ( STDMETHODCALLTYPE *OnVideoStreamTick )( + IMFMediaEngine * This, + /* [annotation][out] */ + _Out_ LONGLONG *pPts); + + END_INTERFACE + } IMFMediaEngineVtbl; + + interface IMFMediaEngine + { + CONST_VTBL struct IMFMediaEngineVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngine_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngine_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngine_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngine_GetError(This,ppError) \ + ( (This)->lpVtbl -> GetError(This,ppError) ) + +#define IMFMediaEngine_SetErrorCode(This,error) \ + ( (This)->lpVtbl -> SetErrorCode(This,error) ) + +#define IMFMediaEngine_SetSourceElements(This,pSrcElements) \ + ( (This)->lpVtbl -> SetSourceElements(This,pSrcElements) ) + +#define IMFMediaEngine_SetSource(This,pUrl) \ + ( (This)->lpVtbl -> SetSource(This,pUrl) ) + +#define IMFMediaEngine_GetCurrentSource(This,ppUrl) \ + ( (This)->lpVtbl -> GetCurrentSource(This,ppUrl) ) + +#define IMFMediaEngine_GetNetworkState(This) \ + ( (This)->lpVtbl -> GetNetworkState(This) ) + +#define IMFMediaEngine_GetPreload(This) \ + ( (This)->lpVtbl -> GetPreload(This) ) + +#define IMFMediaEngine_SetPreload(This,Preload) \ + ( (This)->lpVtbl -> SetPreload(This,Preload) ) + +#define IMFMediaEngine_GetBuffered(This,ppBuffered) \ + ( (This)->lpVtbl -> GetBuffered(This,ppBuffered) ) + +#define IMFMediaEngine_Load(This) \ + ( (This)->lpVtbl -> Load(This) ) + +#define IMFMediaEngine_CanPlayType(This,type,pAnswer) \ + ( (This)->lpVtbl -> CanPlayType(This,type,pAnswer) ) + +#define IMFMediaEngine_GetReadyState(This) \ + ( (This)->lpVtbl -> GetReadyState(This) ) + +#define IMFMediaEngine_IsSeeking(This) \ + ( (This)->lpVtbl -> IsSeeking(This) ) + +#define IMFMediaEngine_GetCurrentTime(This) \ + ( (This)->lpVtbl -> GetCurrentTime(This) ) + +#define IMFMediaEngine_SetCurrentTime(This,seekTime) \ + ( (This)->lpVtbl -> SetCurrentTime(This,seekTime) ) + +#define IMFMediaEngine_GetStartTime(This) \ + ( (This)->lpVtbl -> GetStartTime(This) ) + +#define IMFMediaEngine_GetDuration(This) \ + ( (This)->lpVtbl -> GetDuration(This) ) + +#define IMFMediaEngine_IsPaused(This) \ + ( (This)->lpVtbl -> IsPaused(This) ) + +#define IMFMediaEngine_GetDefaultPlaybackRate(This) \ + ( (This)->lpVtbl -> GetDefaultPlaybackRate(This) ) + +#define IMFMediaEngine_SetDefaultPlaybackRate(This,Rate) \ + ( (This)->lpVtbl -> SetDefaultPlaybackRate(This,Rate) ) + +#define IMFMediaEngine_GetPlaybackRate(This) \ + ( (This)->lpVtbl -> GetPlaybackRate(This) ) + +#define IMFMediaEngine_SetPlaybackRate(This,Rate) \ + ( (This)->lpVtbl -> SetPlaybackRate(This,Rate) ) + +#define IMFMediaEngine_GetPlayed(This,ppPlayed) \ + ( (This)->lpVtbl -> GetPlayed(This,ppPlayed) ) + +#define IMFMediaEngine_GetSeekable(This,ppSeekable) \ + ( (This)->lpVtbl -> GetSeekable(This,ppSeekable) ) + +#define IMFMediaEngine_IsEnded(This) \ + ( (This)->lpVtbl -> IsEnded(This) ) + +#define IMFMediaEngine_GetAutoPlay(This) \ + ( (This)->lpVtbl -> GetAutoPlay(This) ) + +#define IMFMediaEngine_SetAutoPlay(This,AutoPlay) \ + ( (This)->lpVtbl -> SetAutoPlay(This,AutoPlay) ) + +#define IMFMediaEngine_GetLoop(This) \ + ( (This)->lpVtbl -> GetLoop(This) ) + +#define IMFMediaEngine_SetLoop(This,Loop) \ + ( (This)->lpVtbl -> SetLoop(This,Loop) ) + +#define IMFMediaEngine_Play(This) \ + ( (This)->lpVtbl -> Play(This) ) + +#define IMFMediaEngine_Pause(This) \ + ( (This)->lpVtbl -> Pause(This) ) + +#define IMFMediaEngine_GetMuted(This) \ + ( (This)->lpVtbl -> GetMuted(This) ) + +#define IMFMediaEngine_SetMuted(This,Muted) \ + ( (This)->lpVtbl -> SetMuted(This,Muted) ) + +#define IMFMediaEngine_GetVolume(This) \ + ( (This)->lpVtbl -> GetVolume(This) ) + +#define IMFMediaEngine_SetVolume(This,Volume) \ + ( (This)->lpVtbl -> SetVolume(This,Volume) ) + +#define IMFMediaEngine_HasVideo(This) \ + ( (This)->lpVtbl -> HasVideo(This) ) + +#define IMFMediaEngine_HasAudio(This) \ + ( (This)->lpVtbl -> HasAudio(This) ) + +#define IMFMediaEngine_GetNativeVideoSize(This,cx,cy) \ + ( (This)->lpVtbl -> GetNativeVideoSize(This,cx,cy) ) + +#define IMFMediaEngine_GetVideoAspectRatio(This,cx,cy) \ + ( (This)->lpVtbl -> GetVideoAspectRatio(This,cx,cy) ) + +#define IMFMediaEngine_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + +#define IMFMediaEngine_TransferVideoFrame(This,pDstSurf,pSrc,pDst,pBorderClr) \ + ( (This)->lpVtbl -> TransferVideoFrame(This,pDstSurf,pSrc,pDst,pBorderClr) ) + +#define IMFMediaEngine_OnVideoStreamTick(This,pPts) \ + ( (This)->lpVtbl -> OnVideoStreamTick(This,pPts) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngine_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0005 */ +/* [local] */ + +typedef +enum MF_MEDIA_ENGINE_S3D_PACKING_MODE + { + MF_MEDIA_ENGINE_S3D_PACKING_MODE_NONE = 0, + MF_MEDIA_ENGINE_S3D_PACKING_MODE_SIDE_BY_SIDE = 1, + MF_MEDIA_ENGINE_S3D_PACKING_MODE_TOP_BOTTOM = 2 + } MF_MEDIA_ENGINE_S3D_PACKING_MODE; + +typedef +enum MF_MEDIA_ENGINE_STATISTIC + { + MF_MEDIA_ENGINE_STATISTIC_FRAMES_RENDERED = 0, + MF_MEDIA_ENGINE_STATISTIC_FRAMES_DROPPED = 1, + MF_MEDIA_ENGINE_STATISTIC_BYTES_DOWNLOADED = 2, + MF_MEDIA_ENGINE_STATISTIC_BUFFER_PROGRESS = 3, + MF_MEDIA_ENGINE_STATISTIC_FRAMES_PER_SECOND = 4, + MF_MEDIA_ENGINE_STATISTIC_PLAYBACK_JITTER = 5, + MF_MEDIA_ENGINE_STATISTIC_FRAMES_CORRUPTED = 6, + MF_MEDIA_ENGINE_STATISTIC_TOTAL_FRAME_DELAY = 7 + } MF_MEDIA_ENGINE_STATISTIC; + +typedef +enum MF_MEDIA_ENGINE_SEEK_MODE + { + MF_MEDIA_ENGINE_SEEK_MODE_NORMAL = 0, + MF_MEDIA_ENGINE_SEEK_MODE_APPROXIMATE = 1 + } MF_MEDIA_ENGINE_SEEK_MODE; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0005_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0005_v0_0_s_ifspec; + +#ifndef __IMFMediaEngineEx_INTERFACE_DEFINED__ +#define __IMFMediaEngineEx_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineEx */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineEx; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("83015ead-b1e6-40d0-a98a-37145ffe1ad1") + IMFMediaEngineEx : public IMFMediaEngine + { + public: + virtual HRESULT STDMETHODCALLTYPE SetSourceFromByteStream( + /* [annotation][in] */ + _In_ IMFByteStream *pByteStream, + /* [annotation][in] */ + _In_ BSTR pURL) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStatistics( + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_STATISTIC StatisticID, + /* [annotation][out] */ + _Out_ PROPVARIANT *pStatistic) = 0; + + virtual HRESULT STDMETHODCALLTYPE UpdateVideoStream( + /* [annotation][in] */ + _In_opt_ const MFVideoNormalizedRect *pSrc, + /* [annotation][in] */ + _In_opt_ const RECT *pDst, + /* [annotation][in] */ + _In_opt_ const MFARGB *pBorderClr) = 0; + + virtual double STDMETHODCALLTYPE GetBalance( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBalance( + /* [annotation][in] */ + _In_ double balance) = 0; + + virtual BOOL STDMETHODCALLTYPE IsPlaybackRateSupported( + /* [annotation][in] */ + _In_ double rate) = 0; + + virtual HRESULT STDMETHODCALLTYPE FrameStep( + /* [annotation][in] */ + _In_ BOOL Forward) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetResourceCharacteristics( + /* [annotation][out] */ + _Out_ DWORD *pCharacteristics) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPresentationAttribute( + /* [annotation][in] */ + _In_ REFGUID guidMFAttribute, + /* [annotation][out] */ + _Out_ PROPVARIANT *pvValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetNumberOfStreams( + /* [annotation][out] */ + _Out_ DWORD *pdwStreamCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamAttribute( + /* [annotation][in] */ + _In_ DWORD dwStreamIndex, + /* [annotation][in] */ + _In_ REFGUID guidMFAttribute, + /* [annotation][out] */ + _Out_ PROPVARIANT *pvValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamSelection( + /* [annotation][in] */ + _In_ DWORD dwStreamIndex, + /* [annotation][out] */ + _Out_ BOOL *pEnabled) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStreamSelection( + /* [annotation][in] */ + _In_ DWORD dwStreamIndex, + /* [annotation][in] */ + _In_ BOOL Enabled) = 0; + + virtual HRESULT STDMETHODCALLTYPE ApplyStreamSelections( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsProtected( + /* [annotation][out] */ + _Out_ BOOL *pProtected) = 0; + + virtual HRESULT STDMETHODCALLTYPE InsertVideoEffect( + /* [annotation][in] */ + _In_ IUnknown *pEffect, + /* [annotation][in] */ + _In_ BOOL fOptional) = 0; + + virtual HRESULT STDMETHODCALLTYPE InsertAudioEffect( + /* [annotation][in] */ + _In_ IUnknown *pEffect, + /* [annotation][in] */ + _In_ BOOL fOptional) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveAllEffects( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTimelineMarkerTimer( + /* [annotation][in] */ + _In_ double timeToFire) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTimelineMarkerTimer( + /* [annotation][out] */ + _Out_ double *pTimeToFire) = 0; + + virtual HRESULT STDMETHODCALLTYPE CancelTimelineMarkerTimer( void) = 0; + + virtual BOOL STDMETHODCALLTYPE IsStereo3D( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStereo3DFramePackingMode( + /* [annotation][out] */ + _Out_ MF_MEDIA_ENGINE_S3D_PACKING_MODE *packMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStereo3DFramePackingMode( + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_S3D_PACKING_MODE packMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStereo3DRenderMode( + /* [annotation][out] */ + _Out_ MF3DVideoOutputType *outputType) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStereo3DRenderMode( + /* [annotation][in] */ + _In_ MF3DVideoOutputType outputType) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableWindowlessSwapchainMode( + /* [annotation][in] */ + _In_ BOOL fEnable) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVideoSwapchainHandle( + /* [annotation][out] */ + _Out_ HANDLE *phSwapchain) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableHorizontalMirrorMode( + /* [annotation][in] */ + _In_ BOOL fEnable) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAudioStreamCategory( + /* [annotation][out] */ + _Out_ UINT32 *pCategory) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAudioStreamCategory( + /* [annotation][in] */ + _In_ UINT32 category) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAudioEndpointRole( + /* [annotation][out] */ + _Out_ UINT32 *pRole) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAudioEndpointRole( + /* [annotation][in] */ + _In_ UINT32 role) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRealTimeMode( + /* [annotation][out] */ + _Out_ BOOL *pfEnabled) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetRealTimeMode( + /* [annotation][in] */ + _In_ BOOL fEnable) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCurrentTimeEx( + /* [annotation][in] */ + _In_ double seekTime, + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_SEEK_MODE seekMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE EnableTimeUpdateTimer( + /* [annotation][in] */ + _In_ BOOL fEnableTimer) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineExVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineEx * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineEx * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *GetError )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Outptr_ IMFMediaError **ppError); + + HRESULT ( STDMETHODCALLTYPE *SetErrorCode )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_ERR error); + + HRESULT ( STDMETHODCALLTYPE *SetSourceElements )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ IMFMediaEngineSrcElements *pSrcElements); + + HRESULT ( STDMETHODCALLTYPE *SetSource )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ BSTR pUrl); + + HRESULT ( STDMETHODCALLTYPE *GetCurrentSource )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_ BSTR *ppUrl); + + USHORT ( STDMETHODCALLTYPE *GetNetworkState )( + IMFMediaEngineEx * This); + + MF_MEDIA_ENGINE_PRELOAD ( STDMETHODCALLTYPE *GetPreload )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *SetPreload )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_PRELOAD Preload); + + HRESULT ( STDMETHODCALLTYPE *GetBuffered )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppBuffered); + + HRESULT ( STDMETHODCALLTYPE *Load )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *CanPlayType )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ BSTR type, + /* [annotation][out] */ + _Out_ MF_MEDIA_ENGINE_CANPLAY *pAnswer); + + USHORT ( STDMETHODCALLTYPE *GetReadyState )( + IMFMediaEngineEx * This); + + BOOL ( STDMETHODCALLTYPE *IsSeeking )( + IMFMediaEngineEx * This); + + double ( STDMETHODCALLTYPE *GetCurrentTime )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *SetCurrentTime )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ double seekTime); + + double ( STDMETHODCALLTYPE *GetStartTime )( + IMFMediaEngineEx * This); + + double ( STDMETHODCALLTYPE *GetDuration )( + IMFMediaEngineEx * This); + + BOOL ( STDMETHODCALLTYPE *IsPaused )( + IMFMediaEngineEx * This); + + double ( STDMETHODCALLTYPE *GetDefaultPlaybackRate )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *SetDefaultPlaybackRate )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ double Rate); + + double ( STDMETHODCALLTYPE *GetPlaybackRate )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *SetPlaybackRate )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ double Rate); + + HRESULT ( STDMETHODCALLTYPE *GetPlayed )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppPlayed); + + HRESULT ( STDMETHODCALLTYPE *GetSeekable )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppSeekable); + + BOOL ( STDMETHODCALLTYPE *IsEnded )( + IMFMediaEngineEx * This); + + BOOL ( STDMETHODCALLTYPE *GetAutoPlay )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *SetAutoPlay )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ BOOL AutoPlay); + + BOOL ( STDMETHODCALLTYPE *GetLoop )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *SetLoop )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ BOOL Loop); + + HRESULT ( STDMETHODCALLTYPE *Play )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *Pause )( + IMFMediaEngineEx * This); + + BOOL ( STDMETHODCALLTYPE *GetMuted )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *SetMuted )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ BOOL Muted); + + double ( STDMETHODCALLTYPE *GetVolume )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *SetVolume )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ double Volume); + + BOOL ( STDMETHODCALLTYPE *HasVideo )( + IMFMediaEngineEx * This); + + BOOL ( STDMETHODCALLTYPE *HasAudio )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *GetNativeVideoSize )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_opt_ DWORD *cx, + /* [annotation][out] */ + _Out_opt_ DWORD *cy); + + HRESULT ( STDMETHODCALLTYPE *GetVideoAspectRatio )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_opt_ DWORD *cx, + /* [annotation][out] */ + _Out_opt_ DWORD *cy); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *TransferVideoFrame )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ IUnknown *pDstSurf, + /* [annotation][in] */ + _In_opt_ const MFVideoNormalizedRect *pSrc, + /* [annotation][in] */ + _In_ const RECT *pDst, + /* [annotation][in] */ + _In_opt_ const MFARGB *pBorderClr); + + HRESULT ( STDMETHODCALLTYPE *OnVideoStreamTick )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_ LONGLONG *pPts); + + HRESULT ( STDMETHODCALLTYPE *SetSourceFromByteStream )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ IMFByteStream *pByteStream, + /* [annotation][in] */ + _In_ BSTR pURL); + + HRESULT ( STDMETHODCALLTYPE *GetStatistics )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_STATISTIC StatisticID, + /* [annotation][out] */ + _Out_ PROPVARIANT *pStatistic); + + HRESULT ( STDMETHODCALLTYPE *UpdateVideoStream )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_opt_ const MFVideoNormalizedRect *pSrc, + /* [annotation][in] */ + _In_opt_ const RECT *pDst, + /* [annotation][in] */ + _In_opt_ const MFARGB *pBorderClr); + + double ( STDMETHODCALLTYPE *GetBalance )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *SetBalance )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ double balance); + + BOOL ( STDMETHODCALLTYPE *IsPlaybackRateSupported )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ double rate); + + HRESULT ( STDMETHODCALLTYPE *FrameStep )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ BOOL Forward); + + HRESULT ( STDMETHODCALLTYPE *GetResourceCharacteristics )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_ DWORD *pCharacteristics); + + HRESULT ( STDMETHODCALLTYPE *GetPresentationAttribute )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ REFGUID guidMFAttribute, + /* [annotation][out] */ + _Out_ PROPVARIANT *pvValue); + + HRESULT ( STDMETHODCALLTYPE *GetNumberOfStreams )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_ DWORD *pdwStreamCount); + + HRESULT ( STDMETHODCALLTYPE *GetStreamAttribute )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ DWORD dwStreamIndex, + /* [annotation][in] */ + _In_ REFGUID guidMFAttribute, + /* [annotation][out] */ + _Out_ PROPVARIANT *pvValue); + + HRESULT ( STDMETHODCALLTYPE *GetStreamSelection )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ DWORD dwStreamIndex, + /* [annotation][out] */ + _Out_ BOOL *pEnabled); + + HRESULT ( STDMETHODCALLTYPE *SetStreamSelection )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ DWORD dwStreamIndex, + /* [annotation][in] */ + _In_ BOOL Enabled); + + HRESULT ( STDMETHODCALLTYPE *ApplyStreamSelections )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *IsProtected )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_ BOOL *pProtected); + + HRESULT ( STDMETHODCALLTYPE *InsertVideoEffect )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ IUnknown *pEffect, + /* [annotation][in] */ + _In_ BOOL fOptional); + + HRESULT ( STDMETHODCALLTYPE *InsertAudioEffect )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ IUnknown *pEffect, + /* [annotation][in] */ + _In_ BOOL fOptional); + + HRESULT ( STDMETHODCALLTYPE *RemoveAllEffects )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *SetTimelineMarkerTimer )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ double timeToFire); + + HRESULT ( STDMETHODCALLTYPE *GetTimelineMarkerTimer )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_ double *pTimeToFire); + + HRESULT ( STDMETHODCALLTYPE *CancelTimelineMarkerTimer )( + IMFMediaEngineEx * This); + + BOOL ( STDMETHODCALLTYPE *IsStereo3D )( + IMFMediaEngineEx * This); + + HRESULT ( STDMETHODCALLTYPE *GetStereo3DFramePackingMode )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_ MF_MEDIA_ENGINE_S3D_PACKING_MODE *packMode); + + HRESULT ( STDMETHODCALLTYPE *SetStereo3DFramePackingMode )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_S3D_PACKING_MODE packMode); + + HRESULT ( STDMETHODCALLTYPE *GetStereo3DRenderMode )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_ MF3DVideoOutputType *outputType); + + HRESULT ( STDMETHODCALLTYPE *SetStereo3DRenderMode )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ MF3DVideoOutputType outputType); + + HRESULT ( STDMETHODCALLTYPE *EnableWindowlessSwapchainMode )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ BOOL fEnable); + + HRESULT ( STDMETHODCALLTYPE *GetVideoSwapchainHandle )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_ HANDLE *phSwapchain); + + HRESULT ( STDMETHODCALLTYPE *EnableHorizontalMirrorMode )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ BOOL fEnable); + + HRESULT ( STDMETHODCALLTYPE *GetAudioStreamCategory )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_ UINT32 *pCategory); + + HRESULT ( STDMETHODCALLTYPE *SetAudioStreamCategory )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ UINT32 category); + + HRESULT ( STDMETHODCALLTYPE *GetAudioEndpointRole )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_ UINT32 *pRole); + + HRESULT ( STDMETHODCALLTYPE *SetAudioEndpointRole )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ UINT32 role); + + HRESULT ( STDMETHODCALLTYPE *GetRealTimeMode )( + IMFMediaEngineEx * This, + /* [annotation][out] */ + _Out_ BOOL *pfEnabled); + + HRESULT ( STDMETHODCALLTYPE *SetRealTimeMode )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ BOOL fEnable); + + HRESULT ( STDMETHODCALLTYPE *SetCurrentTimeEx )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ double seekTime, + /* [annotation][in] */ + _In_ MF_MEDIA_ENGINE_SEEK_MODE seekMode); + + HRESULT ( STDMETHODCALLTYPE *EnableTimeUpdateTimer )( + IMFMediaEngineEx * This, + /* [annotation][in] */ + _In_ BOOL fEnableTimer); + + END_INTERFACE + } IMFMediaEngineExVtbl; + + interface IMFMediaEngineEx + { + CONST_VTBL struct IMFMediaEngineExVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineEx_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineEx_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineEx_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineEx_GetError(This,ppError) \ + ( (This)->lpVtbl -> GetError(This,ppError) ) + +#define IMFMediaEngineEx_SetErrorCode(This,error) \ + ( (This)->lpVtbl -> SetErrorCode(This,error) ) + +#define IMFMediaEngineEx_SetSourceElements(This,pSrcElements) \ + ( (This)->lpVtbl -> SetSourceElements(This,pSrcElements) ) + +#define IMFMediaEngineEx_SetSource(This,pUrl) \ + ( (This)->lpVtbl -> SetSource(This,pUrl) ) + +#define IMFMediaEngineEx_GetCurrentSource(This,ppUrl) \ + ( (This)->lpVtbl -> GetCurrentSource(This,ppUrl) ) + +#define IMFMediaEngineEx_GetNetworkState(This) \ + ( (This)->lpVtbl -> GetNetworkState(This) ) + +#define IMFMediaEngineEx_GetPreload(This) \ + ( (This)->lpVtbl -> GetPreload(This) ) + +#define IMFMediaEngineEx_SetPreload(This,Preload) \ + ( (This)->lpVtbl -> SetPreload(This,Preload) ) + +#define IMFMediaEngineEx_GetBuffered(This,ppBuffered) \ + ( (This)->lpVtbl -> GetBuffered(This,ppBuffered) ) + +#define IMFMediaEngineEx_Load(This) \ + ( (This)->lpVtbl -> Load(This) ) + +#define IMFMediaEngineEx_CanPlayType(This,type,pAnswer) \ + ( (This)->lpVtbl -> CanPlayType(This,type,pAnswer) ) + +#define IMFMediaEngineEx_GetReadyState(This) \ + ( (This)->lpVtbl -> GetReadyState(This) ) + +#define IMFMediaEngineEx_IsSeeking(This) \ + ( (This)->lpVtbl -> IsSeeking(This) ) + +#define IMFMediaEngineEx_GetCurrentTime(This) \ + ( (This)->lpVtbl -> GetCurrentTime(This) ) + +#define IMFMediaEngineEx_SetCurrentTime(This,seekTime) \ + ( (This)->lpVtbl -> SetCurrentTime(This,seekTime) ) + +#define IMFMediaEngineEx_GetStartTime(This) \ + ( (This)->lpVtbl -> GetStartTime(This) ) + +#define IMFMediaEngineEx_GetDuration(This) \ + ( (This)->lpVtbl -> GetDuration(This) ) + +#define IMFMediaEngineEx_IsPaused(This) \ + ( (This)->lpVtbl -> IsPaused(This) ) + +#define IMFMediaEngineEx_GetDefaultPlaybackRate(This) \ + ( (This)->lpVtbl -> GetDefaultPlaybackRate(This) ) + +#define IMFMediaEngineEx_SetDefaultPlaybackRate(This,Rate) \ + ( (This)->lpVtbl -> SetDefaultPlaybackRate(This,Rate) ) + +#define IMFMediaEngineEx_GetPlaybackRate(This) \ + ( (This)->lpVtbl -> GetPlaybackRate(This) ) + +#define IMFMediaEngineEx_SetPlaybackRate(This,Rate) \ + ( (This)->lpVtbl -> SetPlaybackRate(This,Rate) ) + +#define IMFMediaEngineEx_GetPlayed(This,ppPlayed) \ + ( (This)->lpVtbl -> GetPlayed(This,ppPlayed) ) + +#define IMFMediaEngineEx_GetSeekable(This,ppSeekable) \ + ( (This)->lpVtbl -> GetSeekable(This,ppSeekable) ) + +#define IMFMediaEngineEx_IsEnded(This) \ + ( (This)->lpVtbl -> IsEnded(This) ) + +#define IMFMediaEngineEx_GetAutoPlay(This) \ + ( (This)->lpVtbl -> GetAutoPlay(This) ) + +#define IMFMediaEngineEx_SetAutoPlay(This,AutoPlay) \ + ( (This)->lpVtbl -> SetAutoPlay(This,AutoPlay) ) + +#define IMFMediaEngineEx_GetLoop(This) \ + ( (This)->lpVtbl -> GetLoop(This) ) + +#define IMFMediaEngineEx_SetLoop(This,Loop) \ + ( (This)->lpVtbl -> SetLoop(This,Loop) ) + +#define IMFMediaEngineEx_Play(This) \ + ( (This)->lpVtbl -> Play(This) ) + +#define IMFMediaEngineEx_Pause(This) \ + ( (This)->lpVtbl -> Pause(This) ) + +#define IMFMediaEngineEx_GetMuted(This) \ + ( (This)->lpVtbl -> GetMuted(This) ) + +#define IMFMediaEngineEx_SetMuted(This,Muted) \ + ( (This)->lpVtbl -> SetMuted(This,Muted) ) + +#define IMFMediaEngineEx_GetVolume(This) \ + ( (This)->lpVtbl -> GetVolume(This) ) + +#define IMFMediaEngineEx_SetVolume(This,Volume) \ + ( (This)->lpVtbl -> SetVolume(This,Volume) ) + +#define IMFMediaEngineEx_HasVideo(This) \ + ( (This)->lpVtbl -> HasVideo(This) ) + +#define IMFMediaEngineEx_HasAudio(This) \ + ( (This)->lpVtbl -> HasAudio(This) ) + +#define IMFMediaEngineEx_GetNativeVideoSize(This,cx,cy) \ + ( (This)->lpVtbl -> GetNativeVideoSize(This,cx,cy) ) + +#define IMFMediaEngineEx_GetVideoAspectRatio(This,cx,cy) \ + ( (This)->lpVtbl -> GetVideoAspectRatio(This,cx,cy) ) + +#define IMFMediaEngineEx_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + +#define IMFMediaEngineEx_TransferVideoFrame(This,pDstSurf,pSrc,pDst,pBorderClr) \ + ( (This)->lpVtbl -> TransferVideoFrame(This,pDstSurf,pSrc,pDst,pBorderClr) ) + +#define IMFMediaEngineEx_OnVideoStreamTick(This,pPts) \ + ( (This)->lpVtbl -> OnVideoStreamTick(This,pPts) ) + + +#define IMFMediaEngineEx_SetSourceFromByteStream(This,pByteStream,pURL) \ + ( (This)->lpVtbl -> SetSourceFromByteStream(This,pByteStream,pURL) ) + +#define IMFMediaEngineEx_GetStatistics(This,StatisticID,pStatistic) \ + ( (This)->lpVtbl -> GetStatistics(This,StatisticID,pStatistic) ) + +#define IMFMediaEngineEx_UpdateVideoStream(This,pSrc,pDst,pBorderClr) \ + ( (This)->lpVtbl -> UpdateVideoStream(This,pSrc,pDst,pBorderClr) ) + +#define IMFMediaEngineEx_GetBalance(This) \ + ( (This)->lpVtbl -> GetBalance(This) ) + +#define IMFMediaEngineEx_SetBalance(This,balance) \ + ( (This)->lpVtbl -> SetBalance(This,balance) ) + +#define IMFMediaEngineEx_IsPlaybackRateSupported(This,rate) \ + ( (This)->lpVtbl -> IsPlaybackRateSupported(This,rate) ) + +#define IMFMediaEngineEx_FrameStep(This,Forward) \ + ( (This)->lpVtbl -> FrameStep(This,Forward) ) + +#define IMFMediaEngineEx_GetResourceCharacteristics(This,pCharacteristics) \ + ( (This)->lpVtbl -> GetResourceCharacteristics(This,pCharacteristics) ) + +#define IMFMediaEngineEx_GetPresentationAttribute(This,guidMFAttribute,pvValue) \ + ( (This)->lpVtbl -> GetPresentationAttribute(This,guidMFAttribute,pvValue) ) + +#define IMFMediaEngineEx_GetNumberOfStreams(This,pdwStreamCount) \ + ( (This)->lpVtbl -> GetNumberOfStreams(This,pdwStreamCount) ) + +#define IMFMediaEngineEx_GetStreamAttribute(This,dwStreamIndex,guidMFAttribute,pvValue) \ + ( (This)->lpVtbl -> GetStreamAttribute(This,dwStreamIndex,guidMFAttribute,pvValue) ) + +#define IMFMediaEngineEx_GetStreamSelection(This,dwStreamIndex,pEnabled) \ + ( (This)->lpVtbl -> GetStreamSelection(This,dwStreamIndex,pEnabled) ) + +#define IMFMediaEngineEx_SetStreamSelection(This,dwStreamIndex,Enabled) \ + ( (This)->lpVtbl -> SetStreamSelection(This,dwStreamIndex,Enabled) ) + +#define IMFMediaEngineEx_ApplyStreamSelections(This) \ + ( (This)->lpVtbl -> ApplyStreamSelections(This) ) + +#define IMFMediaEngineEx_IsProtected(This,pProtected) \ + ( (This)->lpVtbl -> IsProtected(This,pProtected) ) + +#define IMFMediaEngineEx_InsertVideoEffect(This,pEffect,fOptional) \ + ( (This)->lpVtbl -> InsertVideoEffect(This,pEffect,fOptional) ) + +#define IMFMediaEngineEx_InsertAudioEffect(This,pEffect,fOptional) \ + ( (This)->lpVtbl -> InsertAudioEffect(This,pEffect,fOptional) ) + +#define IMFMediaEngineEx_RemoveAllEffects(This) \ + ( (This)->lpVtbl -> RemoveAllEffects(This) ) + +#define IMFMediaEngineEx_SetTimelineMarkerTimer(This,timeToFire) \ + ( (This)->lpVtbl -> SetTimelineMarkerTimer(This,timeToFire) ) + +#define IMFMediaEngineEx_GetTimelineMarkerTimer(This,pTimeToFire) \ + ( (This)->lpVtbl -> GetTimelineMarkerTimer(This,pTimeToFire) ) + +#define IMFMediaEngineEx_CancelTimelineMarkerTimer(This) \ + ( (This)->lpVtbl -> CancelTimelineMarkerTimer(This) ) + +#define IMFMediaEngineEx_IsStereo3D(This) \ + ( (This)->lpVtbl -> IsStereo3D(This) ) + +#define IMFMediaEngineEx_GetStereo3DFramePackingMode(This,packMode) \ + ( (This)->lpVtbl -> GetStereo3DFramePackingMode(This,packMode) ) + +#define IMFMediaEngineEx_SetStereo3DFramePackingMode(This,packMode) \ + ( (This)->lpVtbl -> SetStereo3DFramePackingMode(This,packMode) ) + +#define IMFMediaEngineEx_GetStereo3DRenderMode(This,outputType) \ + ( (This)->lpVtbl -> GetStereo3DRenderMode(This,outputType) ) + +#define IMFMediaEngineEx_SetStereo3DRenderMode(This,outputType) \ + ( (This)->lpVtbl -> SetStereo3DRenderMode(This,outputType) ) + +#define IMFMediaEngineEx_EnableWindowlessSwapchainMode(This,fEnable) \ + ( (This)->lpVtbl -> EnableWindowlessSwapchainMode(This,fEnable) ) + +#define IMFMediaEngineEx_GetVideoSwapchainHandle(This,phSwapchain) \ + ( (This)->lpVtbl -> GetVideoSwapchainHandle(This,phSwapchain) ) + +#define IMFMediaEngineEx_EnableHorizontalMirrorMode(This,fEnable) \ + ( (This)->lpVtbl -> EnableHorizontalMirrorMode(This,fEnable) ) + +#define IMFMediaEngineEx_GetAudioStreamCategory(This,pCategory) \ + ( (This)->lpVtbl -> GetAudioStreamCategory(This,pCategory) ) + +#define IMFMediaEngineEx_SetAudioStreamCategory(This,category) \ + ( (This)->lpVtbl -> SetAudioStreamCategory(This,category) ) + +#define IMFMediaEngineEx_GetAudioEndpointRole(This,pRole) \ + ( (This)->lpVtbl -> GetAudioEndpointRole(This,pRole) ) + +#define IMFMediaEngineEx_SetAudioEndpointRole(This,role) \ + ( (This)->lpVtbl -> SetAudioEndpointRole(This,role) ) + +#define IMFMediaEngineEx_GetRealTimeMode(This,pfEnabled) \ + ( (This)->lpVtbl -> GetRealTimeMode(This,pfEnabled) ) + +#define IMFMediaEngineEx_SetRealTimeMode(This,fEnable) \ + ( (This)->lpVtbl -> SetRealTimeMode(This,fEnable) ) + +#define IMFMediaEngineEx_SetCurrentTimeEx(This,seekTime,seekMode) \ + ( (This)->lpVtbl -> SetCurrentTimeEx(This,seekTime,seekMode) ) + +#define IMFMediaEngineEx_EnableTimeUpdateTimer(This,fEnableTimer) \ + ( (This)->lpVtbl -> EnableTimeUpdateTimer(This,fEnableTimer) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineEx_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaEngineAudioEndpointId_INTERFACE_DEFINED__ +#define __IMFMediaEngineAudioEndpointId_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineAudioEndpointId */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineAudioEndpointId; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7a3bac98-0e76-49fb-8c20-8a86fd98eaf2") + IMFMediaEngineAudioEndpointId : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetAudioEndpointId( + /* [annotation][in] */ + _In_opt_ LPCWSTR pszEndpointId) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAudioEndpointId( + /* [annotation][out] */ + _Outptr_ LPWSTR *ppszEndpointId) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineAudioEndpointIdVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineAudioEndpointId * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineAudioEndpointId * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineAudioEndpointId * This); + + HRESULT ( STDMETHODCALLTYPE *SetAudioEndpointId )( + IMFMediaEngineAudioEndpointId * This, + /* [annotation][in] */ + _In_opt_ LPCWSTR pszEndpointId); + + HRESULT ( STDMETHODCALLTYPE *GetAudioEndpointId )( + IMFMediaEngineAudioEndpointId * This, + /* [annotation][out] */ + _Outptr_ LPWSTR *ppszEndpointId); + + END_INTERFACE + } IMFMediaEngineAudioEndpointIdVtbl; + + interface IMFMediaEngineAudioEndpointId + { + CONST_VTBL struct IMFMediaEngineAudioEndpointIdVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineAudioEndpointId_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineAudioEndpointId_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineAudioEndpointId_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineAudioEndpointId_SetAudioEndpointId(This,pszEndpointId) \ + ( (This)->lpVtbl -> SetAudioEndpointId(This,pszEndpointId) ) + +#define IMFMediaEngineAudioEndpointId_GetAudioEndpointId(This,ppszEndpointId) \ + ( (This)->lpVtbl -> GetAudioEndpointId(This,ppszEndpointId) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineAudioEndpointId_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0007 */ +/* [local] */ + +typedef +enum MF_MEDIA_ENGINE_EXTENSION_TYPE + { + MF_MEDIA_ENGINE_EXTENSION_TYPE_MEDIASOURCE = 0, + MF_MEDIA_ENGINE_EXTENSION_TYPE_BYTESTREAM = 1 + } MF_MEDIA_ENGINE_EXTENSION_TYPE; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0007_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0007_v0_0_s_ifspec; + +#ifndef __IMFMediaEngineExtension_INTERFACE_DEFINED__ +#define __IMFMediaEngineExtension_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineExtension */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineExtension; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2f69d622-20b5-41e9-afdf-89ced1dda04e") + IMFMediaEngineExtension : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CanPlayType( + /* [annotation][in] */ + _In_ BOOL AudioOnly, + /* [annotation][in] */ + _In_ BSTR MimeType, + /* [annotation][out] */ + _Out_ MF_MEDIA_ENGINE_CANPLAY *pAnswer) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginCreateObject( + /* [annotation][in] */ + _In_ BSTR bstrURL, + /* [annotation][in] */ + _In_opt_ IMFByteStream *pByteStream, + /* [annotation][in] */ + _In_ MF_OBJECT_TYPE type, + /* [annotation][out] */ + _Outptr_ IUnknown **ppIUnknownCancelCookie, + /* [annotation][in] */ + _In_ IMFAsyncCallback *pCallback, + /* [annotation][in] */ + _In_opt_ IUnknown *punkState) = 0; + + virtual HRESULT STDMETHODCALLTYPE CancelObjectCreation( + /* [annotation][in] */ + _In_ IUnknown *pIUnknownCancelCookie) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndCreateObject( + /* [annotation][in] */ + _In_ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineExtensionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineExtension * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineExtension * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineExtension * This); + + HRESULT ( STDMETHODCALLTYPE *CanPlayType )( + IMFMediaEngineExtension * This, + /* [annotation][in] */ + _In_ BOOL AudioOnly, + /* [annotation][in] */ + _In_ BSTR MimeType, + /* [annotation][out] */ + _Out_ MF_MEDIA_ENGINE_CANPLAY *pAnswer); + + HRESULT ( STDMETHODCALLTYPE *BeginCreateObject )( + IMFMediaEngineExtension * This, + /* [annotation][in] */ + _In_ BSTR bstrURL, + /* [annotation][in] */ + _In_opt_ IMFByteStream *pByteStream, + /* [annotation][in] */ + _In_ MF_OBJECT_TYPE type, + /* [annotation][out] */ + _Outptr_ IUnknown **ppIUnknownCancelCookie, + /* [annotation][in] */ + _In_ IMFAsyncCallback *pCallback, + /* [annotation][in] */ + _In_opt_ IUnknown *punkState); + + HRESULT ( STDMETHODCALLTYPE *CancelObjectCreation )( + IMFMediaEngineExtension * This, + /* [annotation][in] */ + _In_ IUnknown *pIUnknownCancelCookie); + + HRESULT ( STDMETHODCALLTYPE *EndCreateObject )( + IMFMediaEngineExtension * This, + /* [annotation][in] */ + _In_ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Outptr_ IUnknown **ppObject); + + END_INTERFACE + } IMFMediaEngineExtensionVtbl; + + interface IMFMediaEngineExtension + { + CONST_VTBL struct IMFMediaEngineExtensionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineExtension_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineExtension_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineExtension_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineExtension_CanPlayType(This,AudioOnly,MimeType,pAnswer) \ + ( (This)->lpVtbl -> CanPlayType(This,AudioOnly,MimeType,pAnswer) ) + +#define IMFMediaEngineExtension_BeginCreateObject(This,bstrURL,pByteStream,type,ppIUnknownCancelCookie,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginCreateObject(This,bstrURL,pByteStream,type,ppIUnknownCancelCookie,pCallback,punkState) ) + +#define IMFMediaEngineExtension_CancelObjectCreation(This,pIUnknownCancelCookie) \ + ( (This)->lpVtbl -> CancelObjectCreation(This,pIUnknownCancelCookie) ) + +#define IMFMediaEngineExtension_EndCreateObject(This,pResult,ppObject) \ + ( (This)->lpVtbl -> EndCreateObject(This,pResult,ppObject) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineExtension_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0008 */ +/* [local] */ + + +enum MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAGS + { + MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAG_PROTECTED = 0x1, + MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAG_REQUIRES_SURFACE_PROTECTION = 0x2, + MF_MEDIA_ENGINE_FRAME_PROTECTION_FLAG_REQUIRES_ANTI_SCREEN_SCRAPE_PROTECTION = 0x4 + } ; + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0008_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0008_v0_0_s_ifspec; + +#ifndef __IMFMediaEngineProtectedContent_INTERFACE_DEFINED__ +#define __IMFMediaEngineProtectedContent_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineProtectedContent */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineProtectedContent; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9f8021e8-9c8c-487e-bb5c-79aa4779938c") + IMFMediaEngineProtectedContent : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ShareResources( + /* [annotation] */ + _In_ IUnknown *pUnkDeviceContext) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRequiredProtections( + /* [annotation][out] */ + _Out_ DWORD *pFrameProtectionFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetOPMWindow( + /* [annotation][in] */ + _In_ HWND hwnd) = 0; + + virtual HRESULT STDMETHODCALLTYPE TransferVideoFrame( + /* [annotation][in] */ + _In_ IUnknown *pDstSurf, + /* [annotation][in] */ + _In_opt_ const MFVideoNormalizedRect *pSrc, + /* [annotation][in] */ + _In_ const RECT *pDst, + /* [annotation][in] */ + _In_opt_ const MFARGB *pBorderClr, + /* [annotation][out] */ + _Out_ DWORD *pFrameProtectionFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetContentProtectionManager( + /* [annotation][in] */ + _In_opt_ IMFContentProtectionManager *pCPM) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetApplicationCertificate( + /* [annotation][in] */ + _In_reads_bytes_(cbBlob) const BYTE *pbBlob, + /* [annotation][in] */ + _In_ DWORD cbBlob) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineProtectedContentVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineProtectedContent * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineProtectedContent * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineProtectedContent * This); + + HRESULT ( STDMETHODCALLTYPE *ShareResources )( + IMFMediaEngineProtectedContent * This, + /* [annotation] */ + _In_ IUnknown *pUnkDeviceContext); + + HRESULT ( STDMETHODCALLTYPE *GetRequiredProtections )( + IMFMediaEngineProtectedContent * This, + /* [annotation][out] */ + _Out_ DWORD *pFrameProtectionFlags); + + HRESULT ( STDMETHODCALLTYPE *SetOPMWindow )( + IMFMediaEngineProtectedContent * This, + /* [annotation][in] */ + _In_ HWND hwnd); + + HRESULT ( STDMETHODCALLTYPE *TransferVideoFrame )( + IMFMediaEngineProtectedContent * This, + /* [annotation][in] */ + _In_ IUnknown *pDstSurf, + /* [annotation][in] */ + _In_opt_ const MFVideoNormalizedRect *pSrc, + /* [annotation][in] */ + _In_ const RECT *pDst, + /* [annotation][in] */ + _In_opt_ const MFARGB *pBorderClr, + /* [annotation][out] */ + _Out_ DWORD *pFrameProtectionFlags); + + HRESULT ( STDMETHODCALLTYPE *SetContentProtectionManager )( + IMFMediaEngineProtectedContent * This, + /* [annotation][in] */ + _In_opt_ IMFContentProtectionManager *pCPM); + + HRESULT ( STDMETHODCALLTYPE *SetApplicationCertificate )( + IMFMediaEngineProtectedContent * This, + /* [annotation][in] */ + _In_reads_bytes_(cbBlob) const BYTE *pbBlob, + /* [annotation][in] */ + _In_ DWORD cbBlob); + + END_INTERFACE + } IMFMediaEngineProtectedContentVtbl; + + interface IMFMediaEngineProtectedContent + { + CONST_VTBL struct IMFMediaEngineProtectedContentVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineProtectedContent_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineProtectedContent_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineProtectedContent_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineProtectedContent_ShareResources(This,pUnkDeviceContext) \ + ( (This)->lpVtbl -> ShareResources(This,pUnkDeviceContext) ) + +#define IMFMediaEngineProtectedContent_GetRequiredProtections(This,pFrameProtectionFlags) \ + ( (This)->lpVtbl -> GetRequiredProtections(This,pFrameProtectionFlags) ) + +#define IMFMediaEngineProtectedContent_SetOPMWindow(This,hwnd) \ + ( (This)->lpVtbl -> SetOPMWindow(This,hwnd) ) + +#define IMFMediaEngineProtectedContent_TransferVideoFrame(This,pDstSurf,pSrc,pDst,pBorderClr,pFrameProtectionFlags) \ + ( (This)->lpVtbl -> TransferVideoFrame(This,pDstSurf,pSrc,pDst,pBorderClr,pFrameProtectionFlags) ) + +#define IMFMediaEngineProtectedContent_SetContentProtectionManager(This,pCPM) \ + ( (This)->lpVtbl -> SetContentProtectionManager(This,pCPM) ) + +#define IMFMediaEngineProtectedContent_SetApplicationCertificate(This,pbBlob,cbBlob) \ + ( (This)->lpVtbl -> SetApplicationCertificate(This,pbBlob,cbBlob) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineProtectedContent_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0009 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0009_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0009_v0_0_s_ifspec; + +#ifndef __IAudioSourceProvider_INTERFACE_DEFINED__ +#define __IAudioSourceProvider_INTERFACE_DEFINED__ + +/* interface IAudioSourceProvider */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IAudioSourceProvider; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("EBBAF249-AFC2-4582-91C6-B60DF2E84954") + IAudioSourceProvider : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ProvideInput( + /* [annotation][in] */ + _In_ DWORD dwSampleCount, + /* [annotation][in] */ + _Inout_ DWORD *pdwChannelCount, + /* [annotation][out] */ + _Out_writes_opt_(dwSampleCount * (*pdwChannelCount)) float *pInterleavedAudioData) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IAudioSourceProviderVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IAudioSourceProvider * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IAudioSourceProvider * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IAudioSourceProvider * This); + + HRESULT ( STDMETHODCALLTYPE *ProvideInput )( + IAudioSourceProvider * This, + /* [annotation][in] */ + _In_ DWORD dwSampleCount, + /* [annotation][in] */ + _Inout_ DWORD *pdwChannelCount, + /* [annotation][out] */ + _Out_writes_opt_(dwSampleCount * (*pdwChannelCount)) float *pInterleavedAudioData); + + END_INTERFACE + } IAudioSourceProviderVtbl; + + interface IAudioSourceProvider + { + CONST_VTBL struct IAudioSourceProviderVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IAudioSourceProvider_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IAudioSourceProvider_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IAudioSourceProvider_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IAudioSourceProvider_ProvideInput(This,dwSampleCount,pdwChannelCount,pInterleavedAudioData) \ + ( (This)->lpVtbl -> ProvideInput(This,dwSampleCount,pdwChannelCount,pInterleavedAudioData) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IAudioSourceProvider_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaEngineWebSupport_INTERFACE_DEFINED__ +#define __IMFMediaEngineWebSupport_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineWebSupport */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineWebSupport; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ba2743a1-07e0-48ef-84b6-9a2ed023ca6c") + IMFMediaEngineWebSupport : public IUnknown + { + public: + virtual BOOL STDMETHODCALLTYPE ShouldDelayTheLoadEvent( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE ConnectWebAudio( + /* [annotation][in] */ + _In_ DWORD dwSampleRate, + /* [annotation][out] */ + _COM_Outptr_ IAudioSourceProvider **ppSourceProvider) = 0; + + virtual HRESULT STDMETHODCALLTYPE DisconnectWebAudio( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineWebSupportVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineWebSupport * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineWebSupport * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineWebSupport * This); + + BOOL ( STDMETHODCALLTYPE *ShouldDelayTheLoadEvent )( + IMFMediaEngineWebSupport * This); + + HRESULT ( STDMETHODCALLTYPE *ConnectWebAudio )( + IMFMediaEngineWebSupport * This, + /* [annotation][in] */ + _In_ DWORD dwSampleRate, + /* [annotation][out] */ + _COM_Outptr_ IAudioSourceProvider **ppSourceProvider); + + HRESULT ( STDMETHODCALLTYPE *DisconnectWebAudio )( + IMFMediaEngineWebSupport * This); + + END_INTERFACE + } IMFMediaEngineWebSupportVtbl; + + interface IMFMediaEngineWebSupport + { + CONST_VTBL struct IMFMediaEngineWebSupportVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineWebSupport_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineWebSupport_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineWebSupport_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineWebSupport_ShouldDelayTheLoadEvent(This) \ + ( (This)->lpVtbl -> ShouldDelayTheLoadEvent(This) ) + +#define IMFMediaEngineWebSupport_ConnectWebAudio(This,dwSampleRate,ppSourceProvider) \ + ( (This)->lpVtbl -> ConnectWebAudio(This,dwSampleRate,ppSourceProvider) ) + +#define IMFMediaEngineWebSupport_DisconnectWebAudio(This) \ + ( (This)->lpVtbl -> DisconnectWebAudio(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineWebSupport_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0011 */ +/* [local] */ + +EXTERN_GUID(MF_MSE_CALLBACK, +0x9063a7c0, 0x42c5, 0x4ffd, 0xa8, 0xa8, 0x6f, 0xcf, 0x9e, 0xa3, 0xd0, 0x0c); +EXTERN_GUID(MF_MSE_ACTIVELIST_CALLBACK, +0x949bda0f, 0x4549, 0x46d5, 0xad, 0x7f, 0xb8, 0x46, 0xe1, 0xab, 0x16, 0x52); +EXTERN_GUID(MF_MSE_BUFFERLIST_CALLBACK, +0x42e669b0, 0xd60e, 0x4afb, 0xa8, 0x5b, 0xd8, 0xe5, 0xfe, 0x6b, 0xda, 0xb5); +EXTERN_GUID(MF_MSE_VP9_SUPPORT, +0x92d78429, 0xd88b, 0x4ff0, 0x83, 0x22, 0x80, 0x3e, 0xfa, 0x6e, 0x96, 0x26); +EXTERN_GUID(MF_MSE_OPUS_SUPPORT, +0x4d224cc1, 0x8cc4, 0x48a3, 0xa7, 0xa7, 0xe4, 0xc1, 0x6c, 0xe6, 0x38, 0x8a); +typedef +enum MF_MSE_VP9_SUPPORT_TYPE + { + MF_MSE_VP9_SUPPORT_DEFAULT = 0, + MF_MSE_VP9_SUPPORT_ON = 1, + MF_MSE_VP9_SUPPORT_OFF = 2 + } MF_MSE_VP9_SUPPORT_TYPE; + +typedef +enum MF_MSE_OPUS_SUPPORT_TYPE + { + MF_MSE_OPUS_SUPPORT_ON = 0, + MF_MSE_OPUS_SUPPORT_OFF = 1 + } MF_MSE_OPUS_SUPPORT_TYPE; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0011_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0011_v0_0_s_ifspec; + +#ifndef __IMFMediaSourceExtensionNotify_INTERFACE_DEFINED__ +#define __IMFMediaSourceExtensionNotify_INTERFACE_DEFINED__ + +/* interface IMFMediaSourceExtensionNotify */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaSourceExtensionNotify; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("a7901327-05dd-4469-a7b7-0e01979e361d") + IMFMediaSourceExtensionNotify : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE OnSourceOpen( void) = 0; + + virtual void STDMETHODCALLTYPE OnSourceEnded( void) = 0; + + virtual void STDMETHODCALLTYPE OnSourceClose( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaSourceExtensionNotifyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaSourceExtensionNotify * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaSourceExtensionNotify * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaSourceExtensionNotify * This); + + void ( STDMETHODCALLTYPE *OnSourceOpen )( + IMFMediaSourceExtensionNotify * This); + + void ( STDMETHODCALLTYPE *OnSourceEnded )( + IMFMediaSourceExtensionNotify * This); + + void ( STDMETHODCALLTYPE *OnSourceClose )( + IMFMediaSourceExtensionNotify * This); + + END_INTERFACE + } IMFMediaSourceExtensionNotifyVtbl; + + interface IMFMediaSourceExtensionNotify + { + CONST_VTBL struct IMFMediaSourceExtensionNotifyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaSourceExtensionNotify_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaSourceExtensionNotify_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaSourceExtensionNotify_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaSourceExtensionNotify_OnSourceOpen(This) \ + ( (This)->lpVtbl -> OnSourceOpen(This) ) + +#define IMFMediaSourceExtensionNotify_OnSourceEnded(This) \ + ( (This)->lpVtbl -> OnSourceEnded(This) ) + +#define IMFMediaSourceExtensionNotify_OnSourceClose(This) \ + ( (This)->lpVtbl -> OnSourceClose(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaSourceExtensionNotify_INTERFACE_DEFINED__ */ + + +#ifndef __IMFBufferListNotify_INTERFACE_DEFINED__ +#define __IMFBufferListNotify_INTERFACE_DEFINED__ + +/* interface IMFBufferListNotify */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFBufferListNotify; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("24cd47f7-81d8-4785-adb2-af697a963cd2") + IMFBufferListNotify : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE OnAddSourceBuffer( void) = 0; + + virtual void STDMETHODCALLTYPE OnRemoveSourceBuffer( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFBufferListNotifyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFBufferListNotify * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFBufferListNotify * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFBufferListNotify * This); + + void ( STDMETHODCALLTYPE *OnAddSourceBuffer )( + IMFBufferListNotify * This); + + void ( STDMETHODCALLTYPE *OnRemoveSourceBuffer )( + IMFBufferListNotify * This); + + END_INTERFACE + } IMFBufferListNotifyVtbl; + + interface IMFBufferListNotify + { + CONST_VTBL struct IMFBufferListNotifyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFBufferListNotify_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFBufferListNotify_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFBufferListNotify_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFBufferListNotify_OnAddSourceBuffer(This) \ + ( (This)->lpVtbl -> OnAddSourceBuffer(This) ) + +#define IMFBufferListNotify_OnRemoveSourceBuffer(This) \ + ( (This)->lpVtbl -> OnRemoveSourceBuffer(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFBufferListNotify_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSourceBufferNotify_INTERFACE_DEFINED__ +#define __IMFSourceBufferNotify_INTERFACE_DEFINED__ + +/* interface IMFSourceBufferNotify */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFSourceBufferNotify; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("87e47623-2ceb-45d6-9b88-d8520c4dcbbc") + IMFSourceBufferNotify : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE OnUpdateStart( void) = 0; + + virtual void STDMETHODCALLTYPE OnAbort( void) = 0; + + virtual void STDMETHODCALLTYPE OnError( + /* [annotation][in] */ + _In_ HRESULT hr) = 0; + + virtual void STDMETHODCALLTYPE OnUpdate( void) = 0; + + virtual void STDMETHODCALLTYPE OnUpdateEnd( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSourceBufferNotifyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSourceBufferNotify * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSourceBufferNotify * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSourceBufferNotify * This); + + void ( STDMETHODCALLTYPE *OnUpdateStart )( + IMFSourceBufferNotify * This); + + void ( STDMETHODCALLTYPE *OnAbort )( + IMFSourceBufferNotify * This); + + void ( STDMETHODCALLTYPE *OnError )( + IMFSourceBufferNotify * This, + /* [annotation][in] */ + _In_ HRESULT hr); + + void ( STDMETHODCALLTYPE *OnUpdate )( + IMFSourceBufferNotify * This); + + void ( STDMETHODCALLTYPE *OnUpdateEnd )( + IMFSourceBufferNotify * This); + + END_INTERFACE + } IMFSourceBufferNotifyVtbl; + + interface IMFSourceBufferNotify + { + CONST_VTBL struct IMFSourceBufferNotifyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSourceBufferNotify_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSourceBufferNotify_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSourceBufferNotify_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSourceBufferNotify_OnUpdateStart(This) \ + ( (This)->lpVtbl -> OnUpdateStart(This) ) + +#define IMFSourceBufferNotify_OnAbort(This) \ + ( (This)->lpVtbl -> OnAbort(This) ) + +#define IMFSourceBufferNotify_OnError(This,hr) \ + ( (This)->lpVtbl -> OnError(This,hr) ) + +#define IMFSourceBufferNotify_OnUpdate(This) \ + ( (This)->lpVtbl -> OnUpdate(This) ) + +#define IMFSourceBufferNotify_OnUpdateEnd(This) \ + ( (This)->lpVtbl -> OnUpdateEnd(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSourceBufferNotify_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSourceBuffer_INTERFACE_DEFINED__ +#define __IMFSourceBuffer_INTERFACE_DEFINED__ + +/* interface IMFSourceBuffer */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFSourceBuffer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e2cd3a4b-af25-4d3d-9110-da0e6f8ee877") + IMFSourceBuffer : public IUnknown + { + public: + virtual BOOL STDMETHODCALLTYPE GetUpdating( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBuffered( + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppBuffered) = 0; + + virtual double STDMETHODCALLTYPE GetTimeStampOffset( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetTimeStampOffset( + /* [annotation][in] */ + _In_ double offset) = 0; + + virtual double STDMETHODCALLTYPE GetAppendWindowStart( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAppendWindowStart( + /* [annotation][in] */ + _In_ double time) = 0; + + virtual double STDMETHODCALLTYPE GetAppendWindowEnd( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAppendWindowEnd( + /* [annotation][in] */ + _In_ double time) = 0; + + virtual HRESULT STDMETHODCALLTYPE Append( + /* [annotation][in] */ + _In_reads_bytes_(len) const BYTE *pData, + /* [annotation][in] */ + _In_ DWORD len) = 0; + + virtual HRESULT STDMETHODCALLTYPE AppendByteStream( + /* [annotation][in] */ + _In_ IMFByteStream *pStream, + /* [annotation][in] */ + _In_opt_ DWORDLONG *pMaxLen) = 0; + + virtual HRESULT STDMETHODCALLTYPE Abort( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Remove( + /* [annotation][in] */ + _In_ double start, + /* [annotation][in] */ + _In_ double end) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSourceBufferVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSourceBuffer * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSourceBuffer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSourceBuffer * This); + + BOOL ( STDMETHODCALLTYPE *GetUpdating )( + IMFSourceBuffer * This); + + HRESULT ( STDMETHODCALLTYPE *GetBuffered )( + IMFSourceBuffer * This, + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppBuffered); + + double ( STDMETHODCALLTYPE *GetTimeStampOffset )( + IMFSourceBuffer * This); + + HRESULT ( STDMETHODCALLTYPE *SetTimeStampOffset )( + IMFSourceBuffer * This, + /* [annotation][in] */ + _In_ double offset); + + double ( STDMETHODCALLTYPE *GetAppendWindowStart )( + IMFSourceBuffer * This); + + HRESULT ( STDMETHODCALLTYPE *SetAppendWindowStart )( + IMFSourceBuffer * This, + /* [annotation][in] */ + _In_ double time); + + double ( STDMETHODCALLTYPE *GetAppendWindowEnd )( + IMFSourceBuffer * This); + + HRESULT ( STDMETHODCALLTYPE *SetAppendWindowEnd )( + IMFSourceBuffer * This, + /* [annotation][in] */ + _In_ double time); + + HRESULT ( STDMETHODCALLTYPE *Append )( + IMFSourceBuffer * This, + /* [annotation][in] */ + _In_reads_bytes_(len) const BYTE *pData, + /* [annotation][in] */ + _In_ DWORD len); + + HRESULT ( STDMETHODCALLTYPE *AppendByteStream )( + IMFSourceBuffer * This, + /* [annotation][in] */ + _In_ IMFByteStream *pStream, + /* [annotation][in] */ + _In_opt_ DWORDLONG *pMaxLen); + + HRESULT ( STDMETHODCALLTYPE *Abort )( + IMFSourceBuffer * This); + + HRESULT ( STDMETHODCALLTYPE *Remove )( + IMFSourceBuffer * This, + /* [annotation][in] */ + _In_ double start, + /* [annotation][in] */ + _In_ double end); + + END_INTERFACE + } IMFSourceBufferVtbl; + + interface IMFSourceBuffer + { + CONST_VTBL struct IMFSourceBufferVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSourceBuffer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSourceBuffer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSourceBuffer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSourceBuffer_GetUpdating(This) \ + ( (This)->lpVtbl -> GetUpdating(This) ) + +#define IMFSourceBuffer_GetBuffered(This,ppBuffered) \ + ( (This)->lpVtbl -> GetBuffered(This,ppBuffered) ) + +#define IMFSourceBuffer_GetTimeStampOffset(This) \ + ( (This)->lpVtbl -> GetTimeStampOffset(This) ) + +#define IMFSourceBuffer_SetTimeStampOffset(This,offset) \ + ( (This)->lpVtbl -> SetTimeStampOffset(This,offset) ) + +#define IMFSourceBuffer_GetAppendWindowStart(This) \ + ( (This)->lpVtbl -> GetAppendWindowStart(This) ) + +#define IMFSourceBuffer_SetAppendWindowStart(This,time) \ + ( (This)->lpVtbl -> SetAppendWindowStart(This,time) ) + +#define IMFSourceBuffer_GetAppendWindowEnd(This) \ + ( (This)->lpVtbl -> GetAppendWindowEnd(This) ) + +#define IMFSourceBuffer_SetAppendWindowEnd(This,time) \ + ( (This)->lpVtbl -> SetAppendWindowEnd(This,time) ) + +#define IMFSourceBuffer_Append(This,pData,len) \ + ( (This)->lpVtbl -> Append(This,pData,len) ) + +#define IMFSourceBuffer_AppendByteStream(This,pStream,pMaxLen) \ + ( (This)->lpVtbl -> AppendByteStream(This,pStream,pMaxLen) ) + +#define IMFSourceBuffer_Abort(This) \ + ( (This)->lpVtbl -> Abort(This) ) + +#define IMFSourceBuffer_Remove(This,start,end) \ + ( (This)->lpVtbl -> Remove(This,start,end) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSourceBuffer_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0015 */ +/* [local] */ + +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +typedef +enum MF_MSE_APPEND_MODE + { + MF_MSE_APPEND_MODE_SEGMENTS = 0, + MF_MSE_APPEND_MODE_SEQUENCE = 1 + } MF_MSE_APPEND_MODE; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0015_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0015_v0_0_s_ifspec; + +#ifndef __IMFSourceBufferAppendMode_INTERFACE_DEFINED__ +#define __IMFSourceBufferAppendMode_INTERFACE_DEFINED__ + +/* interface IMFSourceBufferAppendMode */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFSourceBufferAppendMode; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("19666fb4-babe-4c55-bc03-0a074da37e2a") + IMFSourceBufferAppendMode : public IUnknown + { + public: + virtual MF_MSE_APPEND_MODE STDMETHODCALLTYPE GetAppendMode( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetAppendMode( + /* [annotation][in] */ + _In_ MF_MSE_APPEND_MODE mode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSourceBufferAppendModeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSourceBufferAppendMode * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSourceBufferAppendMode * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSourceBufferAppendMode * This); + + MF_MSE_APPEND_MODE ( STDMETHODCALLTYPE *GetAppendMode )( + IMFSourceBufferAppendMode * This); + + HRESULT ( STDMETHODCALLTYPE *SetAppendMode )( + IMFSourceBufferAppendMode * This, + /* [annotation][in] */ + _In_ MF_MSE_APPEND_MODE mode); + + END_INTERFACE + } IMFSourceBufferAppendModeVtbl; + + interface IMFSourceBufferAppendMode + { + CONST_VTBL struct IMFSourceBufferAppendModeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSourceBufferAppendMode_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSourceBufferAppendMode_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSourceBufferAppendMode_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSourceBufferAppendMode_GetAppendMode(This) \ + ( (This)->lpVtbl -> GetAppendMode(This) ) + +#define IMFSourceBufferAppendMode_SetAppendMode(This,mode) \ + ( (This)->lpVtbl -> SetAppendMode(This,mode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSourceBufferAppendMode_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0016 */ +/* [local] */ + +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0016_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0016_v0_0_s_ifspec; + +#ifndef __IMFSourceBufferList_INTERFACE_DEFINED__ +#define __IMFSourceBufferList_INTERFACE_DEFINED__ + +/* interface IMFSourceBufferList */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFSourceBufferList; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("249981f8-8325-41f3-b80c-3b9e3aad0cbe") + IMFSourceBufferList : public IUnknown + { + public: + virtual DWORD STDMETHODCALLTYPE GetLength( void) = 0; + + virtual IMFSourceBuffer *STDMETHODCALLTYPE GetSourceBuffer( + /* [annotation][in] */ + _In_ DWORD index) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSourceBufferListVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSourceBufferList * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSourceBufferList * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSourceBufferList * This); + + DWORD ( STDMETHODCALLTYPE *GetLength )( + IMFSourceBufferList * This); + + IMFSourceBuffer *( STDMETHODCALLTYPE *GetSourceBuffer )( + IMFSourceBufferList * This, + /* [annotation][in] */ + _In_ DWORD index); + + END_INTERFACE + } IMFSourceBufferListVtbl; + + interface IMFSourceBufferList + { + CONST_VTBL struct IMFSourceBufferListVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSourceBufferList_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSourceBufferList_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSourceBufferList_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSourceBufferList_GetLength(This) \ + ( (This)->lpVtbl -> GetLength(This) ) + +#define IMFSourceBufferList_GetSourceBuffer(This,index) \ + ( (This)->lpVtbl -> GetSourceBuffer(This,index) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSourceBufferList_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0017 */ +/* [local] */ + +typedef +enum MF_MSE_READY + { + MF_MSE_READY_CLOSED = 1, + MF_MSE_READY_OPEN = 2, + MF_MSE_READY_ENDED = 3 + } MF_MSE_READY; + +typedef +enum MF_MSE_ERROR + { + MF_MSE_ERROR_NOERROR = 0, + MF_MSE_ERROR_NETWORK = 1, + MF_MSE_ERROR_DECODE = 2, + MF_MSE_ERROR_UNKNOWN_ERROR = 3 + } MF_MSE_ERROR; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0017_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0017_v0_0_s_ifspec; + +#ifndef __IMFMediaSourceExtension_INTERFACE_DEFINED__ +#define __IMFMediaSourceExtension_INTERFACE_DEFINED__ + +/* interface IMFMediaSourceExtension */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaSourceExtension; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e467b94e-a713-4562-a802-816a42e9008a") + IMFMediaSourceExtension : public IUnknown + { + public: + virtual IMFSourceBufferList *STDMETHODCALLTYPE GetSourceBuffers( void) = 0; + + virtual IMFSourceBufferList *STDMETHODCALLTYPE GetActiveSourceBuffers( void) = 0; + + virtual MF_MSE_READY STDMETHODCALLTYPE GetReadyState( void) = 0; + + virtual double STDMETHODCALLTYPE GetDuration( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDuration( + /* [annotation][in] */ + _In_ double duration) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddSourceBuffer( + /* [annotation][in] */ + _In_ BSTR type, + /* [annotation][in] */ + _In_ IMFSourceBufferNotify *pNotify, + /* [annotation][out] */ + _Outptr_ IMFSourceBuffer **ppSourceBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveSourceBuffer( + /* [annotation][in] */ + _In_ IMFSourceBuffer *pSourceBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetEndOfStream( + /* [annotation][in] */ + _In_ MF_MSE_ERROR error) = 0; + + virtual BOOL STDMETHODCALLTYPE IsTypeSupported( + /* [annotation][in] */ + _In_ BSTR type) = 0; + + virtual IMFSourceBuffer *STDMETHODCALLTYPE GetSourceBuffer( + /* [annotation][in] */ + _In_ DWORD dwStreamIndex) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaSourceExtensionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaSourceExtension * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaSourceExtension * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaSourceExtension * This); + + IMFSourceBufferList *( STDMETHODCALLTYPE *GetSourceBuffers )( + IMFMediaSourceExtension * This); + + IMFSourceBufferList *( STDMETHODCALLTYPE *GetActiveSourceBuffers )( + IMFMediaSourceExtension * This); + + MF_MSE_READY ( STDMETHODCALLTYPE *GetReadyState )( + IMFMediaSourceExtension * This); + + double ( STDMETHODCALLTYPE *GetDuration )( + IMFMediaSourceExtension * This); + + HRESULT ( STDMETHODCALLTYPE *SetDuration )( + IMFMediaSourceExtension * This, + /* [annotation][in] */ + _In_ double duration); + + HRESULT ( STDMETHODCALLTYPE *AddSourceBuffer )( + IMFMediaSourceExtension * This, + /* [annotation][in] */ + _In_ BSTR type, + /* [annotation][in] */ + _In_ IMFSourceBufferNotify *pNotify, + /* [annotation][out] */ + _Outptr_ IMFSourceBuffer **ppSourceBuffer); + + HRESULT ( STDMETHODCALLTYPE *RemoveSourceBuffer )( + IMFMediaSourceExtension * This, + /* [annotation][in] */ + _In_ IMFSourceBuffer *pSourceBuffer); + + HRESULT ( STDMETHODCALLTYPE *SetEndOfStream )( + IMFMediaSourceExtension * This, + /* [annotation][in] */ + _In_ MF_MSE_ERROR error); + + BOOL ( STDMETHODCALLTYPE *IsTypeSupported )( + IMFMediaSourceExtension * This, + /* [annotation][in] */ + _In_ BSTR type); + + IMFSourceBuffer *( STDMETHODCALLTYPE *GetSourceBuffer )( + IMFMediaSourceExtension * This, + /* [annotation][in] */ + _In_ DWORD dwStreamIndex); + + END_INTERFACE + } IMFMediaSourceExtensionVtbl; + + interface IMFMediaSourceExtension + { + CONST_VTBL struct IMFMediaSourceExtensionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaSourceExtension_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaSourceExtension_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaSourceExtension_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaSourceExtension_GetSourceBuffers(This) \ + ( (This)->lpVtbl -> GetSourceBuffers(This) ) + +#define IMFMediaSourceExtension_GetActiveSourceBuffers(This) \ + ( (This)->lpVtbl -> GetActiveSourceBuffers(This) ) + +#define IMFMediaSourceExtension_GetReadyState(This) \ + ( (This)->lpVtbl -> GetReadyState(This) ) + +#define IMFMediaSourceExtension_GetDuration(This) \ + ( (This)->lpVtbl -> GetDuration(This) ) + +#define IMFMediaSourceExtension_SetDuration(This,duration) \ + ( (This)->lpVtbl -> SetDuration(This,duration) ) + +#define IMFMediaSourceExtension_AddSourceBuffer(This,type,pNotify,ppSourceBuffer) \ + ( (This)->lpVtbl -> AddSourceBuffer(This,type,pNotify,ppSourceBuffer) ) + +#define IMFMediaSourceExtension_RemoveSourceBuffer(This,pSourceBuffer) \ + ( (This)->lpVtbl -> RemoveSourceBuffer(This,pSourceBuffer) ) + +#define IMFMediaSourceExtension_SetEndOfStream(This,error) \ + ( (This)->lpVtbl -> SetEndOfStream(This,error) ) + +#define IMFMediaSourceExtension_IsTypeSupported(This,type) \ + ( (This)->lpVtbl -> IsTypeSupported(This,type) ) + +#define IMFMediaSourceExtension_GetSourceBuffer(This,dwStreamIndex) \ + ( (This)->lpVtbl -> GetSourceBuffer(This,dwStreamIndex) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaSourceExtension_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaSourceExtensionLiveSeekableRange_INTERFACE_DEFINED__ +#define __IMFMediaSourceExtensionLiveSeekableRange_INTERFACE_DEFINED__ + +/* interface IMFMediaSourceExtensionLiveSeekableRange */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaSourceExtensionLiveSeekableRange; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5D1ABFD6-450A-4D92-9EFC-D6B6CBC1F4DA") + IMFMediaSourceExtensionLiveSeekableRange : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE SetLiveSeekableRange( + /* [annotation][in] */ + _In_ double start, + /* [annotation][in] */ + _In_ double end) = 0; + + virtual HRESULT STDMETHODCALLTYPE ClearLiveSeekableRange( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaSourceExtensionLiveSeekableRangeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaSourceExtensionLiveSeekableRange * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaSourceExtensionLiveSeekableRange * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaSourceExtensionLiveSeekableRange * This); + + HRESULT ( STDMETHODCALLTYPE *SetLiveSeekableRange )( + IMFMediaSourceExtensionLiveSeekableRange * This, + /* [annotation][in] */ + _In_ double start, + /* [annotation][in] */ + _In_ double end); + + HRESULT ( STDMETHODCALLTYPE *ClearLiveSeekableRange )( + IMFMediaSourceExtensionLiveSeekableRange * This); + + END_INTERFACE + } IMFMediaSourceExtensionLiveSeekableRangeVtbl; + + interface IMFMediaSourceExtensionLiveSeekableRange + { + CONST_VTBL struct IMFMediaSourceExtensionLiveSeekableRangeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaSourceExtensionLiveSeekableRange_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaSourceExtensionLiveSeekableRange_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaSourceExtensionLiveSeekableRange_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaSourceExtensionLiveSeekableRange_SetLiveSeekableRange(This,start,end) \ + ( (This)->lpVtbl -> SetLiveSeekableRange(This,start,end) ) + +#define IMFMediaSourceExtensionLiveSeekableRange_ClearLiveSeekableRange(This) \ + ( (This)->lpVtbl -> ClearLiveSeekableRange(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaSourceExtensionLiveSeekableRange_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0019 */ +/* [local] */ + + + + + + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0019_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0019_v0_0_s_ifspec; + +#ifndef __IMFMediaEngineEME_INTERFACE_DEFINED__ +#define __IMFMediaEngineEME_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineEME */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineEME; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("50dc93e4-ba4f-4275-ae66-83e836e57469") + IMFMediaEngineEME : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE get_Keys( + /* [annotation] */ + _COM_Outptr_result_maybenull_ IMFMediaKeys **keys) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetMediaKeys( + /* [annotation] */ + _In_opt_ IMFMediaKeys *keys) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineEMEVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineEME * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineEME * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineEME * This); + + HRESULT ( STDMETHODCALLTYPE *get_Keys )( + IMFMediaEngineEME * This, + /* [annotation] */ + _COM_Outptr_result_maybenull_ IMFMediaKeys **keys); + + HRESULT ( STDMETHODCALLTYPE *SetMediaKeys )( + IMFMediaEngineEME * This, + /* [annotation] */ + _In_opt_ IMFMediaKeys *keys); + + END_INTERFACE + } IMFMediaEngineEMEVtbl; + + interface IMFMediaEngineEME + { + CONST_VTBL struct IMFMediaEngineEMEVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineEME_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineEME_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineEME_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineEME_get_Keys(This,keys) \ + ( (This)->lpVtbl -> get_Keys(This,keys) ) + +#define IMFMediaEngineEME_SetMediaKeys(This,keys) \ + ( (This)->lpVtbl -> SetMediaKeys(This,keys) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineEME_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaEngineSrcElementsEx_INTERFACE_DEFINED__ +#define __IMFMediaEngineSrcElementsEx_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineSrcElementsEx */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineSrcElementsEx; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("654a6bb3-e1a3-424a-9908-53a43a0dfda0") + IMFMediaEngineSrcElementsEx : public IMFMediaEngineSrcElements + { + public: + virtual HRESULT STDMETHODCALLTYPE AddElementEx( + /* [annotation] */ + _In_opt_ BSTR pURL, + /* [annotation] */ + _In_opt_ BSTR pType, + /* [annotation] */ + _In_opt_ BSTR pMedia, + /* [annotation] */ + _In_opt_ BSTR keySystem) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetKeySystem( + /* [annotation] */ + _In_ DWORD index, + /* [annotation] */ + _Outptr_result_maybenull_ BSTR *pType) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineSrcElementsExVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineSrcElementsEx * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineSrcElementsEx * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineSrcElementsEx * This); + + DWORD ( STDMETHODCALLTYPE *GetLength )( + IMFMediaEngineSrcElementsEx * This); + + HRESULT ( STDMETHODCALLTYPE *GetURL )( + IMFMediaEngineSrcElementsEx * This, + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ BSTR *pURL); + + HRESULT ( STDMETHODCALLTYPE *GetType )( + IMFMediaEngineSrcElementsEx * This, + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ BSTR *pType); + + HRESULT ( STDMETHODCALLTYPE *GetMedia )( + IMFMediaEngineSrcElementsEx * This, + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ BSTR *pMedia); + + HRESULT ( STDMETHODCALLTYPE *AddElement )( + IMFMediaEngineSrcElementsEx * This, + /* [annotation][in] */ + _In_opt_ BSTR pURL, + /* [annotation][in] */ + _In_opt_ BSTR pType, + /* [annotation][in] */ + _In_opt_ BSTR pMedia); + + HRESULT ( STDMETHODCALLTYPE *RemoveAllElements )( + IMFMediaEngineSrcElementsEx * This); + + HRESULT ( STDMETHODCALLTYPE *AddElementEx )( + IMFMediaEngineSrcElementsEx * This, + /* [annotation] */ + _In_opt_ BSTR pURL, + /* [annotation] */ + _In_opt_ BSTR pType, + /* [annotation] */ + _In_opt_ BSTR pMedia, + /* [annotation] */ + _In_opt_ BSTR keySystem); + + HRESULT ( STDMETHODCALLTYPE *GetKeySystem )( + IMFMediaEngineSrcElementsEx * This, + /* [annotation] */ + _In_ DWORD index, + /* [annotation] */ + _Outptr_result_maybenull_ BSTR *pType); + + END_INTERFACE + } IMFMediaEngineSrcElementsExVtbl; + + interface IMFMediaEngineSrcElementsEx + { + CONST_VTBL struct IMFMediaEngineSrcElementsExVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineSrcElementsEx_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineSrcElementsEx_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineSrcElementsEx_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineSrcElementsEx_GetLength(This) \ + ( (This)->lpVtbl -> GetLength(This) ) + +#define IMFMediaEngineSrcElementsEx_GetURL(This,index,pURL) \ + ( (This)->lpVtbl -> GetURL(This,index,pURL) ) + +#define IMFMediaEngineSrcElementsEx_GetType(This,index,pType) \ + ( (This)->lpVtbl -> GetType(This,index,pType) ) + +#define IMFMediaEngineSrcElementsEx_GetMedia(This,index,pMedia) \ + ( (This)->lpVtbl -> GetMedia(This,index,pMedia) ) + +#define IMFMediaEngineSrcElementsEx_AddElement(This,pURL,pType,pMedia) \ + ( (This)->lpVtbl -> AddElement(This,pURL,pType,pMedia) ) + +#define IMFMediaEngineSrcElementsEx_RemoveAllElements(This) \ + ( (This)->lpVtbl -> RemoveAllElements(This) ) + + +#define IMFMediaEngineSrcElementsEx_AddElementEx(This,pURL,pType,pMedia,keySystem) \ + ( (This)->lpVtbl -> AddElementEx(This,pURL,pType,pMedia,keySystem) ) + +#define IMFMediaEngineSrcElementsEx_GetKeySystem(This,index,pType) \ + ( (This)->lpVtbl -> GetKeySystem(This,index,pType) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineSrcElementsEx_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0021 */ +/* [local] */ + +EXTERN_GUID(MF_MEDIA_ENGINE_NEEDKEY_CALLBACK, +0x7ea80843, 0xb6e4, 0x432c, 0x8e, 0xa4, 0x78, 0x48, 0xff, 0xe4, 0x22, 0x0e); + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0021_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0021_v0_0_s_ifspec; + +#ifndef __IMFMediaEngineNeedKeyNotify_INTERFACE_DEFINED__ +#define __IMFMediaEngineNeedKeyNotify_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineNeedKeyNotify */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineNeedKeyNotify; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("46a30204-a696-4b18-8804-246b8f031bb1") + IMFMediaEngineNeedKeyNotify : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE NeedKey( + /* [annotation] */ + _In_reads_bytes_opt_(cb) const BYTE *initData, + /* [annotation] */ + _In_ DWORD cb) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineNeedKeyNotifyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineNeedKeyNotify * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineNeedKeyNotify * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineNeedKeyNotify * This); + + void ( STDMETHODCALLTYPE *NeedKey )( + IMFMediaEngineNeedKeyNotify * This, + /* [annotation] */ + _In_reads_bytes_opt_(cb) const BYTE *initData, + /* [annotation] */ + _In_ DWORD cb); + + END_INTERFACE + } IMFMediaEngineNeedKeyNotifyVtbl; + + interface IMFMediaEngineNeedKeyNotify + { + CONST_VTBL struct IMFMediaEngineNeedKeyNotifyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineNeedKeyNotify_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineNeedKeyNotify_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineNeedKeyNotify_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineNeedKeyNotify_NeedKey(This,initData,cb) \ + ( (This)->lpVtbl -> NeedKey(This,initData,cb) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineNeedKeyNotify_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaKeys_INTERFACE_DEFINED__ +#define __IMFMediaKeys_INTERFACE_DEFINED__ + +/* interface IMFMediaKeys */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaKeys; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5cb31c05-61ff-418f-afda-caaf41421a38") + IMFMediaKeys : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateSession( + /* [annotation] */ + _In_opt_ BSTR mimeType, + /* [annotation] */ + _In_reads_bytes_opt_(cb) const BYTE *initData, + /* [annotation] */ + _In_opt_ DWORD cb, + /* [annotation] */ + _In_reads_bytes_opt_(cbCustomData) const BYTE *customData, + /* [annotation] */ + _In_ DWORD cbCustomData, + /* [annotation] */ + _In_ IMFMediaKeySessionNotify *notify, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeySession **ppSession) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_KeySystem( + /* [annotation] */ + _COM_Outptr_ BSTR *keySystem) = 0; + + virtual HRESULT STDMETHODCALLTYPE Shutdown( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSuspendNotify( + /* [annotation] */ + _COM_Outptr_ IMFCdmSuspendNotify **notify) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaKeysVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaKeys * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaKeys * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaKeys * This); + + HRESULT ( STDMETHODCALLTYPE *CreateSession )( + IMFMediaKeys * This, + /* [annotation] */ + _In_opt_ BSTR mimeType, + /* [annotation] */ + _In_reads_bytes_opt_(cb) const BYTE *initData, + /* [annotation] */ + _In_opt_ DWORD cb, + /* [annotation] */ + _In_reads_bytes_opt_(cbCustomData) const BYTE *customData, + /* [annotation] */ + _In_ DWORD cbCustomData, + /* [annotation] */ + _In_ IMFMediaKeySessionNotify *notify, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeySession **ppSession); + + HRESULT ( STDMETHODCALLTYPE *get_KeySystem )( + IMFMediaKeys * This, + /* [annotation] */ + _COM_Outptr_ BSTR *keySystem); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + IMFMediaKeys * This); + + HRESULT ( STDMETHODCALLTYPE *GetSuspendNotify )( + IMFMediaKeys * This, + /* [annotation] */ + _COM_Outptr_ IMFCdmSuspendNotify **notify); + + END_INTERFACE + } IMFMediaKeysVtbl; + + interface IMFMediaKeys + { + CONST_VTBL struct IMFMediaKeysVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaKeys_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaKeys_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaKeys_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaKeys_CreateSession(This,mimeType,initData,cb,customData,cbCustomData,notify,ppSession) \ + ( (This)->lpVtbl -> CreateSession(This,mimeType,initData,cb,customData,cbCustomData,notify,ppSession) ) + +#define IMFMediaKeys_get_KeySystem(This,keySystem) \ + ( (This)->lpVtbl -> get_KeySystem(This,keySystem) ) + +#define IMFMediaKeys_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + +#define IMFMediaKeys_GetSuspendNotify(This,notify) \ + ( (This)->lpVtbl -> GetSuspendNotify(This,notify) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaKeys_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0023 */ +/* [local] */ + +typedef +enum _MF_MEDIA_ENGINE_KEYERR + { + MF_MEDIAENGINE_KEYERR_UNKNOWN = 1, + MF_MEDIAENGINE_KEYERR_CLIENT = 2, + MF_MEDIAENGINE_KEYERR_SERVICE = 3, + MF_MEDIAENGINE_KEYERR_OUTPUT = 4, + MF_MEDIAENGINE_KEYERR_HARDWARECHANGE = 5, + MF_MEDIAENGINE_KEYERR_DOMAIN = 6 + } MF_MEDIA_ENGINE_KEYERR; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0023_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0023_v0_0_s_ifspec; + +#ifndef __IMFMediaKeySession_INTERFACE_DEFINED__ +#define __IMFMediaKeySession_INTERFACE_DEFINED__ + +/* interface IMFMediaKeySession */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaKeySession; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("24fa67d5-d1d0-4dc5-995c-c0efdc191fb5") + IMFMediaKeySession : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetError( + /* [annotation] */ + _Out_ USHORT *code, + /* [annotation] */ + _Out_ DWORD *systemCode) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_KeySystem( + /* [annotation] */ + _COM_Outptr_ BSTR *keySystem) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_SessionId( + /* [annotation] */ + _COM_Outptr_ BSTR *sessionId) = 0; + + virtual HRESULT STDMETHODCALLTYPE Update( + /* [annotation] */ + _In_reads_bytes_(cb) const BYTE *key, + /* [annotation] */ + _In_ DWORD cb) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaKeySessionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaKeySession * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaKeySession * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaKeySession * This); + + HRESULT ( STDMETHODCALLTYPE *GetError )( + IMFMediaKeySession * This, + /* [annotation] */ + _Out_ USHORT *code, + /* [annotation] */ + _Out_ DWORD *systemCode); + + HRESULT ( STDMETHODCALLTYPE *get_KeySystem )( + IMFMediaKeySession * This, + /* [annotation] */ + _COM_Outptr_ BSTR *keySystem); + + HRESULT ( STDMETHODCALLTYPE *get_SessionId )( + IMFMediaKeySession * This, + /* [annotation] */ + _COM_Outptr_ BSTR *sessionId); + + HRESULT ( STDMETHODCALLTYPE *Update )( + IMFMediaKeySession * This, + /* [annotation] */ + _In_reads_bytes_(cb) const BYTE *key, + /* [annotation] */ + _In_ DWORD cb); + + HRESULT ( STDMETHODCALLTYPE *Close )( + IMFMediaKeySession * This); + + END_INTERFACE + } IMFMediaKeySessionVtbl; + + interface IMFMediaKeySession + { + CONST_VTBL struct IMFMediaKeySessionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaKeySession_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaKeySession_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaKeySession_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaKeySession_GetError(This,code,systemCode) \ + ( (This)->lpVtbl -> GetError(This,code,systemCode) ) + +#define IMFMediaKeySession_get_KeySystem(This,keySystem) \ + ( (This)->lpVtbl -> get_KeySystem(This,keySystem) ) + +#define IMFMediaKeySession_get_SessionId(This,sessionId) \ + ( (This)->lpVtbl -> get_SessionId(This,sessionId) ) + +#define IMFMediaKeySession_Update(This,key,cb) \ + ( (This)->lpVtbl -> Update(This,key,cb) ) + +#define IMFMediaKeySession_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaKeySession_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaKeySessionNotify_INTERFACE_DEFINED__ +#define __IMFMediaKeySessionNotify_INTERFACE_DEFINED__ + +/* interface IMFMediaKeySessionNotify */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaKeySessionNotify; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6a0083f9-8947-4c1d-9ce0-cdee22b23135") + IMFMediaKeySessionNotify : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE KeyMessage( + /* [annotation] */ + _In_opt_ BSTR destinationURL, + /* [annotation] */ + _In_reads_bytes_(cb) const BYTE *message, + /* [annotation] */ + _In_ DWORD cb) = 0; + + virtual void STDMETHODCALLTYPE KeyAdded( void) = 0; + + virtual void STDMETHODCALLTYPE KeyError( + /* [annotation] */ + _In_ USHORT code, + /* [annotation] */ + _In_ DWORD systemCode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaKeySessionNotifyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaKeySessionNotify * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaKeySessionNotify * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaKeySessionNotify * This); + + void ( STDMETHODCALLTYPE *KeyMessage )( + IMFMediaKeySessionNotify * This, + /* [annotation] */ + _In_opt_ BSTR destinationURL, + /* [annotation] */ + _In_reads_bytes_(cb) const BYTE *message, + /* [annotation] */ + _In_ DWORD cb); + + void ( STDMETHODCALLTYPE *KeyAdded )( + IMFMediaKeySessionNotify * This); + + void ( STDMETHODCALLTYPE *KeyError )( + IMFMediaKeySessionNotify * This, + /* [annotation] */ + _In_ USHORT code, + /* [annotation] */ + _In_ DWORD systemCode); + + END_INTERFACE + } IMFMediaKeySessionNotifyVtbl; + + interface IMFMediaKeySessionNotify + { + CONST_VTBL struct IMFMediaKeySessionNotifyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaKeySessionNotify_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaKeySessionNotify_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaKeySessionNotify_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaKeySessionNotify_KeyMessage(This,destinationURL,message,cb) \ + ( (This)->lpVtbl -> KeyMessage(This,destinationURL,message,cb) ) + +#define IMFMediaKeySessionNotify_KeyAdded(This) \ + ( (This)->lpVtbl -> KeyAdded(This) ) + +#define IMFMediaKeySessionNotify_KeyError(This,code,systemCode) \ + ( (This)->lpVtbl -> KeyError(This,code,systemCode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaKeySessionNotify_INTERFACE_DEFINED__ */ + + +#ifndef __IMFCdmSuspendNotify_INTERFACE_DEFINED__ +#define __IMFCdmSuspendNotify_INTERFACE_DEFINED__ + +/* interface IMFCdmSuspendNotify */ +/* [unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFCdmSuspendNotify; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7a5645d2-43bd-47fd-87b7-dcd24cc7d692") + IMFCdmSuspendNotify : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Begin( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE End( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFCdmSuspendNotifyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFCdmSuspendNotify * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFCdmSuspendNotify * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFCdmSuspendNotify * This); + + HRESULT ( STDMETHODCALLTYPE *Begin )( + __RPC__in IMFCdmSuspendNotify * This); + + HRESULT ( STDMETHODCALLTYPE *End )( + __RPC__in IMFCdmSuspendNotify * This); + + END_INTERFACE + } IMFCdmSuspendNotifyVtbl; + + interface IMFCdmSuspendNotify + { + CONST_VTBL struct IMFCdmSuspendNotifyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFCdmSuspendNotify_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFCdmSuspendNotify_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFCdmSuspendNotify_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFCdmSuspendNotify_Begin(This) \ + ( (This)->lpVtbl -> Begin(This) ) + +#define IMFCdmSuspendNotify_End(This) \ + ( (This)->lpVtbl -> End(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFCdmSuspendNotify_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0026 */ +/* [local] */ + +typedef +enum _MF_HDCP_STATUS + { + MF_HDCP_STATUS_ON = 0, + MF_HDCP_STATUS_OFF = 1, + MF_HDCP_STATUS_ON_WITH_TYPE_ENFORCEMENT = 2 + } MF_HDCP_STATUS; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0026_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0026_v0_0_s_ifspec; + +#ifndef __IMFHDCPStatus_INTERFACE_DEFINED__ +#define __IMFHDCPStatus_INTERFACE_DEFINED__ + +/* interface IMFHDCPStatus */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFHDCPStatus; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DE400F54-5BF1-40CF-8964-0BEA136B1E3D") + IMFHDCPStatus : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Query( + /* [annotation][in] */ + _Inout_ MF_HDCP_STATUS *pStatus, + /* [annotation][in] */ + _Inout_ BOOL *pfStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE Set( + /* [annotation][in] */ + _In_ MF_HDCP_STATUS status) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFHDCPStatusVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFHDCPStatus * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFHDCPStatus * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFHDCPStatus * This); + + HRESULT ( STDMETHODCALLTYPE *Query )( + IMFHDCPStatus * This, + /* [annotation][in] */ + _Inout_ MF_HDCP_STATUS *pStatus, + /* [annotation][in] */ + _Inout_ BOOL *pfStatus); + + HRESULT ( STDMETHODCALLTYPE *Set )( + IMFHDCPStatus * This, + /* [annotation][in] */ + _In_ MF_HDCP_STATUS status); + + END_INTERFACE + } IMFHDCPStatusVtbl; + + interface IMFHDCPStatus + { + CONST_VTBL struct IMFHDCPStatusVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFHDCPStatus_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFHDCPStatus_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFHDCPStatus_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFHDCPStatus_Query(This,pStatus,pfStatus) \ + ( (This)->lpVtbl -> Query(This,pStatus,pfStatus) ) + +#define IMFHDCPStatus_Set(This,status) \ + ( (This)->lpVtbl -> Set(This,status) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFHDCPStatus_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0027 */ +/* [local] */ + +typedef +enum MF_MEDIA_ENGINE_OPM_STATUS + { + MF_MEDIA_ENGINE_OPM_NOT_REQUESTED = 0, + MF_MEDIA_ENGINE_OPM_ESTABLISHED = 1, + MF_MEDIA_ENGINE_OPM_FAILED_VM = 2, + MF_MEDIA_ENGINE_OPM_FAILED_BDA = 3, + MF_MEDIA_ENGINE_OPM_FAILED_UNSIGNED_DRIVER = 4, + MF_MEDIA_ENGINE_OPM_FAILED = 5 + } MF_MEDIA_ENGINE_OPM_STATUS; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0027_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0027_v0_0_s_ifspec; + +#ifndef __IMFMediaEngineOPMInfo_INTERFACE_DEFINED__ +#define __IMFMediaEngineOPMInfo_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineOPMInfo */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineOPMInfo; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("765763e6-6c01-4b01-bb0f-b829f60ed28c") + IMFMediaEngineOPMInfo : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetOPMInfo( + /* [annotation][out] */ + _Out_ MF_MEDIA_ENGINE_OPM_STATUS *pStatus, + /* [annotation][out] */ + _Out_ BOOL *pConstricted) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineOPMInfoVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineOPMInfo * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineOPMInfo * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineOPMInfo * This); + + HRESULT ( STDMETHODCALLTYPE *GetOPMInfo )( + IMFMediaEngineOPMInfo * This, + /* [annotation][out] */ + _Out_ MF_MEDIA_ENGINE_OPM_STATUS *pStatus, + /* [annotation][out] */ + _Out_ BOOL *pConstricted); + + END_INTERFACE + } IMFMediaEngineOPMInfoVtbl; + + interface IMFMediaEngineOPMInfo + { + CONST_VTBL struct IMFMediaEngineOPMInfoVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineOPMInfo_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineOPMInfo_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineOPMInfo_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineOPMInfo_GetOPMInfo(This,pStatus,pConstricted) \ + ( (This)->lpVtbl -> GetOPMInfo(This,pStatus,pConstricted) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineOPMInfo_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0028 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#ifndef NO_MEDIA_ENGINE_FACTORY +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_GUID(MF_MEDIA_ENGINE_CALLBACK, +0xc60381b8,0x83a4,0x41f8,0xa3,0xd0,0xde,0x05,0x07,0x68,0x49,0xa9); +EXTERN_GUID(MF_MEDIA_ENGINE_DXGI_MANAGER, +0x065702da,0x1094,0x486d,0x86,0x17,0xee,0x7c,0xc4,0xee,0x46,0x48); +EXTERN_GUID(MF_MEDIA_ENGINE_EXTENSION, +0x3109fd46,0x060d,0x4b62,0x8d,0xcf,0xfa,0xff,0x81,0x13,0x18,0xd2); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +EXTERN_GUID(MF_MEDIA_ENGINE_PLAYBACK_HWND, +0xd988879b,0x67c9,0x4d92,0xba,0xa7,0x6e,0xad,0xd4,0x46,0x03,0x9d); +EXTERN_GUID(MF_MEDIA_ENGINE_OPM_HWND, +0xa0be8ee7, 0x0572, 0x4f2c, 0xa8, 0x01, 0x2a, 0x15, 0x1b, 0xd3, 0xe7, 0x26); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_GUID(MF_MEDIA_ENGINE_PLAYBACK_VISUAL, +0x6debd26f,0x6ab9,0x4d7e,0xb0,0xee,0xc6,0x1a,0x73,0xff,0xad,0x15); +EXTERN_GUID(MF_MEDIA_ENGINE_COREWINDOW, +0xfccae4dc, 0x0b7f, 0x41c2, 0x9f, 0x96, 0x46, 0x59, 0x94, 0x8a, 0xcd, 0xdc); +EXTERN_GUID(MF_MEDIA_ENGINE_VIDEO_OUTPUT_FORMAT, +0x5066893c,0x8cf9,0x42bc,0x8b,0x8a,0x47,0x22,0x12,0xe5,0x27,0x26); +EXTERN_GUID(MF_MEDIA_ENGINE_CONTENT_PROTECTION_FLAGS, +0xe0350223, 0x5aaf, 0x4d76, 0xa7, 0xc3, 0x06, 0xde, 0x70, 0x89, 0x4d, 0xb4); +EXTERN_GUID(MF_MEDIA_ENGINE_CONTENT_PROTECTION_MANAGER, +0xfdd6dfaa, 0xbd85, 0x4af3, 0x9e, 0x0f, 0xa0, 0x1d, 0x53, 0x9d, 0x87, 0x6a); +EXTERN_GUID(MF_MEDIA_ENGINE_AUDIO_ENDPOINT_ROLE, +0xd2cb93d1, 0x116a, 0x44f2, 0x93, 0x85, 0xf7, 0xd0, 0xfd, 0xa2, 0xfb, 0x46); +EXTERN_GUID(MF_MEDIA_ENGINE_AUDIO_CATEGORY, +0xc8d4c51d, 0x350e, 0x41f2, 0xba, 0x46, 0xfa, 0xeb, 0xbb, 0x08, 0x57, 0xf6); +EXTERN_GUID(MF_MEDIA_ENGINE_STREAM_CONTAINS_ALPHA_CHANNEL, +0x5cbfaf44, 0xd2b2, 0x4cfb, 0x80, 0xa7, 0xd4, 0x29, 0xc7, 0x4c, 0x78, 0x9d); +EXTERN_GUID(MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE, +0x4e0212e2, 0xe18f, 0x41e1, 0x95, 0xe5, 0xc0, 0xe7, 0xe9, 0x23, 0x5b, 0xc3); +EXTERN_GUID(MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE9, +0x052c2d39, 0x40c0, 0x4188, 0xab, 0x86, 0xf8, 0x28, 0x27, 0x3b, 0x75, 0x22); +EXTERN_GUID(MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE10, +0x11a47afd, 0x6589, 0x4124, 0xb3, 0x12, 0x61, 0x58, 0xec, 0x51, 0x7f, 0xc3); +EXTERN_GUID(MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE11, +0x1cf1315f, 0xce3f, 0x4035, 0x93, 0x91, 0x16, 0x14, 0x2f, 0x77, 0x51, 0x89); +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +EXTERN_GUID(MF_MEDIA_ENGINE_BROWSER_COMPATIBILITY_MODE_IE_EDGE, +0xa6f3e465, 0x3aca, 0x442c, 0xa3, 0xf0, 0xad, 0x6d, 0xda, 0xd8, 0x39, 0xae); +EXTERN_GUID(MF_MEDIA_ENGINE_COMPATIBILITY_MODE, +0x3ef26ad4, 0xdc54, 0x45de, 0xb9, 0xaf, 0x76, 0xc8, 0xc6, 0x6b, 0xfa, 0x8e); +EXTERN_GUID(MF_MEDIA_ENGINE_COMPATIBILITY_MODE_WWA_EDGE, +0x15b29098, 0x9f01, 0x4e4d, 0xb6, 0x5a, 0xc0, 0x6c, 0x6c, 0x89, 0xda, 0x2a); +EXTERN_GUID(MF_MEDIA_ENGINE_COMPATIBILITY_MODE_WIN10, +0x5b25e089, 0x6ca7, 0x4139, 0xa2, 0xcb, 0xfc, 0xaa, 0xb3, 0x95, 0x52, 0xa3); +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +EXTERN_GUID(MF_MEDIA_ENGINE_SOURCE_RESOLVER_CONFIG_STORE, +0x0ac0c497, 0xb3c4, 0x48c9, 0x9c, 0xde, 0xbb, 0x8c, 0xa2, 0x44, 0x2c, 0xa3); +EXTERN_GUID(MF_MEDIA_ENGINE_TRACK_ID, +0x65bea312, 0x4043, 0x4815, 0x8e, 0xab, 0x44, 0xdc, 0xe2, 0xef, 0x8f, 0x2a); +EXTERN_GUID(MF_MEDIA_ENGINE_TELEMETRY_APPLICATION_ID, +0x1e7b273b, 0xa7e4, 0x402a, 0x8f, 0x51, 0xc4, 0x8e, 0x88, 0xa2, 0xca, 0xbc); +EXTERN_GUID(MF_MEDIA_ENGINE_SYNCHRONOUS_CLOSE, +0xc3c2e12f, 0x7e0e, 0x4e43, 0xb9, 0x1c, 0xdc, 0x99, 0x2c, 0xcd, 0xfa, 0x5e); +EXTERN_GUID(MF_MEDIA_ENGINE_MEDIA_PLAYER_MODE, +0x3ddd8d45, 0x5aa1, 0x4112, 0x82, 0xe5, 0x36, 0xf6, 0xa2, 0x19, 0x7e, 0x6e); +typedef +enum MF_MEDIA_ENGINE_CREATEFLAGS + { + MF_MEDIA_ENGINE_AUDIOONLY = 0x1, + MF_MEDIA_ENGINE_WAITFORSTABLE_STATE = 0x2, + MF_MEDIA_ENGINE_FORCEMUTE = 0x4, + MF_MEDIA_ENGINE_REAL_TIME_MODE = 0x8, + MF_MEDIA_ENGINE_DISABLE_LOCAL_PLUGINS = 0x10, + MF_MEDIA_ENGINE_CREATEFLAGS_MASK = 0x1f + } MF_MEDIA_ENGINE_CREATEFLAGS; + +typedef +enum MF_MEDIA_ENGINE_PROTECTION_FLAGS + { + MF_MEDIA_ENGINE_ENABLE_PROTECTED_CONTENT = 1, + MF_MEDIA_ENGINE_USE_PMP_FOR_ALL_CONTENT = 2, + MF_MEDIA_ENGINE_USE_UNPROTECTED_PMP = 4 + } MF_MEDIA_ENGINE_PROTECTION_FLAGS; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0028_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0028_v0_0_s_ifspec; + +#ifndef __IMFMediaEngineClassFactory_INTERFACE_DEFINED__ +#define __IMFMediaEngineClassFactory_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineClassFactory */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineClassFactory; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("4D645ACE-26AA-4688-9BE1-DF3516990B93") + IMFMediaEngineClassFactory : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateInstance( + /* [annotation][in] */ + _In_ DWORD dwFlags, + /* [annotation][in] */ + _In_ IMFAttributes *pAttr, + /* [annotation][out] */ + _Outptr_ IMFMediaEngine **ppPlayer) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateTimeRange( + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppTimeRange) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateError( + /* [annotation][out] */ + _Outptr_ IMFMediaError **ppError) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineClassFactoryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineClassFactory * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineClassFactory * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineClassFactory * This); + + HRESULT ( STDMETHODCALLTYPE *CreateInstance )( + IMFMediaEngineClassFactory * This, + /* [annotation][in] */ + _In_ DWORD dwFlags, + /* [annotation][in] */ + _In_ IMFAttributes *pAttr, + /* [annotation][out] */ + _Outptr_ IMFMediaEngine **ppPlayer); + + HRESULT ( STDMETHODCALLTYPE *CreateTimeRange )( + IMFMediaEngineClassFactory * This, + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppTimeRange); + + HRESULT ( STDMETHODCALLTYPE *CreateError )( + IMFMediaEngineClassFactory * This, + /* [annotation][out] */ + _Outptr_ IMFMediaError **ppError); + + END_INTERFACE + } IMFMediaEngineClassFactoryVtbl; + + interface IMFMediaEngineClassFactory + { + CONST_VTBL struct IMFMediaEngineClassFactoryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineClassFactory_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineClassFactory_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineClassFactory_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineClassFactory_CreateInstance(This,dwFlags,pAttr,ppPlayer) \ + ( (This)->lpVtbl -> CreateInstance(This,dwFlags,pAttr,ppPlayer) ) + +#define IMFMediaEngineClassFactory_CreateTimeRange(This,ppTimeRange) \ + ( (This)->lpVtbl -> CreateTimeRange(This,ppTimeRange) ) + +#define IMFMediaEngineClassFactory_CreateError(This,ppError) \ + ( (This)->lpVtbl -> CreateError(This,ppError) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineClassFactory_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0029 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0029_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0029_v0_0_s_ifspec; + +#ifndef __IMFMediaEngineClassFactoryEx_INTERFACE_DEFINED__ +#define __IMFMediaEngineClassFactoryEx_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineClassFactoryEx */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineClassFactoryEx; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c56156c6-ea5b-48a5-9df8-fbe035d0929e") + IMFMediaEngineClassFactoryEx : public IMFMediaEngineClassFactory + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateMediaSourceExtension( + /* [annotation][in] */ + _In_ DWORD dwFlags, + /* [annotation][in] */ + _In_ IMFAttributes *pAttr, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaSourceExtension **ppMSE) = 0; + + virtual HRESULT STDMETHODCALLTYPE CreateMediaKeys( + /* [annotation] */ + _In_ BSTR keySystem, + /* [annotation] */ + _In_opt_ BSTR cdmStorePath, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeys **ppKeys) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsTypeSupported( + /* [annotation] */ + _In_opt_ BSTR type, + /* [annotation] */ + _In_ BSTR keySystem, + /* [annotation] */ + _Out_ BOOL *isSupported) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineClassFactoryExVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineClassFactoryEx * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineClassFactoryEx * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineClassFactoryEx * This); + + HRESULT ( STDMETHODCALLTYPE *CreateInstance )( + IMFMediaEngineClassFactoryEx * This, + /* [annotation][in] */ + _In_ DWORD dwFlags, + /* [annotation][in] */ + _In_ IMFAttributes *pAttr, + /* [annotation][out] */ + _Outptr_ IMFMediaEngine **ppPlayer); + + HRESULT ( STDMETHODCALLTYPE *CreateTimeRange )( + IMFMediaEngineClassFactoryEx * This, + /* [annotation][out] */ + _Outptr_ IMFMediaTimeRange **ppTimeRange); + + HRESULT ( STDMETHODCALLTYPE *CreateError )( + IMFMediaEngineClassFactoryEx * This, + /* [annotation][out] */ + _Outptr_ IMFMediaError **ppError); + + HRESULT ( STDMETHODCALLTYPE *CreateMediaSourceExtension )( + IMFMediaEngineClassFactoryEx * This, + /* [annotation][in] */ + _In_ DWORD dwFlags, + /* [annotation][in] */ + _In_ IMFAttributes *pAttr, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaSourceExtension **ppMSE); + + HRESULT ( STDMETHODCALLTYPE *CreateMediaKeys )( + IMFMediaEngineClassFactoryEx * This, + /* [annotation] */ + _In_ BSTR keySystem, + /* [annotation] */ + _In_opt_ BSTR cdmStorePath, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeys **ppKeys); + + HRESULT ( STDMETHODCALLTYPE *IsTypeSupported )( + IMFMediaEngineClassFactoryEx * This, + /* [annotation] */ + _In_opt_ BSTR type, + /* [annotation] */ + _In_ BSTR keySystem, + /* [annotation] */ + _Out_ BOOL *isSupported); + + END_INTERFACE + } IMFMediaEngineClassFactoryExVtbl; + + interface IMFMediaEngineClassFactoryEx + { + CONST_VTBL struct IMFMediaEngineClassFactoryExVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineClassFactoryEx_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineClassFactoryEx_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineClassFactoryEx_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineClassFactoryEx_CreateInstance(This,dwFlags,pAttr,ppPlayer) \ + ( (This)->lpVtbl -> CreateInstance(This,dwFlags,pAttr,ppPlayer) ) + +#define IMFMediaEngineClassFactoryEx_CreateTimeRange(This,ppTimeRange) \ + ( (This)->lpVtbl -> CreateTimeRange(This,ppTimeRange) ) + +#define IMFMediaEngineClassFactoryEx_CreateError(This,ppError) \ + ( (This)->lpVtbl -> CreateError(This,ppError) ) + + +#define IMFMediaEngineClassFactoryEx_CreateMediaSourceExtension(This,dwFlags,pAttr,ppMSE) \ + ( (This)->lpVtbl -> CreateMediaSourceExtension(This,dwFlags,pAttr,ppMSE) ) + +#define IMFMediaEngineClassFactoryEx_CreateMediaKeys(This,keySystem,cdmStorePath,ppKeys) \ + ( (This)->lpVtbl -> CreateMediaKeys(This,keySystem,cdmStorePath,ppKeys) ) + +#define IMFMediaEngineClassFactoryEx_IsTypeSupported(This,type,keySystem,isSupported) \ + ( (This)->lpVtbl -> IsTypeSupported(This,type,keySystem,isSupported) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineClassFactoryEx_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaEngineClassFactory2_INTERFACE_DEFINED__ +#define __IMFMediaEngineClassFactory2_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineClassFactory2 */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineClassFactory2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("09083cef-867f-4bf6-8776-dee3a7b42fca") + IMFMediaEngineClassFactory2 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateMediaKeys2( + /* [annotation] */ + _In_ BSTR keySystem, + /* [annotation] */ + _In_ BSTR defaultCdmStorePath, + /* [annotation] */ + _In_opt_ BSTR inprivateCdmStorePath, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeys **ppKeys) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineClassFactory2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineClassFactory2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineClassFactory2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineClassFactory2 * This); + + HRESULT ( STDMETHODCALLTYPE *CreateMediaKeys2 )( + IMFMediaEngineClassFactory2 * This, + /* [annotation] */ + _In_ BSTR keySystem, + /* [annotation] */ + _In_ BSTR defaultCdmStorePath, + /* [annotation] */ + _In_opt_ BSTR inprivateCdmStorePath, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeys **ppKeys); + + END_INTERFACE + } IMFMediaEngineClassFactory2Vtbl; + + interface IMFMediaEngineClassFactory2 + { + CONST_VTBL struct IMFMediaEngineClassFactory2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineClassFactory2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineClassFactory2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineClassFactory2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineClassFactory2_CreateMediaKeys2(This,keySystem,defaultCdmStorePath,inprivateCdmStorePath,ppKeys) \ + ( (This)->lpVtbl -> CreateMediaKeys2(This,keySystem,defaultCdmStorePath,inprivateCdmStorePath,ppKeys) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineClassFactory2_INTERFACE_DEFINED__ */ + + +#ifndef __IMFExtendedDRMTypeSupport_INTERFACE_DEFINED__ +#define __IMFExtendedDRMTypeSupport_INTERFACE_DEFINED__ + +/* interface IMFExtendedDRMTypeSupport */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFExtendedDRMTypeSupport; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("332EC562-3758-468D-A784-E38F23552128") + IMFExtendedDRMTypeSupport : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE IsTypeSupportedEx( + /* [annotation] */ + _In_opt_ BSTR type, + /* [annotation] */ + _In_ BSTR keySystem, + /* [annotation] */ + _Out_ MF_MEDIA_ENGINE_CANPLAY *pAnswer) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFExtendedDRMTypeSupportVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFExtendedDRMTypeSupport * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFExtendedDRMTypeSupport * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFExtendedDRMTypeSupport * This); + + HRESULT ( STDMETHODCALLTYPE *IsTypeSupportedEx )( + IMFExtendedDRMTypeSupport * This, + /* [annotation] */ + _In_opt_ BSTR type, + /* [annotation] */ + _In_ BSTR keySystem, + /* [annotation] */ + _Out_ MF_MEDIA_ENGINE_CANPLAY *pAnswer); + + END_INTERFACE + } IMFExtendedDRMTypeSupportVtbl; + + interface IMFExtendedDRMTypeSupport + { + CONST_VTBL struct IMFExtendedDRMTypeSupportVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFExtendedDRMTypeSupport_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFExtendedDRMTypeSupport_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFExtendedDRMTypeSupport_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFExtendedDRMTypeSupport_IsTypeSupportedEx(This,type,keySystem,pAnswer) \ + ( (This)->lpVtbl -> IsTypeSupportedEx(This,type,keySystem,pAnswer) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFExtendedDRMTypeSupport_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaEngineSupportsSourceTransfer_INTERFACE_DEFINED__ +#define __IMFMediaEngineSupportsSourceTransfer_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineSupportsSourceTransfer */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineSupportsSourceTransfer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("a724b056-1b2e-4642-a6f3-db9420c52908") + IMFMediaEngineSupportsSourceTransfer : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE ShouldTransferSource( + /* [annotation][out] */ + _Out_ BOOL *pfShouldTransfer) = 0; + + virtual HRESULT STDMETHODCALLTYPE DetachMediaSource( + /* [annotation][out] */ + _COM_Outptr_ IMFByteStream **ppByteStream, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaSource **ppMediaSource, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaSourceExtension **ppMSE) = 0; + + virtual HRESULT STDMETHODCALLTYPE AttachMediaSource( + /* [annotation][in] */ + _In_opt_ IMFByteStream *pByteStream, + /* [annotation][in] */ + _In_ IMFMediaSource *pMediaSource, + /* [annotation][in] */ + _In_opt_ IMFMediaSourceExtension *pMSE) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineSupportsSourceTransferVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineSupportsSourceTransfer * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineSupportsSourceTransfer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineSupportsSourceTransfer * This); + + HRESULT ( STDMETHODCALLTYPE *ShouldTransferSource )( + IMFMediaEngineSupportsSourceTransfer * This, + /* [annotation][out] */ + _Out_ BOOL *pfShouldTransfer); + + HRESULT ( STDMETHODCALLTYPE *DetachMediaSource )( + IMFMediaEngineSupportsSourceTransfer * This, + /* [annotation][out] */ + _COM_Outptr_ IMFByteStream **ppByteStream, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaSource **ppMediaSource, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaSourceExtension **ppMSE); + + HRESULT ( STDMETHODCALLTYPE *AttachMediaSource )( + IMFMediaEngineSupportsSourceTransfer * This, + /* [annotation][in] */ + _In_opt_ IMFByteStream *pByteStream, + /* [annotation][in] */ + _In_ IMFMediaSource *pMediaSource, + /* [annotation][in] */ + _In_opt_ IMFMediaSourceExtension *pMSE); + + END_INTERFACE + } IMFMediaEngineSupportsSourceTransferVtbl; + + interface IMFMediaEngineSupportsSourceTransfer + { + CONST_VTBL struct IMFMediaEngineSupportsSourceTransferVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineSupportsSourceTransfer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineSupportsSourceTransfer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineSupportsSourceTransfer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineSupportsSourceTransfer_ShouldTransferSource(This,pfShouldTransfer) \ + ( (This)->lpVtbl -> ShouldTransferSource(This,pfShouldTransfer) ) + +#define IMFMediaEngineSupportsSourceTransfer_DetachMediaSource(This,ppByteStream,ppMediaSource,ppMSE) \ + ( (This)->lpVtbl -> DetachMediaSource(This,ppByteStream,ppMediaSource,ppMSE) ) + +#define IMFMediaEngineSupportsSourceTransfer_AttachMediaSource(This,pByteStream,pMediaSource,pMSE) \ + ( (This)->lpVtbl -> AttachMediaSource(This,pByteStream,pMediaSource,pMSE) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineSupportsSourceTransfer_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0033 */ +/* [local] */ + +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0033_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0033_v0_0_s_ifspec; + +#ifndef __IMFMediaEngineTransferSource_INTERFACE_DEFINED__ +#define __IMFMediaEngineTransferSource_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineTransferSource */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineTransferSource; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("24230452-fe54-40cc-94f3-fcc394c340d6") + IMFMediaEngineTransferSource : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE TransferSourceToMediaEngine( + /* [annotation][in] */ + _In_ IMFMediaEngine *destination) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineTransferSourceVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineTransferSource * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineTransferSource * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineTransferSource * This); + + HRESULT ( STDMETHODCALLTYPE *TransferSourceToMediaEngine )( + IMFMediaEngineTransferSource * This, + /* [annotation][in] */ + _In_ IMFMediaEngine *destination); + + END_INTERFACE + } IMFMediaEngineTransferSourceVtbl; + + interface IMFMediaEngineTransferSource + { + CONST_VTBL struct IMFMediaEngineTransferSourceVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineTransferSource_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineTransferSource_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineTransferSource_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineTransferSource_TransferSourceToMediaEngine(This,destination) \ + ( (This)->lpVtbl -> TransferSourceToMediaEngine(This,destination) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineTransferSource_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0034 */ +/* [local] */ + +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_GUID(CLSID_MFMediaEngineClassFactory, +0xb44392da, 0x499b, 0x446b, 0xa4, 0xcb, 0x0, 0x5f, 0xea, 0xd0, 0xe6, 0xd5); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#endif // (NO_MEDIA_ENGINE_FACTORY) +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +EXTERN_GUID( MF_MEDIA_ENGINE_TIMEDTEXT, 0x805ea411, 0x92e0, 0x4e59, 0x9b, 0x6e, 0x5c, 0x7d, 0x79, 0x15, 0xe6, 0x4f); +typedef +enum MF_TIMED_TEXT_TRACK_KIND + { + MF_TIMED_TEXT_TRACK_KIND_UNKNOWN = 0, + MF_TIMED_TEXT_TRACK_KIND_SUBTITLES = 1, + MF_TIMED_TEXT_TRACK_KIND_CAPTIONS = 2, + MF_TIMED_TEXT_TRACK_KIND_METADATA = 3 + } MF_TIMED_TEXT_TRACK_KIND; + +typedef +enum MF_TIMED_TEXT_UNIT_TYPE + { + MF_TIMED_TEXT_UNIT_TYPE_PIXELS = 0, + MF_TIMED_TEXT_UNIT_TYPE_PERCENTAGE = 1 + } MF_TIMED_TEXT_UNIT_TYPE; + +typedef +enum MF_TIMED_TEXT_FONT_STYLE + { + MF_TIMED_TEXT_FONT_STYLE_NORMAL = 0, + MF_TIMED_TEXT_FONT_STYLE_OBLIQUE = 1, + MF_TIMED_TEXT_FONT_STYLE_ITALIC = 2 + } MF_TIMED_TEXT_FONT_STYLE; + +typedef +enum MF_TIMED_TEXT_ALIGNMENT + { + MF_TIMED_TEXT_ALIGNMENT_START = 0, + MF_TIMED_TEXT_ALIGNMENT_END = 1, + MF_TIMED_TEXT_ALIGNMENT_CENTER = 2 + } MF_TIMED_TEXT_ALIGNMENT; + +typedef +enum MF_TIMED_TEXT_DISPLAY_ALIGNMENT + { + MF_TIMED_TEXT_DISPLAY_ALIGNMENT_BEFORE = 0, + MF_TIMED_TEXT_DISPLAY_ALIGNMENT_AFTER = 1, + MF_TIMED_TEXT_DISPLAY_ALIGNMENT_CENTER = 2 + } MF_TIMED_TEXT_DISPLAY_ALIGNMENT; + +typedef +enum MF_TIMED_TEXT_DECORATION + { + MF_TIMED_TEXT_DECORATION_NONE = 0, + MF_TIMED_TEXT_DECORATION_UNDERLINE = 1, + MF_TIMED_TEXT_DECORATION_LINE_THROUGH = 2, + MF_TIMED_TEXT_DECORATION_OVERLINE = 4 + } MF_TIMED_TEXT_DECORATION; + +typedef +enum MF_TIMED_TEXT_WRITING_MODE + { + MF_TIMED_TEXT_WRITING_MODE_LRTB = 0, + MF_TIMED_TEXT_WRITING_MODE_RLTB = 1, + MF_TIMED_TEXT_WRITING_MODE_TBRL = 2, + MF_TIMED_TEXT_WRITING_MODE_TBLR = 3, + MF_TIMED_TEXT_WRITING_MODE_LR = 4, + MF_TIMED_TEXT_WRITING_MODE_RL = 5, + MF_TIMED_TEXT_WRITING_MODE_TB = 6 + } MF_TIMED_TEXT_WRITING_MODE; + +typedef +enum MF_TIMED_TEXT_SCROLL_MODE + { + MF_TIMED_TEXT_SCROLL_MODE_POP_ON = 0, + MF_TIMED_TEXT_SCROLL_MODE_ROLL_UP = 1 + } MF_TIMED_TEXT_SCROLL_MODE; + +typedef +enum MF_TIMED_TEXT_ERROR_CODE + { + MF_TIMED_TEXT_ERROR_CODE_NOERROR = 0, + MF_TIMED_TEXT_ERROR_CODE_FATAL = 1, + MF_TIMED_TEXT_ERROR_CODE_DATA_FORMAT = 2, + MF_TIMED_TEXT_ERROR_CODE_NETWORK = 3, + MF_TIMED_TEXT_ERROR_CODE_INTERNAL = 4 + } MF_TIMED_TEXT_ERROR_CODE; + +typedef +enum MF_TIMED_TEXT_CUE_EVENT + { + MF_TIMED_TEXT_CUE_EVENT_ACTIVE = 0, + MF_TIMED_TEXT_CUE_EVENT_INACTIVE = ( MF_TIMED_TEXT_CUE_EVENT_ACTIVE + 1 ) , + MF_TIMED_TEXT_CUE_EVENT_CLEAR = ( MF_TIMED_TEXT_CUE_EVENT_INACTIVE + 1 ) + } MF_TIMED_TEXT_CUE_EVENT; + +typedef +enum MF_TIMED_TEXT_TRACK_READY_STATE + { + MF_TIMED_TEXT_TRACK_READY_STATE_NONE = 0, + MF_TIMED_TEXT_TRACK_READY_STATE_LOADING = ( MF_TIMED_TEXT_TRACK_READY_STATE_NONE + 1 ) , + MF_TIMED_TEXT_TRACK_READY_STATE_LOADED = ( MF_TIMED_TEXT_TRACK_READY_STATE_LOADING + 1 ) , + MF_TIMED_TEXT_TRACK_READY_STATE_ERROR = ( MF_TIMED_TEXT_TRACK_READY_STATE_LOADED + 1 ) + } MF_TIMED_TEXT_TRACK_READY_STATE; + + + + + + + + + + + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0034_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0034_v0_0_s_ifspec; + +#ifndef __IMFTimedText_INTERFACE_DEFINED__ +#define __IMFTimedText_INTERFACE_DEFINED__ + +/* interface IMFTimedText */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFTimedText; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("1f2a94c9-a3df-430d-9d0f-acd85ddc29af") + IMFTimedText : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE RegisterNotifications( + /* [annotation][in] */ + _In_opt_ IMFTimedTextNotify *notify) = 0; + + virtual HRESULT STDMETHODCALLTYPE SelectTrack( + /* [annotation][in] */ + _In_ DWORD trackId, + /* [annotation][in] */ + _In_ BOOL selected) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddDataSource( + /* [annotation][in] */ + _In_ IMFByteStream *byteStream, + /* [annotation][in] */ + _In_opt_ LPCWSTR label, + /* [annotation][in] */ + _In_opt_ LPCWSTR language, + /* [annotation][in] */ + _In_ MF_TIMED_TEXT_TRACK_KIND kind, + /* [annotation][in] */ + _In_ BOOL isDefault, + /* [annotation][in] */ + _Out_ DWORD *trackId) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddDataSourceFromUrl( + /* [annotation][in] */ + _In_ LPCWSTR url, + /* [annotation][in] */ + _In_opt_ LPCWSTR label, + /* [annotation][in] */ + _In_opt_ LPCWSTR language, + /* [annotation][in] */ + _In_ MF_TIMED_TEXT_TRACK_KIND kind, + /* [annotation][in] */ + _In_ BOOL isDefault, + /* [annotation][in] */ + _Out_ DWORD *trackId) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddTrack( + /* [annotation][in] */ + _In_opt_ LPCWSTR label, + /* [annotation][in] */ + _In_opt_ LPCWSTR language, + /* [annotation][in] */ + _In_ MF_TIMED_TEXT_TRACK_KIND kind, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrack **track) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveTrack( + /* [annotation][in] */ + _In_ IMFTimedTextTrack *track) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCueTimeOffset( + /* [annotation][out] */ + _Out_ double *offset) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCueTimeOffset( + /* [annotation][in] */ + _In_ double offset) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTracks( + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrackList **tracks) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetActiveTracks( + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrackList **activeTracks) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTextTracks( + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrackList **textTracks) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMetadataTracks( + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrackList **metadataTracks) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInBandEnabled( + /* [annotation][in] */ + _In_ BOOL enabled) = 0; + + virtual BOOL STDMETHODCALLTYPE IsInBandEnabled( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTimedTextVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTimedText * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTimedText * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTimedText * This); + + HRESULT ( STDMETHODCALLTYPE *RegisterNotifications )( + IMFTimedText * This, + /* [annotation][in] */ + _In_opt_ IMFTimedTextNotify *notify); + + HRESULT ( STDMETHODCALLTYPE *SelectTrack )( + IMFTimedText * This, + /* [annotation][in] */ + _In_ DWORD trackId, + /* [annotation][in] */ + _In_ BOOL selected); + + HRESULT ( STDMETHODCALLTYPE *AddDataSource )( + IMFTimedText * This, + /* [annotation][in] */ + _In_ IMFByteStream *byteStream, + /* [annotation][in] */ + _In_opt_ LPCWSTR label, + /* [annotation][in] */ + _In_opt_ LPCWSTR language, + /* [annotation][in] */ + _In_ MF_TIMED_TEXT_TRACK_KIND kind, + /* [annotation][in] */ + _In_ BOOL isDefault, + /* [annotation][in] */ + _Out_ DWORD *trackId); + + HRESULT ( STDMETHODCALLTYPE *AddDataSourceFromUrl )( + IMFTimedText * This, + /* [annotation][in] */ + _In_ LPCWSTR url, + /* [annotation][in] */ + _In_opt_ LPCWSTR label, + /* [annotation][in] */ + _In_opt_ LPCWSTR language, + /* [annotation][in] */ + _In_ MF_TIMED_TEXT_TRACK_KIND kind, + /* [annotation][in] */ + _In_ BOOL isDefault, + /* [annotation][in] */ + _Out_ DWORD *trackId); + + HRESULT ( STDMETHODCALLTYPE *AddTrack )( + IMFTimedText * This, + /* [annotation][in] */ + _In_opt_ LPCWSTR label, + /* [annotation][in] */ + _In_opt_ LPCWSTR language, + /* [annotation][in] */ + _In_ MF_TIMED_TEXT_TRACK_KIND kind, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrack **track); + + HRESULT ( STDMETHODCALLTYPE *RemoveTrack )( + IMFTimedText * This, + /* [annotation][in] */ + _In_ IMFTimedTextTrack *track); + + HRESULT ( STDMETHODCALLTYPE *GetCueTimeOffset )( + IMFTimedText * This, + /* [annotation][out] */ + _Out_ double *offset); + + HRESULT ( STDMETHODCALLTYPE *SetCueTimeOffset )( + IMFTimedText * This, + /* [annotation][in] */ + _In_ double offset); + + HRESULT ( STDMETHODCALLTYPE *GetTracks )( + IMFTimedText * This, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrackList **tracks); + + HRESULT ( STDMETHODCALLTYPE *GetActiveTracks )( + IMFTimedText * This, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrackList **activeTracks); + + HRESULT ( STDMETHODCALLTYPE *GetTextTracks )( + IMFTimedText * This, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrackList **textTracks); + + HRESULT ( STDMETHODCALLTYPE *GetMetadataTracks )( + IMFTimedText * This, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrackList **metadataTracks); + + HRESULT ( STDMETHODCALLTYPE *SetInBandEnabled )( + IMFTimedText * This, + /* [annotation][in] */ + _In_ BOOL enabled); + + BOOL ( STDMETHODCALLTYPE *IsInBandEnabled )( + IMFTimedText * This); + + END_INTERFACE + } IMFTimedTextVtbl; + + interface IMFTimedText + { + CONST_VTBL struct IMFTimedTextVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTimedText_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTimedText_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTimedText_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTimedText_RegisterNotifications(This,notify) \ + ( (This)->lpVtbl -> RegisterNotifications(This,notify) ) + +#define IMFTimedText_SelectTrack(This,trackId,selected) \ + ( (This)->lpVtbl -> SelectTrack(This,trackId,selected) ) + +#define IMFTimedText_AddDataSource(This,byteStream,label,language,kind,isDefault,trackId) \ + ( (This)->lpVtbl -> AddDataSource(This,byteStream,label,language,kind,isDefault,trackId) ) + +#define IMFTimedText_AddDataSourceFromUrl(This,url,label,language,kind,isDefault,trackId) \ + ( (This)->lpVtbl -> AddDataSourceFromUrl(This,url,label,language,kind,isDefault,trackId) ) + +#define IMFTimedText_AddTrack(This,label,language,kind,track) \ + ( (This)->lpVtbl -> AddTrack(This,label,language,kind,track) ) + +#define IMFTimedText_RemoveTrack(This,track) \ + ( (This)->lpVtbl -> RemoveTrack(This,track) ) + +#define IMFTimedText_GetCueTimeOffset(This,offset) \ + ( (This)->lpVtbl -> GetCueTimeOffset(This,offset) ) + +#define IMFTimedText_SetCueTimeOffset(This,offset) \ + ( (This)->lpVtbl -> SetCueTimeOffset(This,offset) ) + +#define IMFTimedText_GetTracks(This,tracks) \ + ( (This)->lpVtbl -> GetTracks(This,tracks) ) + +#define IMFTimedText_GetActiveTracks(This,activeTracks) \ + ( (This)->lpVtbl -> GetActiveTracks(This,activeTracks) ) + +#define IMFTimedText_GetTextTracks(This,textTracks) \ + ( (This)->lpVtbl -> GetTextTracks(This,textTracks) ) + +#define IMFTimedText_GetMetadataTracks(This,metadataTracks) \ + ( (This)->lpVtbl -> GetMetadataTracks(This,metadataTracks) ) + +#define IMFTimedText_SetInBandEnabled(This,enabled) \ + ( (This)->lpVtbl -> SetInBandEnabled(This,enabled) ) + +#define IMFTimedText_IsInBandEnabled(This) \ + ( (This)->lpVtbl -> IsInBandEnabled(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTimedText_INTERFACE_DEFINED__ */ + + +#ifndef __IMFTimedTextNotify_INTERFACE_DEFINED__ +#define __IMFTimedTextNotify_INTERFACE_DEFINED__ + +/* interface IMFTimedTextNotify */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFTimedTextNotify; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("df6b87b6-ce12-45db-aba7-432fe054e57d") + IMFTimedTextNotify : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE TrackAdded( + /* [annotation][in] */ + _In_ DWORD trackId) = 0; + + virtual void STDMETHODCALLTYPE TrackRemoved( + /* [annotation][in] */ + _In_ DWORD trackId) = 0; + + virtual void STDMETHODCALLTYPE TrackSelected( + /* [annotation][in] */ + _In_ DWORD trackId, + /* [annotation][in] */ + _In_ BOOL selected) = 0; + + virtual void STDMETHODCALLTYPE TrackReadyStateChanged( + /* [annotation][in] */ + _In_ DWORD trackId) = 0; + + virtual void STDMETHODCALLTYPE Error( + /* [annotation][in] */ + _In_ MF_TIMED_TEXT_ERROR_CODE errorCode, + /* [annotation][in] */ + _In_ HRESULT extendedErrorCode, + /* [annotation][in] */ + _In_ DWORD sourceTrackId) = 0; + + virtual void STDMETHODCALLTYPE Cue( + /* [annotation][in] */ + _In_ MF_TIMED_TEXT_CUE_EVENT cueEvent, + /* [annotation][in] */ + _In_ double currentTime, + /* [annotation][in] */ + _In_opt_ IMFTimedTextCue *cue) = 0; + + virtual void STDMETHODCALLTYPE Reset( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTimedTextNotifyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTimedTextNotify * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTimedTextNotify * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTimedTextNotify * This); + + void ( STDMETHODCALLTYPE *TrackAdded )( + IMFTimedTextNotify * This, + /* [annotation][in] */ + _In_ DWORD trackId); + + void ( STDMETHODCALLTYPE *TrackRemoved )( + IMFTimedTextNotify * This, + /* [annotation][in] */ + _In_ DWORD trackId); + + void ( STDMETHODCALLTYPE *TrackSelected )( + IMFTimedTextNotify * This, + /* [annotation][in] */ + _In_ DWORD trackId, + /* [annotation][in] */ + _In_ BOOL selected); + + void ( STDMETHODCALLTYPE *TrackReadyStateChanged )( + IMFTimedTextNotify * This, + /* [annotation][in] */ + _In_ DWORD trackId); + + void ( STDMETHODCALLTYPE *Error )( + IMFTimedTextNotify * This, + /* [annotation][in] */ + _In_ MF_TIMED_TEXT_ERROR_CODE errorCode, + /* [annotation][in] */ + _In_ HRESULT extendedErrorCode, + /* [annotation][in] */ + _In_ DWORD sourceTrackId); + + void ( STDMETHODCALLTYPE *Cue )( + IMFTimedTextNotify * This, + /* [annotation][in] */ + _In_ MF_TIMED_TEXT_CUE_EVENT cueEvent, + /* [annotation][in] */ + _In_ double currentTime, + /* [annotation][in] */ + _In_opt_ IMFTimedTextCue *cue); + + void ( STDMETHODCALLTYPE *Reset )( + IMFTimedTextNotify * This); + + END_INTERFACE + } IMFTimedTextNotifyVtbl; + + interface IMFTimedTextNotify + { + CONST_VTBL struct IMFTimedTextNotifyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTimedTextNotify_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTimedTextNotify_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTimedTextNotify_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTimedTextNotify_TrackAdded(This,trackId) \ + ( (This)->lpVtbl -> TrackAdded(This,trackId) ) + +#define IMFTimedTextNotify_TrackRemoved(This,trackId) \ + ( (This)->lpVtbl -> TrackRemoved(This,trackId) ) + +#define IMFTimedTextNotify_TrackSelected(This,trackId,selected) \ + ( (This)->lpVtbl -> TrackSelected(This,trackId,selected) ) + +#define IMFTimedTextNotify_TrackReadyStateChanged(This,trackId) \ + ( (This)->lpVtbl -> TrackReadyStateChanged(This,trackId) ) + +#define IMFTimedTextNotify_Error(This,errorCode,extendedErrorCode,sourceTrackId) \ + ( (This)->lpVtbl -> Error(This,errorCode,extendedErrorCode,sourceTrackId) ) + +#define IMFTimedTextNotify_Cue(This,cueEvent,currentTime,cue) \ + ( (This)->lpVtbl -> Cue(This,cueEvent,currentTime,cue) ) + +#define IMFTimedTextNotify_Reset(This) \ + ( (This)->lpVtbl -> Reset(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTimedTextNotify_INTERFACE_DEFINED__ */ + + +#ifndef __IMFTimedTextTrack_INTERFACE_DEFINED__ +#define __IMFTimedTextTrack_INTERFACE_DEFINED__ + +/* interface IMFTimedTextTrack */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFTimedTextTrack; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8822c32d-654e-4233-bf21-d7f2e67d30d4") + IMFTimedTextTrack : public IUnknown + { + public: + virtual DWORD STDMETHODCALLTYPE GetId( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetLabel( + /* [annotation][out] */ + _Outptr_ LPWSTR *label) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetLabel( + /* [annotation][in] */ + _In_ LPCWSTR label) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetLanguage( + /* [annotation][out] */ + _Outptr_ LPWSTR *language) = 0; + + virtual MF_TIMED_TEXT_TRACK_KIND STDMETHODCALLTYPE GetTrackKind( void) = 0; + + virtual BOOL STDMETHODCALLTYPE IsInBand( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInBandMetadataTrackDispatchType( + /* [annotation][out] */ + _Outptr_ LPWSTR *dispatchType) = 0; + + virtual BOOL STDMETHODCALLTYPE IsActive( void) = 0; + + virtual MF_TIMED_TEXT_ERROR_CODE STDMETHODCALLTYPE GetErrorCode( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetExtendedErrorCode( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDataFormat( + /* [annotation][out] */ + _Out_ GUID *format) = 0; + + virtual MF_TIMED_TEXT_TRACK_READY_STATE STDMETHODCALLTYPE GetReadyState( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCueList( + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextCueList **cues) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTimedTextTrackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTimedTextTrack * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTimedTextTrack * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTimedTextTrack * This); + + DWORD ( STDMETHODCALLTYPE *GetId )( + IMFTimedTextTrack * This); + + HRESULT ( STDMETHODCALLTYPE *GetLabel )( + IMFTimedTextTrack * This, + /* [annotation][out] */ + _Outptr_ LPWSTR *label); + + HRESULT ( STDMETHODCALLTYPE *SetLabel )( + IMFTimedTextTrack * This, + /* [annotation][in] */ + _In_ LPCWSTR label); + + HRESULT ( STDMETHODCALLTYPE *GetLanguage )( + IMFTimedTextTrack * This, + /* [annotation][out] */ + _Outptr_ LPWSTR *language); + + MF_TIMED_TEXT_TRACK_KIND ( STDMETHODCALLTYPE *GetTrackKind )( + IMFTimedTextTrack * This); + + BOOL ( STDMETHODCALLTYPE *IsInBand )( + IMFTimedTextTrack * This); + + HRESULT ( STDMETHODCALLTYPE *GetInBandMetadataTrackDispatchType )( + IMFTimedTextTrack * This, + /* [annotation][out] */ + _Outptr_ LPWSTR *dispatchType); + + BOOL ( STDMETHODCALLTYPE *IsActive )( + IMFTimedTextTrack * This); + + MF_TIMED_TEXT_ERROR_CODE ( STDMETHODCALLTYPE *GetErrorCode )( + IMFTimedTextTrack * This); + + HRESULT ( STDMETHODCALLTYPE *GetExtendedErrorCode )( + IMFTimedTextTrack * This); + + HRESULT ( STDMETHODCALLTYPE *GetDataFormat )( + IMFTimedTextTrack * This, + /* [annotation][out] */ + _Out_ GUID *format); + + MF_TIMED_TEXT_TRACK_READY_STATE ( STDMETHODCALLTYPE *GetReadyState )( + IMFTimedTextTrack * This); + + HRESULT ( STDMETHODCALLTYPE *GetCueList )( + IMFTimedTextTrack * This, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextCueList **cues); + + END_INTERFACE + } IMFTimedTextTrackVtbl; + + interface IMFTimedTextTrack + { + CONST_VTBL struct IMFTimedTextTrackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTimedTextTrack_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTimedTextTrack_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTimedTextTrack_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTimedTextTrack_GetId(This) \ + ( (This)->lpVtbl -> GetId(This) ) + +#define IMFTimedTextTrack_GetLabel(This,label) \ + ( (This)->lpVtbl -> GetLabel(This,label) ) + +#define IMFTimedTextTrack_SetLabel(This,label) \ + ( (This)->lpVtbl -> SetLabel(This,label) ) + +#define IMFTimedTextTrack_GetLanguage(This,language) \ + ( (This)->lpVtbl -> GetLanguage(This,language) ) + +#define IMFTimedTextTrack_GetTrackKind(This) \ + ( (This)->lpVtbl -> GetTrackKind(This) ) + +#define IMFTimedTextTrack_IsInBand(This) \ + ( (This)->lpVtbl -> IsInBand(This) ) + +#define IMFTimedTextTrack_GetInBandMetadataTrackDispatchType(This,dispatchType) \ + ( (This)->lpVtbl -> GetInBandMetadataTrackDispatchType(This,dispatchType) ) + +#define IMFTimedTextTrack_IsActive(This) \ + ( (This)->lpVtbl -> IsActive(This) ) + +#define IMFTimedTextTrack_GetErrorCode(This) \ + ( (This)->lpVtbl -> GetErrorCode(This) ) + +#define IMFTimedTextTrack_GetExtendedErrorCode(This) \ + ( (This)->lpVtbl -> GetExtendedErrorCode(This) ) + +#define IMFTimedTextTrack_GetDataFormat(This,format) \ + ( (This)->lpVtbl -> GetDataFormat(This,format) ) + +#define IMFTimedTextTrack_GetReadyState(This) \ + ( (This)->lpVtbl -> GetReadyState(This) ) + +#define IMFTimedTextTrack_GetCueList(This,cues) \ + ( (This)->lpVtbl -> GetCueList(This,cues) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTimedTextTrack_INTERFACE_DEFINED__ */ + + +#ifndef __IMFTimedTextTrackList_INTERFACE_DEFINED__ +#define __IMFTimedTextTrackList_INTERFACE_DEFINED__ + +/* interface IMFTimedTextTrackList */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFTimedTextTrackList; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("23ff334c-442c-445f-bccc-edc438aa11e2") + IMFTimedTextTrackList : public IUnknown + { + public: + virtual DWORD STDMETHODCALLTYPE GetLength( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTrack( + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrack **track) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTrackById( + /* [annotation][in] */ + _In_ DWORD trackId, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrack **track) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTimedTextTrackListVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTimedTextTrackList * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTimedTextTrackList * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTimedTextTrackList * This); + + DWORD ( STDMETHODCALLTYPE *GetLength )( + IMFTimedTextTrackList * This); + + HRESULT ( STDMETHODCALLTYPE *GetTrack )( + IMFTimedTextTrackList * This, + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrack **track); + + HRESULT ( STDMETHODCALLTYPE *GetTrackById )( + IMFTimedTextTrackList * This, + /* [annotation][in] */ + _In_ DWORD trackId, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextTrack **track); + + END_INTERFACE + } IMFTimedTextTrackListVtbl; + + interface IMFTimedTextTrackList + { + CONST_VTBL struct IMFTimedTextTrackListVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTimedTextTrackList_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTimedTextTrackList_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTimedTextTrackList_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTimedTextTrackList_GetLength(This) \ + ( (This)->lpVtbl -> GetLength(This) ) + +#define IMFTimedTextTrackList_GetTrack(This,index,track) \ + ( (This)->lpVtbl -> GetTrack(This,index,track) ) + +#define IMFTimedTextTrackList_GetTrackById(This,trackId,track) \ + ( (This)->lpVtbl -> GetTrackById(This,trackId,track) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTimedTextTrackList_INTERFACE_DEFINED__ */ + + +#ifndef __IMFTimedTextCue_INTERFACE_DEFINED__ +#define __IMFTimedTextCue_INTERFACE_DEFINED__ + +/* interface IMFTimedTextCue */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFTimedTextCue; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("1e560447-9a2b-43e1-a94c-b0aaabfbfbc9") + IMFTimedTextCue : public IUnknown + { + public: + virtual DWORD STDMETHODCALLTYPE GetId( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOriginalId( + /* [annotation][out] */ + _Outptr_ LPWSTR *originalId) = 0; + + virtual MF_TIMED_TEXT_TRACK_KIND STDMETHODCALLTYPE GetCueKind( void) = 0; + + virtual double STDMETHODCALLTYPE GetStartTime( void) = 0; + + virtual double STDMETHODCALLTYPE GetDuration( void) = 0; + + virtual DWORD STDMETHODCALLTYPE GetTrackId( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetData( + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFTimedTextBinary **data) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRegion( + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFTimedTextRegion **region) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStyle( + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFTimedTextStyle **style) = 0; + + virtual DWORD STDMETHODCALLTYPE GetLineCount( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetLine( + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextFormattedText **line) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTimedTextCueVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTimedTextCue * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTimedTextCue * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTimedTextCue * This); + + DWORD ( STDMETHODCALLTYPE *GetId )( + IMFTimedTextCue * This); + + HRESULT ( STDMETHODCALLTYPE *GetOriginalId )( + IMFTimedTextCue * This, + /* [annotation][out] */ + _Outptr_ LPWSTR *originalId); + + MF_TIMED_TEXT_TRACK_KIND ( STDMETHODCALLTYPE *GetCueKind )( + IMFTimedTextCue * This); + + double ( STDMETHODCALLTYPE *GetStartTime )( + IMFTimedTextCue * This); + + double ( STDMETHODCALLTYPE *GetDuration )( + IMFTimedTextCue * This); + + DWORD ( STDMETHODCALLTYPE *GetTrackId )( + IMFTimedTextCue * This); + + HRESULT ( STDMETHODCALLTYPE *GetData )( + IMFTimedTextCue * This, + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFTimedTextBinary **data); + + HRESULT ( STDMETHODCALLTYPE *GetRegion )( + IMFTimedTextCue * This, + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFTimedTextRegion **region); + + HRESULT ( STDMETHODCALLTYPE *GetStyle )( + IMFTimedTextCue * This, + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFTimedTextStyle **style); + + DWORD ( STDMETHODCALLTYPE *GetLineCount )( + IMFTimedTextCue * This); + + HRESULT ( STDMETHODCALLTYPE *GetLine )( + IMFTimedTextCue * This, + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextFormattedText **line); + + END_INTERFACE + } IMFTimedTextCueVtbl; + + interface IMFTimedTextCue + { + CONST_VTBL struct IMFTimedTextCueVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTimedTextCue_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTimedTextCue_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTimedTextCue_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTimedTextCue_GetId(This) \ + ( (This)->lpVtbl -> GetId(This) ) + +#define IMFTimedTextCue_GetOriginalId(This,originalId) \ + ( (This)->lpVtbl -> GetOriginalId(This,originalId) ) + +#define IMFTimedTextCue_GetCueKind(This) \ + ( (This)->lpVtbl -> GetCueKind(This) ) + +#define IMFTimedTextCue_GetStartTime(This) \ + ( (This)->lpVtbl -> GetStartTime(This) ) + +#define IMFTimedTextCue_GetDuration(This) \ + ( (This)->lpVtbl -> GetDuration(This) ) + +#define IMFTimedTextCue_GetTrackId(This) \ + ( (This)->lpVtbl -> GetTrackId(This) ) + +#define IMFTimedTextCue_GetData(This,data) \ + ( (This)->lpVtbl -> GetData(This,data) ) + +#define IMFTimedTextCue_GetRegion(This,region) \ + ( (This)->lpVtbl -> GetRegion(This,region) ) + +#define IMFTimedTextCue_GetStyle(This,style) \ + ( (This)->lpVtbl -> GetStyle(This,style) ) + +#define IMFTimedTextCue_GetLineCount(This) \ + ( (This)->lpVtbl -> GetLineCount(This) ) + +#define IMFTimedTextCue_GetLine(This,index,line) \ + ( (This)->lpVtbl -> GetLine(This,index,line) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTimedTextCue_INTERFACE_DEFINED__ */ + + +#ifndef __IMFTimedTextFormattedText_INTERFACE_DEFINED__ +#define __IMFTimedTextFormattedText_INTERFACE_DEFINED__ + +/* interface IMFTimedTextFormattedText */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFTimedTextFormattedText; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e13af3c1-4d47-4354-b1f5-e83ae0ecae60") + IMFTimedTextFormattedText : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetText( + /* [annotation][out] */ + _Outptr_result_maybenull_ LPWSTR *text) = 0; + + virtual DWORD STDMETHODCALLTYPE GetSubformattingCount( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSubformatting( + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ DWORD *firstChar, + /* [annotation][out] */ + _Out_ DWORD *charLength, + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFTimedTextStyle **style) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTimedTextFormattedTextVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTimedTextFormattedText * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTimedTextFormattedText * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTimedTextFormattedText * This); + + HRESULT ( STDMETHODCALLTYPE *GetText )( + IMFTimedTextFormattedText * This, + /* [annotation][out] */ + _Outptr_result_maybenull_ LPWSTR *text); + + DWORD ( STDMETHODCALLTYPE *GetSubformattingCount )( + IMFTimedTextFormattedText * This); + + HRESULT ( STDMETHODCALLTYPE *GetSubformatting )( + IMFTimedTextFormattedText * This, + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _Out_ DWORD *firstChar, + /* [annotation][out] */ + _Out_ DWORD *charLength, + /* [annotation][out] */ + _COM_Outptr_result_maybenull_ IMFTimedTextStyle **style); + + END_INTERFACE + } IMFTimedTextFormattedTextVtbl; + + interface IMFTimedTextFormattedText + { + CONST_VTBL struct IMFTimedTextFormattedTextVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTimedTextFormattedText_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTimedTextFormattedText_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTimedTextFormattedText_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTimedTextFormattedText_GetText(This,text) \ + ( (This)->lpVtbl -> GetText(This,text) ) + +#define IMFTimedTextFormattedText_GetSubformattingCount(This) \ + ( (This)->lpVtbl -> GetSubformattingCount(This) ) + +#define IMFTimedTextFormattedText_GetSubformatting(This,index,firstChar,charLength,style) \ + ( (This)->lpVtbl -> GetSubformatting(This,index,firstChar,charLength,style) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTimedTextFormattedText_INTERFACE_DEFINED__ */ + + +#ifndef __IMFTimedTextStyle_INTERFACE_DEFINED__ +#define __IMFTimedTextStyle_INTERFACE_DEFINED__ + +/* interface IMFTimedTextStyle */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFTimedTextStyle; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("09b2455d-b834-4f01-a347-9052e21c450e") + IMFTimedTextStyle : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetName( + /* [annotation][out] */ + _Outptr_ LPWSTR *name) = 0; + + virtual BOOL STDMETHODCALLTYPE IsExternal( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFontFamily( + /* [annotation][out] */ + _Outptr_ LPWSTR *fontFamily) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFontSize( + /* [annotation][out] */ + _Out_ double *fontSize, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_UNIT_TYPE *unitType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetColor( + /* [annotation][out] */ + _Out_ MFARGB *color) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBackgroundColor( + /* [annotation][out] */ + _Out_ MFARGB *bgColor) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetShowBackgroundAlways( + /* [annotation][out] */ + _Out_ BOOL *showBackgroundAlways) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetFontStyle( + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_FONT_STYLE *fontStyle) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBold( + /* [annotation][out] */ + _Out_ BOOL *bold) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetRightToLeft( + /* [annotation][out] */ + _Out_ BOOL *rightToLeft) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTextAlignment( + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_ALIGNMENT *textAlign) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTextDecoration( + /* [annotation][out] */ + _Out_ DWORD *textDecoration) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTextOutline( + /* [annotation][out] */ + _Out_ MFARGB *color, + /* [annotation][out] */ + _Out_ double *thickness, + /* [annotation][out] */ + _Out_ double *blurRadius, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_UNIT_TYPE *unitType) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTimedTextStyleVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTimedTextStyle * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTimedTextStyle * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTimedTextStyle * This); + + HRESULT ( STDMETHODCALLTYPE *GetName )( + IMFTimedTextStyle * This, + /* [annotation][out] */ + _Outptr_ LPWSTR *name); + + BOOL ( STDMETHODCALLTYPE *IsExternal )( + IMFTimedTextStyle * This); + + HRESULT ( STDMETHODCALLTYPE *GetFontFamily )( + IMFTimedTextStyle * This, + /* [annotation][out] */ + _Outptr_ LPWSTR *fontFamily); + + HRESULT ( STDMETHODCALLTYPE *GetFontSize )( + IMFTimedTextStyle * This, + /* [annotation][out] */ + _Out_ double *fontSize, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_UNIT_TYPE *unitType); + + HRESULT ( STDMETHODCALLTYPE *GetColor )( + IMFTimedTextStyle * This, + /* [annotation][out] */ + _Out_ MFARGB *color); + + HRESULT ( STDMETHODCALLTYPE *GetBackgroundColor )( + IMFTimedTextStyle * This, + /* [annotation][out] */ + _Out_ MFARGB *bgColor); + + HRESULT ( STDMETHODCALLTYPE *GetShowBackgroundAlways )( + IMFTimedTextStyle * This, + /* [annotation][out] */ + _Out_ BOOL *showBackgroundAlways); + + HRESULT ( STDMETHODCALLTYPE *GetFontStyle )( + IMFTimedTextStyle * This, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_FONT_STYLE *fontStyle); + + HRESULT ( STDMETHODCALLTYPE *GetBold )( + IMFTimedTextStyle * This, + /* [annotation][out] */ + _Out_ BOOL *bold); + + HRESULT ( STDMETHODCALLTYPE *GetRightToLeft )( + IMFTimedTextStyle * This, + /* [annotation][out] */ + _Out_ BOOL *rightToLeft); + + HRESULT ( STDMETHODCALLTYPE *GetTextAlignment )( + IMFTimedTextStyle * This, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_ALIGNMENT *textAlign); + + HRESULT ( STDMETHODCALLTYPE *GetTextDecoration )( + IMFTimedTextStyle * This, + /* [annotation][out] */ + _Out_ DWORD *textDecoration); + + HRESULT ( STDMETHODCALLTYPE *GetTextOutline )( + IMFTimedTextStyle * This, + /* [annotation][out] */ + _Out_ MFARGB *color, + /* [annotation][out] */ + _Out_ double *thickness, + /* [annotation][out] */ + _Out_ double *blurRadius, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_UNIT_TYPE *unitType); + + END_INTERFACE + } IMFTimedTextStyleVtbl; + + interface IMFTimedTextStyle + { + CONST_VTBL struct IMFTimedTextStyleVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTimedTextStyle_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTimedTextStyle_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTimedTextStyle_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTimedTextStyle_GetName(This,name) \ + ( (This)->lpVtbl -> GetName(This,name) ) + +#define IMFTimedTextStyle_IsExternal(This) \ + ( (This)->lpVtbl -> IsExternal(This) ) + +#define IMFTimedTextStyle_GetFontFamily(This,fontFamily) \ + ( (This)->lpVtbl -> GetFontFamily(This,fontFamily) ) + +#define IMFTimedTextStyle_GetFontSize(This,fontSize,unitType) \ + ( (This)->lpVtbl -> GetFontSize(This,fontSize,unitType) ) + +#define IMFTimedTextStyle_GetColor(This,color) \ + ( (This)->lpVtbl -> GetColor(This,color) ) + +#define IMFTimedTextStyle_GetBackgroundColor(This,bgColor) \ + ( (This)->lpVtbl -> GetBackgroundColor(This,bgColor) ) + +#define IMFTimedTextStyle_GetShowBackgroundAlways(This,showBackgroundAlways) \ + ( (This)->lpVtbl -> GetShowBackgroundAlways(This,showBackgroundAlways) ) + +#define IMFTimedTextStyle_GetFontStyle(This,fontStyle) \ + ( (This)->lpVtbl -> GetFontStyle(This,fontStyle) ) + +#define IMFTimedTextStyle_GetBold(This,bold) \ + ( (This)->lpVtbl -> GetBold(This,bold) ) + +#define IMFTimedTextStyle_GetRightToLeft(This,rightToLeft) \ + ( (This)->lpVtbl -> GetRightToLeft(This,rightToLeft) ) + +#define IMFTimedTextStyle_GetTextAlignment(This,textAlign) \ + ( (This)->lpVtbl -> GetTextAlignment(This,textAlign) ) + +#define IMFTimedTextStyle_GetTextDecoration(This,textDecoration) \ + ( (This)->lpVtbl -> GetTextDecoration(This,textDecoration) ) + +#define IMFTimedTextStyle_GetTextOutline(This,color,thickness,blurRadius,unitType) \ + ( (This)->lpVtbl -> GetTextOutline(This,color,thickness,blurRadius,unitType) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTimedTextStyle_INTERFACE_DEFINED__ */ + + +#ifndef __IMFTimedTextRegion_INTERFACE_DEFINED__ +#define __IMFTimedTextRegion_INTERFACE_DEFINED__ + +/* interface IMFTimedTextRegion */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFTimedTextRegion; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c8d22afc-bc47-4bdf-9b04-787e49ce3f58") + IMFTimedTextRegion : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetName( + /* [annotation][out] */ + _Outptr_ LPWSTR *name) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPosition( + /* [annotation][out] */ + _Out_ double *pX, + /* [annotation][out] */ + _Out_ double *pY, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_UNIT_TYPE *unitType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetExtent( + /* [annotation][out] */ + _Out_ double *pWidth, + /* [annotation][out] */ + _Out_ double *pHeight, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_UNIT_TYPE *unitType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBackgroundColor( + /* [annotation][out] */ + _Out_ MFARGB *bgColor) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetWritingMode( + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_WRITING_MODE *writingMode) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisplayAlignment( + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_DISPLAY_ALIGNMENT *displayAlign) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetLineHeight( + /* [annotation][out] */ + _Out_ double *pLineHeight, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_UNIT_TYPE *unitType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetClipOverflow( + /* [annotation][out] */ + _Out_ BOOL *clipOverflow) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPadding( + /* [annotation][out] */ + _Out_ double *before, + /* [annotation][out] */ + _Out_ double *start, + /* [annotation][out] */ + _Out_ double *after, + /* [annotation][out] */ + _Out_ double *end, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_UNIT_TYPE *unitType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetWrap( + /* [annotation][out] */ + _Out_ BOOL *wrap) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetZIndex( + /* [annotation][out] */ + _Out_ INT32 *zIndex) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetScrollMode( + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_SCROLL_MODE *scrollMode) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTimedTextRegionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTimedTextRegion * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTimedTextRegion * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTimedTextRegion * This); + + HRESULT ( STDMETHODCALLTYPE *GetName )( + IMFTimedTextRegion * This, + /* [annotation][out] */ + _Outptr_ LPWSTR *name); + + HRESULT ( STDMETHODCALLTYPE *GetPosition )( + IMFTimedTextRegion * This, + /* [annotation][out] */ + _Out_ double *pX, + /* [annotation][out] */ + _Out_ double *pY, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_UNIT_TYPE *unitType); + + HRESULT ( STDMETHODCALLTYPE *GetExtent )( + IMFTimedTextRegion * This, + /* [annotation][out] */ + _Out_ double *pWidth, + /* [annotation][out] */ + _Out_ double *pHeight, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_UNIT_TYPE *unitType); + + HRESULT ( STDMETHODCALLTYPE *GetBackgroundColor )( + IMFTimedTextRegion * This, + /* [annotation][out] */ + _Out_ MFARGB *bgColor); + + HRESULT ( STDMETHODCALLTYPE *GetWritingMode )( + IMFTimedTextRegion * This, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_WRITING_MODE *writingMode); + + HRESULT ( STDMETHODCALLTYPE *GetDisplayAlignment )( + IMFTimedTextRegion * This, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_DISPLAY_ALIGNMENT *displayAlign); + + HRESULT ( STDMETHODCALLTYPE *GetLineHeight )( + IMFTimedTextRegion * This, + /* [annotation][out] */ + _Out_ double *pLineHeight, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_UNIT_TYPE *unitType); + + HRESULT ( STDMETHODCALLTYPE *GetClipOverflow )( + IMFTimedTextRegion * This, + /* [annotation][out] */ + _Out_ BOOL *clipOverflow); + + HRESULT ( STDMETHODCALLTYPE *GetPadding )( + IMFTimedTextRegion * This, + /* [annotation][out] */ + _Out_ double *before, + /* [annotation][out] */ + _Out_ double *start, + /* [annotation][out] */ + _Out_ double *after, + /* [annotation][out] */ + _Out_ double *end, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_UNIT_TYPE *unitType); + + HRESULT ( STDMETHODCALLTYPE *GetWrap )( + IMFTimedTextRegion * This, + /* [annotation][out] */ + _Out_ BOOL *wrap); + + HRESULT ( STDMETHODCALLTYPE *GetZIndex )( + IMFTimedTextRegion * This, + /* [annotation][out] */ + _Out_ INT32 *zIndex); + + HRESULT ( STDMETHODCALLTYPE *GetScrollMode )( + IMFTimedTextRegion * This, + /* [annotation][out] */ + _Out_ MF_TIMED_TEXT_SCROLL_MODE *scrollMode); + + END_INTERFACE + } IMFTimedTextRegionVtbl; + + interface IMFTimedTextRegion + { + CONST_VTBL struct IMFTimedTextRegionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTimedTextRegion_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTimedTextRegion_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTimedTextRegion_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTimedTextRegion_GetName(This,name) \ + ( (This)->lpVtbl -> GetName(This,name) ) + +#define IMFTimedTextRegion_GetPosition(This,pX,pY,unitType) \ + ( (This)->lpVtbl -> GetPosition(This,pX,pY,unitType) ) + +#define IMFTimedTextRegion_GetExtent(This,pWidth,pHeight,unitType) \ + ( (This)->lpVtbl -> GetExtent(This,pWidth,pHeight,unitType) ) + +#define IMFTimedTextRegion_GetBackgroundColor(This,bgColor) \ + ( (This)->lpVtbl -> GetBackgroundColor(This,bgColor) ) + +#define IMFTimedTextRegion_GetWritingMode(This,writingMode) \ + ( (This)->lpVtbl -> GetWritingMode(This,writingMode) ) + +#define IMFTimedTextRegion_GetDisplayAlignment(This,displayAlign) \ + ( (This)->lpVtbl -> GetDisplayAlignment(This,displayAlign) ) + +#define IMFTimedTextRegion_GetLineHeight(This,pLineHeight,unitType) \ + ( (This)->lpVtbl -> GetLineHeight(This,pLineHeight,unitType) ) + +#define IMFTimedTextRegion_GetClipOverflow(This,clipOverflow) \ + ( (This)->lpVtbl -> GetClipOverflow(This,clipOverflow) ) + +#define IMFTimedTextRegion_GetPadding(This,before,start,after,end,unitType) \ + ( (This)->lpVtbl -> GetPadding(This,before,start,after,end,unitType) ) + +#define IMFTimedTextRegion_GetWrap(This,wrap) \ + ( (This)->lpVtbl -> GetWrap(This,wrap) ) + +#define IMFTimedTextRegion_GetZIndex(This,zIndex) \ + ( (This)->lpVtbl -> GetZIndex(This,zIndex) ) + +#define IMFTimedTextRegion_GetScrollMode(This,scrollMode) \ + ( (This)->lpVtbl -> GetScrollMode(This,scrollMode) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTimedTextRegion_INTERFACE_DEFINED__ */ + + +#ifndef __IMFTimedTextBinary_INTERFACE_DEFINED__ +#define __IMFTimedTextBinary_INTERFACE_DEFINED__ + +/* interface IMFTimedTextBinary */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFTimedTextBinary; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("4ae3a412-0545-43c4-bf6f-6b97a5c6c432") + IMFTimedTextBinary : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetData( + /* [annotation][out] */ + _Outptr_result_bytebuffer_(*length) const BYTE **data, + /* [annotation][out] */ + _Out_ DWORD *length) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTimedTextBinaryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTimedTextBinary * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTimedTextBinary * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTimedTextBinary * This); + + HRESULT ( STDMETHODCALLTYPE *GetData )( + IMFTimedTextBinary * This, + /* [annotation][out] */ + _Outptr_result_bytebuffer_(*length) const BYTE **data, + /* [annotation][out] */ + _Out_ DWORD *length); + + END_INTERFACE + } IMFTimedTextBinaryVtbl; + + interface IMFTimedTextBinary + { + CONST_VTBL struct IMFTimedTextBinaryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTimedTextBinary_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTimedTextBinary_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTimedTextBinary_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTimedTextBinary_GetData(This,data,length) \ + ( (This)->lpVtbl -> GetData(This,data,length) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTimedTextBinary_INTERFACE_DEFINED__ */ + + +#ifndef __IMFTimedTextCueList_INTERFACE_DEFINED__ +#define __IMFTimedTextCueList_INTERFACE_DEFINED__ + +/* interface IMFTimedTextCueList */ +/* [local][unique][uuid][object] */ + + +EXTERN_C const IID IID_IMFTimedTextCueList; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ad128745-211b-40a0-9981-fe65f166d0fd") + IMFTimedTextCueList : public IUnknown + { + public: + virtual DWORD STDMETHODCALLTYPE GetLength( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCueByIndex( + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextCue **cue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCueById( + /* [annotation][in] */ + _In_ DWORD id, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextCue **cue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCueByOriginalId( + /* [annotation][in] */ + _In_ LPCWSTR originalId, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextCue **cue) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddTextCue( + /* [annotation][in] */ + _In_ double start, + /* [annotation][in] */ + _In_ double duration, + /* [annotation][in] */ + _In_ LPCWSTR text, + /* [annotation][out] */ + _COM_Outptr_opt_ IMFTimedTextCue **cue) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddDataCue( + /* [annotation][in] */ + _In_ double start, + /* [annotation][in] */ + _In_ double duration, + /* [annotation][in] */ + _In_reads_bytes_(dataSize) const BYTE *data, + /* [annotation][in] */ + _In_ DWORD dataSize, + /* [annotation][out] */ + _COM_Outptr_opt_ IMFTimedTextCue **cue) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveCue( + /* [annotation][in] */ + _In_ IMFTimedTextCue *cue) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTimedTextCueListVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFTimedTextCueList * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFTimedTextCueList * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFTimedTextCueList * This); + + DWORD ( STDMETHODCALLTYPE *GetLength )( + IMFTimedTextCueList * This); + + HRESULT ( STDMETHODCALLTYPE *GetCueByIndex )( + IMFTimedTextCueList * This, + /* [annotation][in] */ + _In_ DWORD index, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextCue **cue); + + HRESULT ( STDMETHODCALLTYPE *GetCueById )( + IMFTimedTextCueList * This, + /* [annotation][in] */ + _In_ DWORD id, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextCue **cue); + + HRESULT ( STDMETHODCALLTYPE *GetCueByOriginalId )( + IMFTimedTextCueList * This, + /* [annotation][in] */ + _In_ LPCWSTR originalId, + /* [annotation][out] */ + _COM_Outptr_ IMFTimedTextCue **cue); + + HRESULT ( STDMETHODCALLTYPE *AddTextCue )( + IMFTimedTextCueList * This, + /* [annotation][in] */ + _In_ double start, + /* [annotation][in] */ + _In_ double duration, + /* [annotation][in] */ + _In_ LPCWSTR text, + /* [annotation][out] */ + _COM_Outptr_opt_ IMFTimedTextCue **cue); + + HRESULT ( STDMETHODCALLTYPE *AddDataCue )( + IMFTimedTextCueList * This, + /* [annotation][in] */ + _In_ double start, + /* [annotation][in] */ + _In_ double duration, + /* [annotation][in] */ + _In_reads_bytes_(dataSize) const BYTE *data, + /* [annotation][in] */ + _In_ DWORD dataSize, + /* [annotation][out] */ + _COM_Outptr_opt_ IMFTimedTextCue **cue); + + HRESULT ( STDMETHODCALLTYPE *RemoveCue )( + IMFTimedTextCueList * This, + /* [annotation][in] */ + _In_ IMFTimedTextCue *cue); + + END_INTERFACE + } IMFTimedTextCueListVtbl; + + interface IMFTimedTextCueList + { + CONST_VTBL struct IMFTimedTextCueListVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTimedTextCueList_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTimedTextCueList_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTimedTextCueList_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTimedTextCueList_GetLength(This) \ + ( (This)->lpVtbl -> GetLength(This) ) + +#define IMFTimedTextCueList_GetCueByIndex(This,index,cue) \ + ( (This)->lpVtbl -> GetCueByIndex(This,index,cue) ) + +#define IMFTimedTextCueList_GetCueById(This,id,cue) \ + ( (This)->lpVtbl -> GetCueById(This,id,cue) ) + +#define IMFTimedTextCueList_GetCueByOriginalId(This,originalId,cue) \ + ( (This)->lpVtbl -> GetCueByOriginalId(This,originalId,cue) ) + +#define IMFTimedTextCueList_AddTextCue(This,start,duration,text,cue) \ + ( (This)->lpVtbl -> AddTextCue(This,start,duration,text,cue) ) + +#define IMFTimedTextCueList_AddDataCue(This,start,duration,data,dataSize,cue) \ + ( (This)->lpVtbl -> AddDataCue(This,start,duration,data,dataSize,cue) ) + +#define IMFTimedTextCueList_RemoveCue(This,cue) \ + ( (This)->lpVtbl -> RemoveCue(This,cue) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTimedTextCueList_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0044 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +EXTERN_GUID(MF_MEDIA_ENGINE_CONTINUE_ON_CODEC_ERROR, +0xdbcdb7f9,0x48e4,0x4295,0xb7,0x0d,0xd5,0x18,0x23,0x4e,0xeb,0x38); +typedef +enum MF_MEDIA_ENGINE_STREAMTYPE_FAILED + { + MF_MEDIA_ENGINE_STREAMTYPE_FAILED_UNKNOWN = 0, + MF_MEDIA_ENGINE_STREAMTYPE_FAILED_AUDIO = 1, + MF_MEDIA_ENGINE_STREAMTYPE_FAILED_VIDEO = 2 + } MF_MEDIA_ENGINE_STREAMTYPE_FAILED; + +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#pragma region EME2 + + + + + + +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +EXTERN_GUID(MF_MEDIA_ENGINE_EME_CALLBACK, +0x494553a7, 0xa481, 0x4cb7, 0xbe, 0xc5, 0x38, 0x09, 0x03, 0x51, 0x37, 0x31); + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0044_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0044_v0_0_s_ifspec; + +#ifndef __IMFMediaEngineEMENotify_INTERFACE_DEFINED__ +#define __IMFMediaEngineEMENotify_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineEMENotify */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineEMENotify; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("9e184d15-cdb7-4f86-b49e-566689f4a601") + IMFMediaEngineEMENotify : public IUnknown + { + public: + virtual void STDMETHODCALLTYPE Encrypted( + /* [annotation] */ + _In_reads_bytes_opt_(cb) const BYTE *pbInitData, + /* [annotation] */ + _In_ DWORD cb, + /* [annotation] */ + _In_ BSTR bstrInitDataType) = 0; + + virtual void STDMETHODCALLTYPE WaitingForKey( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineEMENotifyVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineEMENotify * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineEMENotify * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineEMENotify * This); + + void ( STDMETHODCALLTYPE *Encrypted )( + IMFMediaEngineEMENotify * This, + /* [annotation] */ + _In_reads_bytes_opt_(cb) const BYTE *pbInitData, + /* [annotation] */ + _In_ DWORD cb, + /* [annotation] */ + _In_ BSTR bstrInitDataType); + + void ( STDMETHODCALLTYPE *WaitingForKey )( + IMFMediaEngineEMENotify * This); + + END_INTERFACE + } IMFMediaEngineEMENotifyVtbl; + + interface IMFMediaEngineEMENotify + { + CONST_VTBL struct IMFMediaEngineEMENotifyVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineEMENotify_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineEMENotify_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineEMENotify_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineEMENotify_Encrypted(This,pbInitData,cb,bstrInitDataType) \ + ( (This)->lpVtbl -> Encrypted(This,pbInitData,cb,bstrInitDataType) ) + +#define IMFMediaEngineEMENotify_WaitingForKey(This) \ + ( (This)->lpVtbl -> WaitingForKey(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineEMENotify_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0045 */ +/* [local] */ + +typedef +enum MF_MEDIAKEYS_REQUIREMENT + { + MF_MEDIAKEYS_REQUIREMENT_REQUIRED = 1, + MF_MEDIAKEYS_REQUIREMENT_OPTIONAL = 2, + MF_MEDIAKEYS_REQUIREMENT_NOT_ALLOWED = 3 + } MF_MEDIAKEYS_REQUIREMENT; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0045_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0045_v0_0_s_ifspec; + +#ifndef __IMFMediaKeySessionNotify2_INTERFACE_DEFINED__ +#define __IMFMediaKeySessionNotify2_INTERFACE_DEFINED__ + +/* interface IMFMediaKeySessionNotify2 */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaKeySessionNotify2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c3a9e92a-da88-46b0-a110-6cf953026cb9") + IMFMediaKeySessionNotify2 : public IMFMediaKeySessionNotify + { + public: + virtual void STDMETHODCALLTYPE KeyMessage2( + /* [annotation] */ + _In_ MF_MEDIAKEYSESSION_MESSAGETYPE eMessageType, + /* [annotation] */ + _In_opt_ BSTR destinationURL, + /* [annotation] */ + _In_reads_bytes_(cbMessage) const BYTE *pbMessage, + /* [annotation] */ + _In_ DWORD cbMessage) = 0; + + virtual void STDMETHODCALLTYPE KeyStatusChange( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaKeySessionNotify2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaKeySessionNotify2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaKeySessionNotify2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaKeySessionNotify2 * This); + + void ( STDMETHODCALLTYPE *KeyMessage )( + IMFMediaKeySessionNotify2 * This, + /* [annotation] */ + _In_opt_ BSTR destinationURL, + /* [annotation] */ + _In_reads_bytes_(cb) const BYTE *message, + /* [annotation] */ + _In_ DWORD cb); + + void ( STDMETHODCALLTYPE *KeyAdded )( + IMFMediaKeySessionNotify2 * This); + + void ( STDMETHODCALLTYPE *KeyError )( + IMFMediaKeySessionNotify2 * This, + /* [annotation] */ + _In_ USHORT code, + /* [annotation] */ + _In_ DWORD systemCode); + + void ( STDMETHODCALLTYPE *KeyMessage2 )( + IMFMediaKeySessionNotify2 * This, + /* [annotation] */ + _In_ MF_MEDIAKEYSESSION_MESSAGETYPE eMessageType, + /* [annotation] */ + _In_opt_ BSTR destinationURL, + /* [annotation] */ + _In_reads_bytes_(cbMessage) const BYTE *pbMessage, + /* [annotation] */ + _In_ DWORD cbMessage); + + void ( STDMETHODCALLTYPE *KeyStatusChange )( + IMFMediaKeySessionNotify2 * This); + + END_INTERFACE + } IMFMediaKeySessionNotify2Vtbl; + + interface IMFMediaKeySessionNotify2 + { + CONST_VTBL struct IMFMediaKeySessionNotify2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaKeySessionNotify2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaKeySessionNotify2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaKeySessionNotify2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaKeySessionNotify2_KeyMessage(This,destinationURL,message,cb) \ + ( (This)->lpVtbl -> KeyMessage(This,destinationURL,message,cb) ) + +#define IMFMediaKeySessionNotify2_KeyAdded(This) \ + ( (This)->lpVtbl -> KeyAdded(This) ) + +#define IMFMediaKeySessionNotify2_KeyError(This,code,systemCode) \ + ( (This)->lpVtbl -> KeyError(This,code,systemCode) ) + + +#define IMFMediaKeySessionNotify2_KeyMessage2(This,eMessageType,destinationURL,pbMessage,cbMessage) \ + ( (This)->lpVtbl -> KeyMessage2(This,eMessageType,destinationURL,pbMessage,cbMessage) ) + +#define IMFMediaKeySessionNotify2_KeyStatusChange(This) \ + ( (This)->lpVtbl -> KeyStatusChange(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaKeySessionNotify2_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaKeySystemAccess_INTERFACE_DEFINED__ +#define __IMFMediaKeySystemAccess_INTERFACE_DEFINED__ + +/* interface IMFMediaKeySystemAccess */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaKeySystemAccess; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("aec63fda-7a97-4944-b35c-6c6df8085cc3") + IMFMediaKeySystemAccess : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateMediaKeys( + /* [annotation] */ + _In_opt_ IPropertyStore *pCdmCustomConfig, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeys2 **ppKeys) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_SupportedConfiguration( + /* [annotation] */ + _COM_Outptr_ IPropertyStore **ppSupportedConfiguration) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_KeySystem( + /* [annotation] */ + _Out_ BSTR *pKeySystem) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaKeySystemAccessVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaKeySystemAccess * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaKeySystemAccess * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaKeySystemAccess * This); + + HRESULT ( STDMETHODCALLTYPE *CreateMediaKeys )( + IMFMediaKeySystemAccess * This, + /* [annotation] */ + _In_opt_ IPropertyStore *pCdmCustomConfig, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeys2 **ppKeys); + + HRESULT ( STDMETHODCALLTYPE *get_SupportedConfiguration )( + IMFMediaKeySystemAccess * This, + /* [annotation] */ + _COM_Outptr_ IPropertyStore **ppSupportedConfiguration); + + HRESULT ( STDMETHODCALLTYPE *get_KeySystem )( + IMFMediaKeySystemAccess * This, + /* [annotation] */ + _Out_ BSTR *pKeySystem); + + END_INTERFACE + } IMFMediaKeySystemAccessVtbl; + + interface IMFMediaKeySystemAccess + { + CONST_VTBL struct IMFMediaKeySystemAccessVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaKeySystemAccess_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaKeySystemAccess_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaKeySystemAccess_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaKeySystemAccess_CreateMediaKeys(This,pCdmCustomConfig,ppKeys) \ + ( (This)->lpVtbl -> CreateMediaKeys(This,pCdmCustomConfig,ppKeys) ) + +#define IMFMediaKeySystemAccess_get_SupportedConfiguration(This,ppSupportedConfiguration) \ + ( (This)->lpVtbl -> get_SupportedConfiguration(This,ppSupportedConfiguration) ) + +#define IMFMediaKeySystemAccess_get_KeySystem(This,pKeySystem) \ + ( (This)->lpVtbl -> get_KeySystem(This,pKeySystem) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaKeySystemAccess_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaEngineClassFactory3_INTERFACE_DEFINED__ +#define __IMFMediaEngineClassFactory3_INTERFACE_DEFINED__ + +/* interface IMFMediaEngineClassFactory3 */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEngineClassFactory3; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("3787614f-65f7-4003-b673-ead8293a0e60") + IMFMediaEngineClassFactory3 : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateMediaKeySystemAccess( + /* [annotation] */ + _In_ BSTR keySystem, + /* [annotation] */ + _In_count_(uSize) IPropertyStore **ppSupportedConfigurationsArray, + /* [annotation] */ + _In_ UINT uSize, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeySystemAccess **ppKeyAccess) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEngineClassFactory3Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEngineClassFactory3 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEngineClassFactory3 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEngineClassFactory3 * This); + + HRESULT ( STDMETHODCALLTYPE *CreateMediaKeySystemAccess )( + IMFMediaEngineClassFactory3 * This, + /* [annotation] */ + _In_ BSTR keySystem, + /* [annotation] */ + _In_count_(uSize) IPropertyStore **ppSupportedConfigurationsArray, + /* [annotation] */ + _In_ UINT uSize, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeySystemAccess **ppKeyAccess); + + END_INTERFACE + } IMFMediaEngineClassFactory3Vtbl; + + interface IMFMediaEngineClassFactory3 + { + CONST_VTBL struct IMFMediaEngineClassFactory3Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEngineClassFactory3_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEngineClassFactory3_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEngineClassFactory3_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEngineClassFactory3_CreateMediaKeySystemAccess(This,keySystem,ppSupportedConfigurationsArray,uSize,ppKeyAccess) \ + ( (This)->lpVtbl -> CreateMediaKeySystemAccess(This,keySystem,ppSupportedConfigurationsArray,uSize,ppKeyAccess) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEngineClassFactory3_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0048 */ +/* [local] */ + +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MF_EME_INITDATATYPES = { { 0x497d231b, 0x4eb9, 0x4df0, { 0xb4, 0x74, 0xb9, 0xaf, 0xeb, 0x0a, 0xdf, 0x38 } }, PID_FIRST_USABLE+0x00000001 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MF_EME_DISTINCTIVEID = { { 0x7dc9c4a5, 0x12be, 0x497e, { 0x8b, 0xff, 0x9b, 0x60, 0xb2, 0xdc, 0x58, 0x45 } }, PID_FIRST_USABLE+0x00000002 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MF_EME_PERSISTEDSTATE = { { 0x5d4df6ae, 0x9af1, 0x4e3d, { 0x95, 0x5b, 0x0e, 0x4b, 0xd2, 0x2f, 0xed, 0xf0 } }, PID_FIRST_USABLE+0x00000003 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MF_EME_AUDIOCAPABILITIES = { { 0x980fbb84, 0x297d, 0x4ea7, { 0x89, 0x5f, 0xbc, 0xf2, 0x8a, 0x46, 0x28, 0x81 } }, PID_FIRST_USABLE+0x00000004 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MF_EME_VIDEOCAPABILITIES = { { 0xb172f83d, 0x30dd, 0x4c10, { 0x80, 0x06, 0xed, 0x53, 0xda, 0x4d, 0x3b, 0xdb } }, PID_FIRST_USABLE+0x00000005 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MF_EME_LABEL = { { 0x9eae270e, 0xb2d7, 0x4817, { 0xb8, 0x8f, 0x54, 0x00, 0x99, 0xf2, 0xef, 0x4e } }, PID_FIRST_USABLE+0x00000006 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MF_EME_SESSIONTYPES = { { 0x7623384f, 0x00f5, 0x4376, { 0x86, 0x98, 0x34, 0x58, 0xdb, 0x03, 0x0e, 0xd5 } }, PID_FIRST_USABLE+0x00000007 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MF_EME_ROBUSTNESS = { { 0x9d3d2b9e, 0x7023, 0x4944, { 0xa8, 0xf5, 0xec, 0xca, 0x52, 0xa4, 0x69, 0x90 } }, PID_FIRST_USABLE+0x00000001 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MF_EME_CONTENTTYPE = { { 0x289fb1fc, 0xd9c4, 0x4cc7, { 0xb2, 0xbe, 0x97, 0x2b, 0x0e, 0x9b, 0x28, 0x3a } }, PID_FIRST_USABLE+0x00000002 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MF_EME_CDM_INPRIVATESTOREPATH = { { 0xec305fd9, 0x039f, 0x4ac8, { 0x98, 0xda, 0xe7, 0x92, 0x1e, 0x00, 0x6a, 0x90 } }, PID_FIRST_USABLE+0x00000001 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MF_EME_CDM_STOREPATH = { { 0xf795841e, 0x99f9, 0x44d7, { 0xaf, 0xc0, 0xd3, 0x09, 0xc0, 0x4c, 0x94, 0xab } }, PID_FIRST_USABLE+0x00000002 }; + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0048_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0048_v0_0_s_ifspec; + +#ifndef __IMFMediaKeys2_INTERFACE_DEFINED__ +#define __IMFMediaKeys2_INTERFACE_DEFINED__ + +/* interface IMFMediaKeys2 */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaKeys2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("45892507-ad66-4de2-83a2-acbb13cd8d43") + IMFMediaKeys2 : public IMFMediaKeys + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateSession2( + /* [annotation] */ + _In_ MF_MEDIAKEYSESSION_TYPE eSessionType, + /* [annotation] */ + _In_ IMFMediaKeySessionNotify2 *pMFMediaKeySessionNotify2, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeySession2 **ppSession) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetServerCertificate( + /* [annotation] */ + _In_reads_bytes_opt_(cb) const BYTE *pbServerCertificate, + /* [annotation] */ + _In_ DWORD cb) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDOMException( + /* [annotation] */ + _In_ HRESULT systemCode, + /* [annotation] */ + _Out_ HRESULT *code) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaKeys2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaKeys2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaKeys2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaKeys2 * This); + + HRESULT ( STDMETHODCALLTYPE *CreateSession )( + IMFMediaKeys2 * This, + /* [annotation] */ + _In_opt_ BSTR mimeType, + /* [annotation] */ + _In_reads_bytes_opt_(cb) const BYTE *initData, + /* [annotation] */ + _In_opt_ DWORD cb, + /* [annotation] */ + _In_reads_bytes_opt_(cbCustomData) const BYTE *customData, + /* [annotation] */ + _In_ DWORD cbCustomData, + /* [annotation] */ + _In_ IMFMediaKeySessionNotify *notify, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeySession **ppSession); + + HRESULT ( STDMETHODCALLTYPE *get_KeySystem )( + IMFMediaKeys2 * This, + /* [annotation] */ + _COM_Outptr_ BSTR *keySystem); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + IMFMediaKeys2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetSuspendNotify )( + IMFMediaKeys2 * This, + /* [annotation] */ + _COM_Outptr_ IMFCdmSuspendNotify **notify); + + HRESULT ( STDMETHODCALLTYPE *CreateSession2 )( + IMFMediaKeys2 * This, + /* [annotation] */ + _In_ MF_MEDIAKEYSESSION_TYPE eSessionType, + /* [annotation] */ + _In_ IMFMediaKeySessionNotify2 *pMFMediaKeySessionNotify2, + /* [annotation] */ + _COM_Outptr_ IMFMediaKeySession2 **ppSession); + + HRESULT ( STDMETHODCALLTYPE *SetServerCertificate )( + IMFMediaKeys2 * This, + /* [annotation] */ + _In_reads_bytes_opt_(cb) const BYTE *pbServerCertificate, + /* [annotation] */ + _In_ DWORD cb); + + HRESULT ( STDMETHODCALLTYPE *GetDOMException )( + IMFMediaKeys2 * This, + /* [annotation] */ + _In_ HRESULT systemCode, + /* [annotation] */ + _Out_ HRESULT *code); + + END_INTERFACE + } IMFMediaKeys2Vtbl; + + interface IMFMediaKeys2 + { + CONST_VTBL struct IMFMediaKeys2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaKeys2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaKeys2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaKeys2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaKeys2_CreateSession(This,mimeType,initData,cb,customData,cbCustomData,notify,ppSession) \ + ( (This)->lpVtbl -> CreateSession(This,mimeType,initData,cb,customData,cbCustomData,notify,ppSession) ) + +#define IMFMediaKeys2_get_KeySystem(This,keySystem) \ + ( (This)->lpVtbl -> get_KeySystem(This,keySystem) ) + +#define IMFMediaKeys2_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + +#define IMFMediaKeys2_GetSuspendNotify(This,notify) \ + ( (This)->lpVtbl -> GetSuspendNotify(This,notify) ) + + +#define IMFMediaKeys2_CreateSession2(This,eSessionType,pMFMediaKeySessionNotify2,ppSession) \ + ( (This)->lpVtbl -> CreateSession2(This,eSessionType,pMFMediaKeySessionNotify2,ppSession) ) + +#define IMFMediaKeys2_SetServerCertificate(This,pbServerCertificate,cb) \ + ( (This)->lpVtbl -> SetServerCertificate(This,pbServerCertificate,cb) ) + +#define IMFMediaKeys2_GetDOMException(This,systemCode,code) \ + ( (This)->lpVtbl -> GetDOMException(This,systemCode,code) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaKeys2_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaKeySession2_INTERFACE_DEFINED__ +#define __IMFMediaKeySession2_INTERFACE_DEFINED__ + +/* interface IMFMediaKeySession2 */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaKeySession2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e9707e05-6d55-4636-b185-3de21210bd75") + IMFMediaKeySession2 : public IMFMediaKeySession + { + public: + virtual HRESULT STDMETHODCALLTYPE get_KeyStatuses( + /* [annotation] */ + _Outptr_result_buffer_(*puSize) MFMediaKeyStatus **pKeyStatusesArray, + /* [annotation] */ + _Out_ UINT *puSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE Load( + /* [annotation] */ + _In_ BSTR bstrSessionId, + /* [annotation] */ + _Out_ BOOL *pfLoaded) = 0; + + virtual HRESULT STDMETHODCALLTYPE GenerateRequest( + /* [annotation] */ + _In_ BSTR initDataType, + /* [annotation] */ + _In_reads_bytes_(cb) const BYTE *pbInitData, + /* [annotation] */ + _In_ DWORD cb) = 0; + + virtual HRESULT STDMETHODCALLTYPE get_Expiration( + /* [annotation] */ + _Out_ double *dblExpiration) = 0; + + virtual HRESULT STDMETHODCALLTYPE Remove( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Shutdown( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaKeySession2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaKeySession2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaKeySession2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaKeySession2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetError )( + IMFMediaKeySession2 * This, + /* [annotation] */ + _Out_ USHORT *code, + /* [annotation] */ + _Out_ DWORD *systemCode); + + HRESULT ( STDMETHODCALLTYPE *get_KeySystem )( + IMFMediaKeySession2 * This, + /* [annotation] */ + _COM_Outptr_ BSTR *keySystem); + + HRESULT ( STDMETHODCALLTYPE *get_SessionId )( + IMFMediaKeySession2 * This, + /* [annotation] */ + _COM_Outptr_ BSTR *sessionId); + + HRESULT ( STDMETHODCALLTYPE *Update )( + IMFMediaKeySession2 * This, + /* [annotation] */ + _In_reads_bytes_(cb) const BYTE *key, + /* [annotation] */ + _In_ DWORD cb); + + HRESULT ( STDMETHODCALLTYPE *Close )( + IMFMediaKeySession2 * This); + + HRESULT ( STDMETHODCALLTYPE *get_KeyStatuses )( + IMFMediaKeySession2 * This, + /* [annotation] */ + _Outptr_result_buffer_(*puSize) MFMediaKeyStatus **pKeyStatusesArray, + /* [annotation] */ + _Out_ UINT *puSize); + + HRESULT ( STDMETHODCALLTYPE *Load )( + IMFMediaKeySession2 * This, + /* [annotation] */ + _In_ BSTR bstrSessionId, + /* [annotation] */ + _Out_ BOOL *pfLoaded); + + HRESULT ( STDMETHODCALLTYPE *GenerateRequest )( + IMFMediaKeySession2 * This, + /* [annotation] */ + _In_ BSTR initDataType, + /* [annotation] */ + _In_reads_bytes_(cb) const BYTE *pbInitData, + /* [annotation] */ + _In_ DWORD cb); + + HRESULT ( STDMETHODCALLTYPE *get_Expiration )( + IMFMediaKeySession2 * This, + /* [annotation] */ + _Out_ double *dblExpiration); + + HRESULT ( STDMETHODCALLTYPE *Remove )( + IMFMediaKeySession2 * This); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + IMFMediaKeySession2 * This); + + END_INTERFACE + } IMFMediaKeySession2Vtbl; + + interface IMFMediaKeySession2 + { + CONST_VTBL struct IMFMediaKeySession2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaKeySession2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaKeySession2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaKeySession2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaKeySession2_GetError(This,code,systemCode) \ + ( (This)->lpVtbl -> GetError(This,code,systemCode) ) + +#define IMFMediaKeySession2_get_KeySystem(This,keySystem) \ + ( (This)->lpVtbl -> get_KeySystem(This,keySystem) ) + +#define IMFMediaKeySession2_get_SessionId(This,sessionId) \ + ( (This)->lpVtbl -> get_SessionId(This,sessionId) ) + +#define IMFMediaKeySession2_Update(This,key,cb) \ + ( (This)->lpVtbl -> Update(This,key,cb) ) + +#define IMFMediaKeySession2_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + + +#define IMFMediaKeySession2_get_KeyStatuses(This,pKeyStatusesArray,puSize) \ + ( (This)->lpVtbl -> get_KeyStatuses(This,pKeyStatusesArray,puSize) ) + +#define IMFMediaKeySession2_Load(This,bstrSessionId,pfLoaded) \ + ( (This)->lpVtbl -> Load(This,bstrSessionId,pfLoaded) ) + +#define IMFMediaKeySession2_GenerateRequest(This,initDataType,pbInitData,cb) \ + ( (This)->lpVtbl -> GenerateRequest(This,initDataType,pbInitData,cb) ) + +#define IMFMediaKeySession2_get_Expiration(This,dblExpiration) \ + ( (This)->lpVtbl -> get_Expiration(This,dblExpiration) ) + +#define IMFMediaKeySession2_Remove(This) \ + ( (This)->lpVtbl -> Remove(This) ) + +#define IMFMediaKeySession2_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaKeySession2_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfmediaengine_0000_0050 */ +/* [local] */ + +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion + + +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0050_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfmediaengine_0000_0050_v0_0_s_ifspec; + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/util/test/demos/dx/official/mfobjects.h b/util/test/demos/dx/official/mfobjects.h new file mode 100644 index 000000000..8d5a433af --- /dev/null +++ b/util/test/demos/dx/official/mfobjects.h @@ -0,0 +1,6630 @@ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0622 */ +/* @@MIDL_FILE_HEADING( ) */ + + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCSAL_H_VERSION__ +#define __REQUIRED_RPCSAL_H_VERSION__ 100 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + +#ifndef COM_NO_WINDOWS_H +#include "windows.h" +#include "ole2.h" +#endif /*COM_NO_WINDOWS_H*/ + +#ifndef __mfobjects_h__ +#define __mfobjects_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +/* Forward Declarations */ + +#ifndef __IMFAttributes_FWD_DEFINED__ +#define __IMFAttributes_FWD_DEFINED__ +typedef interface IMFAttributes IMFAttributes; + +#endif /* __IMFAttributes_FWD_DEFINED__ */ + + +#ifndef __IMFMediaBuffer_FWD_DEFINED__ +#define __IMFMediaBuffer_FWD_DEFINED__ +typedef interface IMFMediaBuffer IMFMediaBuffer; + +#endif /* __IMFMediaBuffer_FWD_DEFINED__ */ + + +#ifndef __IMFSample_FWD_DEFINED__ +#define __IMFSample_FWD_DEFINED__ +typedef interface IMFSample IMFSample; + +#endif /* __IMFSample_FWD_DEFINED__ */ + + +#ifndef __IMF2DBuffer_FWD_DEFINED__ +#define __IMF2DBuffer_FWD_DEFINED__ +typedef interface IMF2DBuffer IMF2DBuffer; + +#endif /* __IMF2DBuffer_FWD_DEFINED__ */ + + +#ifndef __IMF2DBuffer2_FWD_DEFINED__ +#define __IMF2DBuffer2_FWD_DEFINED__ +typedef interface IMF2DBuffer2 IMF2DBuffer2; + +#endif /* __IMF2DBuffer2_FWD_DEFINED__ */ + + +#ifndef __IMFDXGIBuffer_FWD_DEFINED__ +#define __IMFDXGIBuffer_FWD_DEFINED__ +typedef interface IMFDXGIBuffer IMFDXGIBuffer; + +#endif /* __IMFDXGIBuffer_FWD_DEFINED__ */ + + +#ifndef __IMFMediaType_FWD_DEFINED__ +#define __IMFMediaType_FWD_DEFINED__ +typedef interface IMFMediaType IMFMediaType; + +#endif /* __IMFMediaType_FWD_DEFINED__ */ + + +#ifndef __IMFAudioMediaType_FWD_DEFINED__ +#define __IMFAudioMediaType_FWD_DEFINED__ +typedef interface IMFAudioMediaType IMFAudioMediaType; + +#endif /* __IMFAudioMediaType_FWD_DEFINED__ */ + + +#ifndef __IMFVideoMediaType_FWD_DEFINED__ +#define __IMFVideoMediaType_FWD_DEFINED__ +typedef interface IMFVideoMediaType IMFVideoMediaType; + +#endif /* __IMFVideoMediaType_FWD_DEFINED__ */ + + +#ifndef __IMFAsyncResult_FWD_DEFINED__ +#define __IMFAsyncResult_FWD_DEFINED__ +typedef interface IMFAsyncResult IMFAsyncResult; + +#endif /* __IMFAsyncResult_FWD_DEFINED__ */ + + +#ifndef __IMFAsyncCallback_FWD_DEFINED__ +#define __IMFAsyncCallback_FWD_DEFINED__ +typedef interface IMFAsyncCallback IMFAsyncCallback; + +#endif /* __IMFAsyncCallback_FWD_DEFINED__ */ + + +#ifndef __IMFAsyncCallbackLogging_FWD_DEFINED__ +#define __IMFAsyncCallbackLogging_FWD_DEFINED__ +typedef interface IMFAsyncCallbackLogging IMFAsyncCallbackLogging; + +#endif /* __IMFAsyncCallbackLogging_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEvent_FWD_DEFINED__ +#define __IMFMediaEvent_FWD_DEFINED__ +typedef interface IMFMediaEvent IMFMediaEvent; + +#endif /* __IMFMediaEvent_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEventGenerator_FWD_DEFINED__ +#define __IMFMediaEventGenerator_FWD_DEFINED__ +typedef interface IMFMediaEventGenerator IMFMediaEventGenerator; + +#endif /* __IMFMediaEventGenerator_FWD_DEFINED__ */ + + +#ifndef __IMFRemoteAsyncCallback_FWD_DEFINED__ +#define __IMFRemoteAsyncCallback_FWD_DEFINED__ +typedef interface IMFRemoteAsyncCallback IMFRemoteAsyncCallback; + +#endif /* __IMFRemoteAsyncCallback_FWD_DEFINED__ */ + + +#ifndef __IMFByteStream_FWD_DEFINED__ +#define __IMFByteStream_FWD_DEFINED__ +typedef interface IMFByteStream IMFByteStream; + +#endif /* __IMFByteStream_FWD_DEFINED__ */ + + +#ifndef __IMFByteStreamProxyClassFactory_FWD_DEFINED__ +#define __IMFByteStreamProxyClassFactory_FWD_DEFINED__ +typedef interface IMFByteStreamProxyClassFactory IMFByteStreamProxyClassFactory; + +#endif /* __IMFByteStreamProxyClassFactory_FWD_DEFINED__ */ + + +#ifndef __IMFSampleOutputStream_FWD_DEFINED__ +#define __IMFSampleOutputStream_FWD_DEFINED__ +typedef interface IMFSampleOutputStream IMFSampleOutputStream; + +#endif /* __IMFSampleOutputStream_FWD_DEFINED__ */ + + +#ifndef __IMFCollection_FWD_DEFINED__ +#define __IMFCollection_FWD_DEFINED__ +typedef interface IMFCollection IMFCollection; + +#endif /* __IMFCollection_FWD_DEFINED__ */ + + +#ifndef __IMFMediaEventQueue_FWD_DEFINED__ +#define __IMFMediaEventQueue_FWD_DEFINED__ +typedef interface IMFMediaEventQueue IMFMediaEventQueue; + +#endif /* __IMFMediaEventQueue_FWD_DEFINED__ */ + + +#ifndef __IMFActivate_FWD_DEFINED__ +#define __IMFActivate_FWD_DEFINED__ +typedef interface IMFActivate IMFActivate; + +#endif /* __IMFActivate_FWD_DEFINED__ */ + + +#ifndef __IMFPluginControl_FWD_DEFINED__ +#define __IMFPluginControl_FWD_DEFINED__ +typedef interface IMFPluginControl IMFPluginControl; + +#endif /* __IMFPluginControl_FWD_DEFINED__ */ + + +#ifndef __IMFPluginControl2_FWD_DEFINED__ +#define __IMFPluginControl2_FWD_DEFINED__ +typedef interface IMFPluginControl2 IMFPluginControl2; + +#endif /* __IMFPluginControl2_FWD_DEFINED__ */ + + +#ifndef __IMFDXGIDeviceManager_FWD_DEFINED__ +#define __IMFDXGIDeviceManager_FWD_DEFINED__ +typedef interface IMFDXGIDeviceManager IMFDXGIDeviceManager; + +#endif /* __IMFDXGIDeviceManager_FWD_DEFINED__ */ + + +#ifndef __IMFMuxStreamAttributesManager_FWD_DEFINED__ +#define __IMFMuxStreamAttributesManager_FWD_DEFINED__ +typedef interface IMFMuxStreamAttributesManager IMFMuxStreamAttributesManager; + +#endif /* __IMFMuxStreamAttributesManager_FWD_DEFINED__ */ + + +#ifndef __IMFMuxStreamMediaTypeManager_FWD_DEFINED__ +#define __IMFMuxStreamMediaTypeManager_FWD_DEFINED__ +typedef interface IMFMuxStreamMediaTypeManager IMFMuxStreamMediaTypeManager; + +#endif /* __IMFMuxStreamMediaTypeManager_FWD_DEFINED__ */ + + +#ifndef __IMFMuxStreamSampleManager_FWD_DEFINED__ +#define __IMFMuxStreamSampleManager_FWD_DEFINED__ +typedef interface IMFMuxStreamSampleManager IMFMuxStreamSampleManager; + +#endif /* __IMFMuxStreamSampleManager_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "unknwn.h" +//#include "propsys.h" +//#include "mediaobj.h" +//#include "mmreg.h" + +#ifdef __cplusplus +extern "C"{ +#endif + + +/* interface __MIDL_itf_mfobjects_0000_0000 */ +/* [local] */ + +#include "winapifamily.h" +typedef ULONGLONG QWORD; + +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef +enum _MF_ATTRIBUTE_TYPE + { + MF_ATTRIBUTE_UINT32 = VT_UI4, + MF_ATTRIBUTE_UINT64 = VT_UI8, + MF_ATTRIBUTE_DOUBLE = VT_R8, + MF_ATTRIBUTE_GUID = VT_CLSID, + MF_ATTRIBUTE_STRING = VT_LPWSTR, + MF_ATTRIBUTE_BLOB = ( VT_VECTOR | VT_UI1 ) , + MF_ATTRIBUTE_IUNKNOWN = VT_UNKNOWN + } MF_ATTRIBUTE_TYPE; + +typedef +enum _MF_ATTRIBUTES_MATCH_TYPE + { + MF_ATTRIBUTES_MATCH_OUR_ITEMS = 0, + MF_ATTRIBUTES_MATCH_THEIR_ITEMS = 1, + MF_ATTRIBUTES_MATCH_ALL_ITEMS = 2, + MF_ATTRIBUTES_MATCH_INTERSECTION = 3, + MF_ATTRIBUTES_MATCH_SMALLER = 4 + } MF_ATTRIBUTES_MATCH_TYPE; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0000_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0000_v0_0_s_ifspec; + +#ifndef __IMFAttributes_INTERFACE_DEFINED__ +#define __IMFAttributes_INTERFACE_DEFINED__ + +/* interface IMFAttributes */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFAttributes; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2cd2d921-c447-44a7-a13c-4adabfc247e3") + IMFAttributes : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetItem( + __RPC__in REFGUID guidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetItemType( + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out MF_ATTRIBUTE_TYPE *pType) = 0; + + virtual HRESULT STDMETHODCALLTYPE CompareItem( + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value, + /* [out] */ __RPC__out BOOL *pbResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE Compare( + __RPC__in_opt IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ __RPC__out BOOL *pbResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetUINT32( + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *punValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetUINT64( + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT64 *punValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDouble( + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out double *pfValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetGUID( + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out GUID *pguidValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStringLength( + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcchLength) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetString( + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cchBufSize) LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcchLength) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAllocatedString( + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(( *pcchLength + 1 ) ) LPWSTR *ppwszValue, + /* [out] */ __RPC__out UINT32 *pcchLength) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBlobSize( + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcbBlobSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBlob( + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cbBufSize) UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcbBlobSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAllocatedBlob( + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbSize) UINT8 **ppBuf, + /* [out] */ __RPC__out UINT32 *pcbSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetUnknown( + __RPC__in REFGUID guidKey, + __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppv) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetItem( + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeleteItem( + __RPC__in REFGUID guidKey) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeleteAllItems( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetUINT32( + __RPC__in REFGUID guidKey, + UINT32 unValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetUINT64( + __RPC__in REFGUID guidKey, + UINT64 unValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDouble( + __RPC__in REFGUID guidKey, + double fValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetGUID( + __RPC__in REFGUID guidKey, + __RPC__in REFGUID guidValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetString( + __RPC__in REFGUID guidKey, + /* [string][in] */ __RPC__in_string LPCWSTR wszValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetBlob( + __RPC__in REFGUID guidKey, + /* [size_is][in] */ __RPC__in_ecount_full(cbBufSize) const UINT8 *pBuf, + UINT32 cbBufSize) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetUnknown( + __RPC__in REFGUID guidKey, + /* [in] */ __RPC__in_opt IUnknown *pUnknown) = 0; + + virtual HRESULT STDMETHODCALLTYPE LockStore( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnlockStore( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCount( + /* [out] */ __RPC__out UINT32 *pcItems) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetItemByIndex( + UINT32 unIndex, + /* [out] */ __RPC__out GUID *pguidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE CopyAllItems( + /* [in] */ __RPC__in_opt IMFAttributes *pDest) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFAttributesVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFAttributes * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFAttributes * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFAttributes * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + __RPC__in IMFAttributes * This, + __RPC__in_opt IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cchBufSize) LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(( *pcchLength + 1 ) ) LPWSTR *ppwszValue, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cbBufSize) UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbSize) UINT8 **ppBuf, + /* [out] */ __RPC__out UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + __RPC__in IMFAttributes * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + __RPC__in REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [string][in] */ __RPC__in_string LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [size_is][in] */ __RPC__in_ecount_full(cbBufSize) const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + __RPC__in IMFAttributes * This, + __RPC__in REFGUID guidKey, + /* [in] */ __RPC__in_opt IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + __RPC__in IMFAttributes * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + __RPC__in IMFAttributes * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + __RPC__in IMFAttributes * This, + /* [out] */ __RPC__out UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + __RPC__in IMFAttributes * This, + UINT32 unIndex, + /* [out] */ __RPC__out GUID *pguidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + __RPC__in IMFAttributes * This, + /* [in] */ __RPC__in_opt IMFAttributes *pDest); + + END_INTERFACE + } IMFAttributesVtbl; + + interface IMFAttributes + { + CONST_VTBL struct IMFAttributesVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFAttributes_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFAttributes_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFAttributes_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFAttributes_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFAttributes_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFAttributes_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFAttributes_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFAttributes_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFAttributes_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFAttributes_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFAttributes_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFAttributes_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFAttributes_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFAttributes_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFAttributes_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFAttributes_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFAttributes_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFAttributes_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFAttributes_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFAttributes_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFAttributes_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFAttributes_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFAttributes_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFAttributes_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFAttributes_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFAttributes_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFAttributes_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFAttributes_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFAttributes_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFAttributes_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFAttributes_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFAttributes_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFAttributes_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFAttributes_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0001 */ +/* [local] */ + + +enum MF_ATTRIBUTE_SERIALIZE_OPTIONS + { + MF_ATTRIBUTE_SERIALIZE_UNKNOWN_BYREF = 0x1 + } ; +STDAPI MFSerializeAttributesToStream( + IMFAttributes * pAttr, + DWORD dwOptions, + IStream * pStm); +STDAPI MFDeserializeAttributesFromStream( + IMFAttributes * pAttr, + DWORD dwOptions, + IStream * pStm); + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0001_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0001_v0_0_s_ifspec; + +#ifndef __IMFMediaBuffer_INTERFACE_DEFINED__ +#define __IMFMediaBuffer_INTERFACE_DEFINED__ + +/* interface IMFMediaBuffer */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaBuffer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("045FA593-8799-42b8-BC8D-8968C6453507") + IMFMediaBuffer : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Lock( + /* [annotation][out] */ + _Outptr_result_bytebuffer_to_(*pcbMaxLength, *pcbCurrentLength) BYTE **ppbBuffer, + /* [annotation][out] */ + _Out_opt_ DWORD *pcbMaxLength, + /* [annotation][out] */ + _Out_opt_ DWORD *pcbCurrentLength) = 0; + + virtual HRESULT STDMETHODCALLTYPE Unlock( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentLength( + /* [annotation][out] */ + _Out_ DWORD *pcbCurrentLength) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCurrentLength( + /* [in] */ DWORD cbCurrentLength) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMaxLength( + /* [annotation][out] */ + _Out_ DWORD *pcbMaxLength) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaBufferVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaBuffer * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaBuffer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaBuffer * This); + + HRESULT ( STDMETHODCALLTYPE *Lock )( + IMFMediaBuffer * This, + /* [annotation][out] */ + _Outptr_result_bytebuffer_to_(*pcbMaxLength, *pcbCurrentLength) BYTE **ppbBuffer, + /* [annotation][out] */ + _Out_opt_ DWORD *pcbMaxLength, + /* [annotation][out] */ + _Out_opt_ DWORD *pcbCurrentLength); + + HRESULT ( STDMETHODCALLTYPE *Unlock )( + IMFMediaBuffer * This); + + HRESULT ( STDMETHODCALLTYPE *GetCurrentLength )( + IMFMediaBuffer * This, + /* [annotation][out] */ + _Out_ DWORD *pcbCurrentLength); + + HRESULT ( STDMETHODCALLTYPE *SetCurrentLength )( + IMFMediaBuffer * This, + /* [in] */ DWORD cbCurrentLength); + + HRESULT ( STDMETHODCALLTYPE *GetMaxLength )( + IMFMediaBuffer * This, + /* [annotation][out] */ + _Out_ DWORD *pcbMaxLength); + + END_INTERFACE + } IMFMediaBufferVtbl; + + interface IMFMediaBuffer + { + CONST_VTBL struct IMFMediaBufferVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaBuffer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaBuffer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaBuffer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaBuffer_Lock(This,ppbBuffer,pcbMaxLength,pcbCurrentLength) \ + ( (This)->lpVtbl -> Lock(This,ppbBuffer,pcbMaxLength,pcbCurrentLength) ) + +#define IMFMediaBuffer_Unlock(This) \ + ( (This)->lpVtbl -> Unlock(This) ) + +#define IMFMediaBuffer_GetCurrentLength(This,pcbCurrentLength) \ + ( (This)->lpVtbl -> GetCurrentLength(This,pcbCurrentLength) ) + +#define IMFMediaBuffer_SetCurrentLength(This,cbCurrentLength) \ + ( (This)->lpVtbl -> SetCurrentLength(This,cbCurrentLength) ) + +#define IMFMediaBuffer_GetMaxLength(This,pcbMaxLength) \ + ( (This)->lpVtbl -> GetMaxLength(This,pcbMaxLength) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaBuffer_INTERFACE_DEFINED__ */ + + +#ifndef __IMFSample_INTERFACE_DEFINED__ +#define __IMFSample_INTERFACE_DEFINED__ + +/* interface IMFSample */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFSample; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c40a00f2-b93a-4d80-ae8c-5a1c634f58e4") + IMFSample : public IMFAttributes + { + public: + virtual HRESULT STDMETHODCALLTYPE GetSampleFlags( + /* [annotation][out] */ + _Out_ DWORD *pdwSampleFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSampleFlags( + /* [in] */ DWORD dwSampleFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSampleTime( + /* [annotation][out] */ + _Out_ LONGLONG *phnsSampleTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSampleTime( + /* [in] */ LONGLONG hnsSampleTime) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSampleDuration( + /* [annotation][out] */ + _Out_ LONGLONG *phnsSampleDuration) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetSampleDuration( + /* [in] */ LONGLONG hnsSampleDuration) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferCount( + /* [annotation][out] */ + _Out_ DWORD *pdwBufferCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetBufferByIndex( + /* [in] */ DWORD dwIndex, + /* [annotation][out] */ + _Out_ IMFMediaBuffer **ppBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE ConvertToContiguousBuffer( + /* [annotation][out] */ + _Out_ IMFMediaBuffer **ppBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddBuffer( + /* [in] */ IMFMediaBuffer *pBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveBufferByIndex( + /* [in] */ DWORD dwIndex) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveAllBuffers( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetTotalLength( + /* [annotation][out] */ + _Out_ DWORD *pcbTotalLength) = 0; + + virtual HRESULT STDMETHODCALLTYPE CopyToBuffer( + /* [in] */ IMFMediaBuffer *pBuffer) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSampleVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFSample * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFSample * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFSample * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + IMFSample * This, + REFGUID guidKey, + /* [full][out][in] */ PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + IMFSample * This, + REFGUID guidKey, + /* [out] */ MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + IMFSample * This, + REFGUID guidKey, + REFPROPVARIANT Value, + /* [out] */ BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + IMFSample * This, + IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + IMFSample * This, + REFGUID guidKey, + /* [out] */ UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + IMFSample * This, + REFGUID guidKey, + /* [out] */ UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + IMFSample * This, + REFGUID guidKey, + /* [out] */ double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + IMFSample * This, + REFGUID guidKey, + /* [out] */ GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + IMFSample * This, + REFGUID guidKey, + /* [out] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IMFSample * This, + REFGUID guidKey, + /* [size_is][out] */ LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + IMFSample * This, + REFGUID guidKey, + /* [size_is][size_is][out] */ LPWSTR *ppwszValue, + /* [out] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + IMFSample * This, + REFGUID guidKey, + /* [out] */ UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + IMFSample * This, + REFGUID guidKey, + /* [size_is][out] */ UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + IMFSample * This, + REFGUID guidKey, + /* [size_is][size_is][out] */ UINT8 **ppBuf, + /* [out] */ UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + IMFSample * This, + REFGUID guidKey, + REFIID riid, + /* [iid_is][out] */ LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + IMFSample * This, + REFGUID guidKey, + REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + IMFSample * This, + REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + IMFSample * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + IMFSample * This, + REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + IMFSample * This, + REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + IMFSample * This, + REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + IMFSample * This, + REFGUID guidKey, + REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + IMFSample * This, + REFGUID guidKey, + /* [string][in] */ LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + IMFSample * This, + REFGUID guidKey, + /* [size_is][in] */ const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + IMFSample * This, + REFGUID guidKey, + /* [in] */ IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + IMFSample * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + IMFSample * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + IMFSample * This, + /* [out] */ UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + IMFSample * This, + UINT32 unIndex, + /* [out] */ GUID *pguidKey, + /* [full][out][in] */ PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + IMFSample * This, + /* [in] */ IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *GetSampleFlags )( + IMFSample * This, + /* [annotation][out] */ + _Out_ DWORD *pdwSampleFlags); + + HRESULT ( STDMETHODCALLTYPE *SetSampleFlags )( + IMFSample * This, + /* [in] */ DWORD dwSampleFlags); + + HRESULT ( STDMETHODCALLTYPE *GetSampleTime )( + IMFSample * This, + /* [annotation][out] */ + _Out_ LONGLONG *phnsSampleTime); + + HRESULT ( STDMETHODCALLTYPE *SetSampleTime )( + IMFSample * This, + /* [in] */ LONGLONG hnsSampleTime); + + HRESULT ( STDMETHODCALLTYPE *GetSampleDuration )( + IMFSample * This, + /* [annotation][out] */ + _Out_ LONGLONG *phnsSampleDuration); + + HRESULT ( STDMETHODCALLTYPE *SetSampleDuration )( + IMFSample * This, + /* [in] */ LONGLONG hnsSampleDuration); + + HRESULT ( STDMETHODCALLTYPE *GetBufferCount )( + IMFSample * This, + /* [annotation][out] */ + _Out_ DWORD *pdwBufferCount); + + HRESULT ( STDMETHODCALLTYPE *GetBufferByIndex )( + IMFSample * This, + /* [in] */ DWORD dwIndex, + /* [annotation][out] */ + _Out_ IMFMediaBuffer **ppBuffer); + + HRESULT ( STDMETHODCALLTYPE *ConvertToContiguousBuffer )( + IMFSample * This, + /* [annotation][out] */ + _Out_ IMFMediaBuffer **ppBuffer); + + HRESULT ( STDMETHODCALLTYPE *AddBuffer )( + IMFSample * This, + /* [in] */ IMFMediaBuffer *pBuffer); + + HRESULT ( STDMETHODCALLTYPE *RemoveBufferByIndex )( + IMFSample * This, + /* [in] */ DWORD dwIndex); + + HRESULT ( STDMETHODCALLTYPE *RemoveAllBuffers )( + IMFSample * This); + + HRESULT ( STDMETHODCALLTYPE *GetTotalLength )( + IMFSample * This, + /* [annotation][out] */ + _Out_ DWORD *pcbTotalLength); + + HRESULT ( STDMETHODCALLTYPE *CopyToBuffer )( + IMFSample * This, + /* [in] */ IMFMediaBuffer *pBuffer); + + END_INTERFACE + } IMFSampleVtbl; + + interface IMFSample + { + CONST_VTBL struct IMFSampleVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSample_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSample_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSample_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSample_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFSample_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFSample_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFSample_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFSample_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFSample_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFSample_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFSample_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFSample_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFSample_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFSample_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFSample_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFSample_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFSample_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFSample_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFSample_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFSample_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFSample_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFSample_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFSample_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFSample_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFSample_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFSample_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFSample_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFSample_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFSample_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFSample_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFSample_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFSample_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFSample_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFSample_GetSampleFlags(This,pdwSampleFlags) \ + ( (This)->lpVtbl -> GetSampleFlags(This,pdwSampleFlags) ) + +#define IMFSample_SetSampleFlags(This,dwSampleFlags) \ + ( (This)->lpVtbl -> SetSampleFlags(This,dwSampleFlags) ) + +#define IMFSample_GetSampleTime(This,phnsSampleTime) \ + ( (This)->lpVtbl -> GetSampleTime(This,phnsSampleTime) ) + +#define IMFSample_SetSampleTime(This,hnsSampleTime) \ + ( (This)->lpVtbl -> SetSampleTime(This,hnsSampleTime) ) + +#define IMFSample_GetSampleDuration(This,phnsSampleDuration) \ + ( (This)->lpVtbl -> GetSampleDuration(This,phnsSampleDuration) ) + +#define IMFSample_SetSampleDuration(This,hnsSampleDuration) \ + ( (This)->lpVtbl -> SetSampleDuration(This,hnsSampleDuration) ) + +#define IMFSample_GetBufferCount(This,pdwBufferCount) \ + ( (This)->lpVtbl -> GetBufferCount(This,pdwBufferCount) ) + +#define IMFSample_GetBufferByIndex(This,dwIndex,ppBuffer) \ + ( (This)->lpVtbl -> GetBufferByIndex(This,dwIndex,ppBuffer) ) + +#define IMFSample_ConvertToContiguousBuffer(This,ppBuffer) \ + ( (This)->lpVtbl -> ConvertToContiguousBuffer(This,ppBuffer) ) + +#define IMFSample_AddBuffer(This,pBuffer) \ + ( (This)->lpVtbl -> AddBuffer(This,pBuffer) ) + +#define IMFSample_RemoveBufferByIndex(This,dwIndex) \ + ( (This)->lpVtbl -> RemoveBufferByIndex(This,dwIndex) ) + +#define IMFSample_RemoveAllBuffers(This) \ + ( (This)->lpVtbl -> RemoveAllBuffers(This) ) + +#define IMFSample_GetTotalLength(This,pcbTotalLength) \ + ( (This)->lpVtbl -> GetTotalLength(This,pcbTotalLength) ) + +#define IMFSample_CopyToBuffer(This,pBuffer) \ + ( (This)->lpVtbl -> CopyToBuffer(This,pBuffer) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSample_INTERFACE_DEFINED__ */ + + +#ifndef __IMF2DBuffer_INTERFACE_DEFINED__ +#define __IMF2DBuffer_INTERFACE_DEFINED__ + +/* interface IMF2DBuffer */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMF2DBuffer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7DC9D5F9-9ED9-44ec-9BBF-0600BB589FBB") + IMF2DBuffer : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Lock2D( + /* [annotation][out] */ + _Outptr_result_bytebuffer_(_Inexpressible_(ComputePlaneSize(*plPitch))) BYTE **ppbScanline0, + /* [annotation][out] */ + _Out_ LONG *plPitch) = 0; + + virtual HRESULT STDMETHODCALLTYPE Unlock2D( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetScanline0AndPitch( + /* [annotation][out] */ + _Out_ BYTE **pbScanline0, + /* [annotation][out] */ + _Out_ LONG *plPitch) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsContiguousFormat( + /* [annotation][out] */ + _Out_ BOOL *pfIsContiguous) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetContiguousLength( + /* [annotation][out] */ + _Out_ DWORD *pcbLength) = 0; + + virtual HRESULT STDMETHODCALLTYPE ContiguousCopyTo( + /* [annotation][size_is][out] */ + _Out_writes_bytes_(cbDestBuffer) BYTE *pbDestBuffer, + /* [in] */ DWORD cbDestBuffer) = 0; + + virtual HRESULT STDMETHODCALLTYPE ContiguousCopyFrom( + /* [annotation][size_is][in] */ + _In_reads_bytes_(cbSrcBuffer) const BYTE *pbSrcBuffer, + /* [in] */ DWORD cbSrcBuffer) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMF2DBufferVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMF2DBuffer * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMF2DBuffer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMF2DBuffer * This); + + HRESULT ( STDMETHODCALLTYPE *Lock2D )( + IMF2DBuffer * This, + /* [annotation][out] */ + _Outptr_result_bytebuffer_(_Inexpressible_(ComputePlaneSize(*plPitch))) BYTE **ppbScanline0, + /* [annotation][out] */ + _Out_ LONG *plPitch); + + HRESULT ( STDMETHODCALLTYPE *Unlock2D )( + IMF2DBuffer * This); + + HRESULT ( STDMETHODCALLTYPE *GetScanline0AndPitch )( + IMF2DBuffer * This, + /* [annotation][out] */ + _Out_ BYTE **pbScanline0, + /* [annotation][out] */ + _Out_ LONG *plPitch); + + HRESULT ( STDMETHODCALLTYPE *IsContiguousFormat )( + IMF2DBuffer * This, + /* [annotation][out] */ + _Out_ BOOL *pfIsContiguous); + + HRESULT ( STDMETHODCALLTYPE *GetContiguousLength )( + IMF2DBuffer * This, + /* [annotation][out] */ + _Out_ DWORD *pcbLength); + + HRESULT ( STDMETHODCALLTYPE *ContiguousCopyTo )( + IMF2DBuffer * This, + /* [annotation][size_is][out] */ + _Out_writes_bytes_(cbDestBuffer) BYTE *pbDestBuffer, + /* [in] */ DWORD cbDestBuffer); + + HRESULT ( STDMETHODCALLTYPE *ContiguousCopyFrom )( + IMF2DBuffer * This, + /* [annotation][size_is][in] */ + _In_reads_bytes_(cbSrcBuffer) const BYTE *pbSrcBuffer, + /* [in] */ DWORD cbSrcBuffer); + + END_INTERFACE + } IMF2DBufferVtbl; + + interface IMF2DBuffer + { + CONST_VTBL struct IMF2DBufferVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMF2DBuffer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMF2DBuffer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMF2DBuffer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMF2DBuffer_Lock2D(This,ppbScanline0,plPitch) \ + ( (This)->lpVtbl -> Lock2D(This,ppbScanline0,plPitch) ) + +#define IMF2DBuffer_Unlock2D(This) \ + ( (This)->lpVtbl -> Unlock2D(This) ) + +#define IMF2DBuffer_GetScanline0AndPitch(This,pbScanline0,plPitch) \ + ( (This)->lpVtbl -> GetScanline0AndPitch(This,pbScanline0,plPitch) ) + +#define IMF2DBuffer_IsContiguousFormat(This,pfIsContiguous) \ + ( (This)->lpVtbl -> IsContiguousFormat(This,pfIsContiguous) ) + +#define IMF2DBuffer_GetContiguousLength(This,pcbLength) \ + ( (This)->lpVtbl -> GetContiguousLength(This,pcbLength) ) + +#define IMF2DBuffer_ContiguousCopyTo(This,pbDestBuffer,cbDestBuffer) \ + ( (This)->lpVtbl -> ContiguousCopyTo(This,pbDestBuffer,cbDestBuffer) ) + +#define IMF2DBuffer_ContiguousCopyFrom(This,pbSrcBuffer,cbSrcBuffer) \ + ( (This)->lpVtbl -> ContiguousCopyFrom(This,pbSrcBuffer,cbSrcBuffer) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMF2DBuffer_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0004 */ +/* [local] */ + +typedef +enum _MF2DBuffer_LockFlags + { + MF2DBuffer_LockFlags_LockTypeMask = ( ( 0x1 | 0x2 ) | 0x3 ) , + MF2DBuffer_LockFlags_Read = 0x1, + MF2DBuffer_LockFlags_Write = 0x2, + MF2DBuffer_LockFlags_ReadWrite = 0x3, + MF2DBuffer_LockFlags_ForceDWORD = 0x7fffffff + } MF2DBuffer_LockFlags; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0004_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0004_v0_0_s_ifspec; + +#ifndef __IMF2DBuffer2_INTERFACE_DEFINED__ +#define __IMF2DBuffer2_INTERFACE_DEFINED__ + +/* interface IMF2DBuffer2 */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMF2DBuffer2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("33ae5ea6-4316-436f-8ddd-d73d22f829ec") + IMF2DBuffer2 : public IMF2DBuffer + { + public: + virtual HRESULT STDMETHODCALLTYPE Lock2DSize( + /* [annotation][in] */ + _In_ MF2DBuffer_LockFlags lockFlags, + /* [annotation][out] */ + _Outptr_result_bytebuffer_(_Inexpressible_(ComputePlaneSize(*plPitch))) BYTE **ppbScanline0, + /* [annotation][out] */ + _Out_ LONG *plPitch, + /* [annotation][out] */ + _Outptr_result_bytebuffer_(*pcbBufferLength) BYTE **ppbBufferStart, + /* [annotation][out] */ + _Out_ DWORD *pcbBufferLength) = 0; + + virtual HRESULT STDMETHODCALLTYPE Copy2DTo( + /* [annotation][in] */ + _In_ IMF2DBuffer2 *pDestBuffer) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMF2DBuffer2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMF2DBuffer2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMF2DBuffer2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMF2DBuffer2 * This); + + HRESULT ( STDMETHODCALLTYPE *Lock2D )( + IMF2DBuffer2 * This, + /* [annotation][out] */ + _Outptr_result_bytebuffer_(_Inexpressible_(ComputePlaneSize(*plPitch))) BYTE **ppbScanline0, + /* [annotation][out] */ + _Out_ LONG *plPitch); + + HRESULT ( STDMETHODCALLTYPE *Unlock2D )( + IMF2DBuffer2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetScanline0AndPitch )( + IMF2DBuffer2 * This, + /* [annotation][out] */ + _Out_ BYTE **pbScanline0, + /* [annotation][out] */ + _Out_ LONG *plPitch); + + HRESULT ( STDMETHODCALLTYPE *IsContiguousFormat )( + IMF2DBuffer2 * This, + /* [annotation][out] */ + _Out_ BOOL *pfIsContiguous); + + HRESULT ( STDMETHODCALLTYPE *GetContiguousLength )( + IMF2DBuffer2 * This, + /* [annotation][out] */ + _Out_ DWORD *pcbLength); + + HRESULT ( STDMETHODCALLTYPE *ContiguousCopyTo )( + IMF2DBuffer2 * This, + /* [annotation][size_is][out] */ + _Out_writes_bytes_(cbDestBuffer) BYTE *pbDestBuffer, + /* [in] */ DWORD cbDestBuffer); + + HRESULT ( STDMETHODCALLTYPE *ContiguousCopyFrom )( + IMF2DBuffer2 * This, + /* [annotation][size_is][in] */ + _In_reads_bytes_(cbSrcBuffer) const BYTE *pbSrcBuffer, + /* [in] */ DWORD cbSrcBuffer); + + HRESULT ( STDMETHODCALLTYPE *Lock2DSize )( + IMF2DBuffer2 * This, + /* [annotation][in] */ + _In_ MF2DBuffer_LockFlags lockFlags, + /* [annotation][out] */ + _Outptr_result_bytebuffer_(_Inexpressible_(ComputePlaneSize(*plPitch))) BYTE **ppbScanline0, + /* [annotation][out] */ + _Out_ LONG *plPitch, + /* [annotation][out] */ + _Outptr_result_bytebuffer_(*pcbBufferLength) BYTE **ppbBufferStart, + /* [annotation][out] */ + _Out_ DWORD *pcbBufferLength); + + HRESULT ( STDMETHODCALLTYPE *Copy2DTo )( + IMF2DBuffer2 * This, + /* [annotation][in] */ + _In_ IMF2DBuffer2 *pDestBuffer); + + END_INTERFACE + } IMF2DBuffer2Vtbl; + + interface IMF2DBuffer2 + { + CONST_VTBL struct IMF2DBuffer2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMF2DBuffer2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMF2DBuffer2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMF2DBuffer2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMF2DBuffer2_Lock2D(This,ppbScanline0,plPitch) \ + ( (This)->lpVtbl -> Lock2D(This,ppbScanline0,plPitch) ) + +#define IMF2DBuffer2_Unlock2D(This) \ + ( (This)->lpVtbl -> Unlock2D(This) ) + +#define IMF2DBuffer2_GetScanline0AndPitch(This,pbScanline0,plPitch) \ + ( (This)->lpVtbl -> GetScanline0AndPitch(This,pbScanline0,plPitch) ) + +#define IMF2DBuffer2_IsContiguousFormat(This,pfIsContiguous) \ + ( (This)->lpVtbl -> IsContiguousFormat(This,pfIsContiguous) ) + +#define IMF2DBuffer2_GetContiguousLength(This,pcbLength) \ + ( (This)->lpVtbl -> GetContiguousLength(This,pcbLength) ) + +#define IMF2DBuffer2_ContiguousCopyTo(This,pbDestBuffer,cbDestBuffer) \ + ( (This)->lpVtbl -> ContiguousCopyTo(This,pbDestBuffer,cbDestBuffer) ) + +#define IMF2DBuffer2_ContiguousCopyFrom(This,pbSrcBuffer,cbSrcBuffer) \ + ( (This)->lpVtbl -> ContiguousCopyFrom(This,pbSrcBuffer,cbSrcBuffer) ) + + +#define IMF2DBuffer2_Lock2DSize(This,lockFlags,ppbScanline0,plPitch,ppbBufferStart,pcbBufferLength) \ + ( (This)->lpVtbl -> Lock2DSize(This,lockFlags,ppbScanline0,plPitch,ppbBufferStart,pcbBufferLength) ) + +#define IMF2DBuffer2_Copy2DTo(This,pDestBuffer) \ + ( (This)->lpVtbl -> Copy2DTo(This,pDestBuffer) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMF2DBuffer2_INTERFACE_DEFINED__ */ + + +#ifndef __IMFDXGIBuffer_INTERFACE_DEFINED__ +#define __IMFDXGIBuffer_INTERFACE_DEFINED__ + +/* interface IMFDXGIBuffer */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFDXGIBuffer; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("e7174cfa-1c9e-48b1-8866-626226bfc258") + IMFDXGIBuffer : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetResource( + /* [annotation][in] */ + _In_ REFIID riid, + /* [annotation][out] */ + _Outptr_ LPVOID *ppvObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSubresourceIndex( + /* [annotation][out] */ + _Out_ UINT *puSubresource) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetUnknown( + /* [annotation][in] */ + _In_ REFIID guid, + /* [annotation][in] */ + _In_ REFIID riid, + /* [annotation][out] */ + _Outptr_ LPVOID *ppvObject) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetUnknown( + /* [annotation][in] */ + _In_ REFIID guid, + /* [annotation][in] */ + _In_opt_ IUnknown *pUnkData) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFDXGIBufferVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFDXGIBuffer * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFDXGIBuffer * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFDXGIBuffer * This); + + HRESULT ( STDMETHODCALLTYPE *GetResource )( + IMFDXGIBuffer * This, + /* [annotation][in] */ + _In_ REFIID riid, + /* [annotation][out] */ + _Outptr_ LPVOID *ppvObject); + + HRESULT ( STDMETHODCALLTYPE *GetSubresourceIndex )( + IMFDXGIBuffer * This, + /* [annotation][out] */ + _Out_ UINT *puSubresource); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + IMFDXGIBuffer * This, + /* [annotation][in] */ + _In_ REFIID guid, + /* [annotation][in] */ + _In_ REFIID riid, + /* [annotation][out] */ + _Outptr_ LPVOID *ppvObject); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + IMFDXGIBuffer * This, + /* [annotation][in] */ + _In_ REFIID guid, + /* [annotation][in] */ + _In_opt_ IUnknown *pUnkData); + + END_INTERFACE + } IMFDXGIBufferVtbl; + + interface IMFDXGIBuffer + { + CONST_VTBL struct IMFDXGIBufferVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFDXGIBuffer_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFDXGIBuffer_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFDXGIBuffer_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFDXGIBuffer_GetResource(This,riid,ppvObject) \ + ( (This)->lpVtbl -> GetResource(This,riid,ppvObject) ) + +#define IMFDXGIBuffer_GetSubresourceIndex(This,puSubresource) \ + ( (This)->lpVtbl -> GetSubresourceIndex(This,puSubresource) ) + +#define IMFDXGIBuffer_GetUnknown(This,guid,riid,ppvObject) \ + ( (This)->lpVtbl -> GetUnknown(This,guid,riid,ppvObject) ) + +#define IMFDXGIBuffer_SetUnknown(This,guid,pUnkData) \ + ( (This)->lpVtbl -> SetUnknown(This,guid,pUnkData) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFDXGIBuffer_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaType_INTERFACE_DEFINED__ +#define __IMFMediaType_INTERFACE_DEFINED__ + +/* interface IMFMediaType */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaType; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("44ae0fa8-ea31-4109-8d2e-4cae4997c555") + IMFMediaType : public IMFAttributes + { + public: + virtual HRESULT STDMETHODCALLTYPE GetMajorType( + /* [out] */ __RPC__out GUID *pguidMajorType) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsCompressedFormat( + /* [out] */ __RPC__out BOOL *pfCompressed) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsEqual( + /* [in] */ __RPC__in_opt IMFMediaType *pIMediaType, + /* [out] */ __RPC__out DWORD *pdwFlags) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE GetRepresentation( + /* [in] */ GUID guidRepresentation, + /* [annotation][out] */ + _Out_ LPVOID *ppvRepresentation) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE FreeRepresentation( + /* [in] */ GUID guidRepresentation, + /* [in] */ LPVOID pvRepresentation) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaTypeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaType * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaType * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + __RPC__in IMFMediaType * This, + __RPC__in_opt IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cchBufSize) LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(( *pcchLength + 1 ) ) LPWSTR *ppwszValue, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cbBufSize) UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbSize) UINT8 **ppBuf, + /* [out] */ __RPC__out UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + __RPC__in IMFMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + __RPC__in REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [string][in] */ __RPC__in_string LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [size_is][in] */ __RPC__in_ecount_full(cbBufSize) const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + __RPC__in IMFMediaType * This, + __RPC__in REFGUID guidKey, + /* [in] */ __RPC__in_opt IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + __RPC__in IMFMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + __RPC__in IMFMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + __RPC__in IMFMediaType * This, + /* [out] */ __RPC__out UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + __RPC__in IMFMediaType * This, + UINT32 unIndex, + /* [out] */ __RPC__out GUID *pguidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + __RPC__in IMFMediaType * This, + /* [in] */ __RPC__in_opt IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *GetMajorType )( + __RPC__in IMFMediaType * This, + /* [out] */ __RPC__out GUID *pguidMajorType); + + HRESULT ( STDMETHODCALLTYPE *IsCompressedFormat )( + __RPC__in IMFMediaType * This, + /* [out] */ __RPC__out BOOL *pfCompressed); + + HRESULT ( STDMETHODCALLTYPE *IsEqual )( + __RPC__in IMFMediaType * This, + /* [in] */ __RPC__in_opt IMFMediaType *pIMediaType, + /* [out] */ __RPC__out DWORD *pdwFlags); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *GetRepresentation )( + IMFMediaType * This, + /* [in] */ GUID guidRepresentation, + /* [annotation][out] */ + _Out_ LPVOID *ppvRepresentation); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *FreeRepresentation )( + IMFMediaType * This, + /* [in] */ GUID guidRepresentation, + /* [in] */ LPVOID pvRepresentation); + + END_INTERFACE + } IMFMediaTypeVtbl; + + interface IMFMediaType + { + CONST_VTBL struct IMFMediaTypeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaType_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaType_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaType_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaType_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFMediaType_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFMediaType_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFMediaType_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFMediaType_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFMediaType_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFMediaType_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFMediaType_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFMediaType_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFMediaType_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFMediaType_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFMediaType_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFMediaType_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFMediaType_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFMediaType_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFMediaType_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFMediaType_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFMediaType_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFMediaType_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFMediaType_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFMediaType_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFMediaType_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFMediaType_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFMediaType_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFMediaType_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFMediaType_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFMediaType_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFMediaType_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFMediaType_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFMediaType_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFMediaType_GetMajorType(This,pguidMajorType) \ + ( (This)->lpVtbl -> GetMajorType(This,pguidMajorType) ) + +#define IMFMediaType_IsCompressedFormat(This,pfCompressed) \ + ( (This)->lpVtbl -> IsCompressedFormat(This,pfCompressed) ) + +#define IMFMediaType_IsEqual(This,pIMediaType,pdwFlags) \ + ( (This)->lpVtbl -> IsEqual(This,pIMediaType,pdwFlags) ) + +#define IMFMediaType_GetRepresentation(This,guidRepresentation,ppvRepresentation) \ + ( (This)->lpVtbl -> GetRepresentation(This,guidRepresentation,ppvRepresentation) ) + +#define IMFMediaType_FreeRepresentation(This,guidRepresentation,pvRepresentation) \ + ( (This)->lpVtbl -> FreeRepresentation(This,guidRepresentation,pvRepresentation) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaType_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0007 */ +/* [local] */ + +#define MF_MEDIATYPE_EQUAL_MAJOR_TYPES 0x00000001 +#define MF_MEDIATYPE_EQUAL_FORMAT_TYPES 0x00000002 +#define MF_MEDIATYPE_EQUAL_FORMAT_DATA 0x00000004 +#define MF_MEDIATYPE_EQUAL_FORMAT_USER_DATA 0x00000008 + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0007_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0007_v0_0_s_ifspec; + +#ifndef __IMFAudioMediaType_INTERFACE_DEFINED__ +#define __IMFAudioMediaType_INTERFACE_DEFINED__ + +/* interface IMFAudioMediaType */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFAudioMediaType; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("26a0adc3-ce26-4672-9304-69552edd3faf") + IMFAudioMediaType : public IMFMediaType + { + public: + virtual const WAVEFORMATEX *STDMETHODCALLTYPE GetAudioFormat( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFAudioMediaTypeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFAudioMediaType * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFAudioMediaType * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFAudioMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [full][out][in] */ PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [out] */ MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + IMFAudioMediaType * This, + REFGUID guidKey, + REFPROPVARIANT Value, + /* [out] */ BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + IMFAudioMediaType * This, + IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [out] */ UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [out] */ UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [out] */ double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [out] */ GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [out] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [size_is][out] */ LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [size_is][size_is][out] */ LPWSTR *ppwszValue, + /* [out] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [out] */ UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [size_is][out] */ UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [size_is][size_is][out] */ UINT8 **ppBuf, + /* [out] */ UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + IMFAudioMediaType * This, + REFGUID guidKey, + REFIID riid, + /* [iid_is][out] */ LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + IMFAudioMediaType * This, + REFGUID guidKey, + REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + IMFAudioMediaType * This, + REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + IMFAudioMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + IMFAudioMediaType * This, + REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + IMFAudioMediaType * This, + REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + IMFAudioMediaType * This, + REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + IMFAudioMediaType * This, + REFGUID guidKey, + REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [string][in] */ LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [size_is][in] */ const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + IMFAudioMediaType * This, + REFGUID guidKey, + /* [in] */ IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + IMFAudioMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + IMFAudioMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + IMFAudioMediaType * This, + /* [out] */ UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + IMFAudioMediaType * This, + UINT32 unIndex, + /* [out] */ GUID *pguidKey, + /* [full][out][in] */ PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + IMFAudioMediaType * This, + /* [in] */ IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *GetMajorType )( + IMFAudioMediaType * This, + /* [out] */ GUID *pguidMajorType); + + HRESULT ( STDMETHODCALLTYPE *IsCompressedFormat )( + IMFAudioMediaType * This, + /* [out] */ BOOL *pfCompressed); + + HRESULT ( STDMETHODCALLTYPE *IsEqual )( + IMFAudioMediaType * This, + /* [in] */ IMFMediaType *pIMediaType, + /* [out] */ DWORD *pdwFlags); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *GetRepresentation )( + IMFAudioMediaType * This, + /* [in] */ GUID guidRepresentation, + /* [annotation][out] */ + _Out_ LPVOID *ppvRepresentation); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *FreeRepresentation )( + IMFAudioMediaType * This, + /* [in] */ GUID guidRepresentation, + /* [in] */ LPVOID pvRepresentation); + + const WAVEFORMATEX *( STDMETHODCALLTYPE *GetAudioFormat )( + IMFAudioMediaType * This); + + END_INTERFACE + } IMFAudioMediaTypeVtbl; + + interface IMFAudioMediaType + { + CONST_VTBL struct IMFAudioMediaTypeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFAudioMediaType_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFAudioMediaType_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFAudioMediaType_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFAudioMediaType_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFAudioMediaType_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFAudioMediaType_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFAudioMediaType_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFAudioMediaType_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFAudioMediaType_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFAudioMediaType_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFAudioMediaType_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFAudioMediaType_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFAudioMediaType_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFAudioMediaType_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFAudioMediaType_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFAudioMediaType_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFAudioMediaType_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFAudioMediaType_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFAudioMediaType_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFAudioMediaType_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFAudioMediaType_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFAudioMediaType_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFAudioMediaType_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFAudioMediaType_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFAudioMediaType_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFAudioMediaType_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFAudioMediaType_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFAudioMediaType_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFAudioMediaType_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFAudioMediaType_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFAudioMediaType_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFAudioMediaType_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFAudioMediaType_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFAudioMediaType_GetMajorType(This,pguidMajorType) \ + ( (This)->lpVtbl -> GetMajorType(This,pguidMajorType) ) + +#define IMFAudioMediaType_IsCompressedFormat(This,pfCompressed) \ + ( (This)->lpVtbl -> IsCompressedFormat(This,pfCompressed) ) + +#define IMFAudioMediaType_IsEqual(This,pIMediaType,pdwFlags) \ + ( (This)->lpVtbl -> IsEqual(This,pIMediaType,pdwFlags) ) + +#define IMFAudioMediaType_GetRepresentation(This,guidRepresentation,ppvRepresentation) \ + ( (This)->lpVtbl -> GetRepresentation(This,guidRepresentation,ppvRepresentation) ) + +#define IMFAudioMediaType_FreeRepresentation(This,guidRepresentation,pvRepresentation) \ + ( (This)->lpVtbl -> FreeRepresentation(This,guidRepresentation,pvRepresentation) ) + + +#define IMFAudioMediaType_GetAudioFormat(This) \ + ( (This)->lpVtbl -> GetAudioFormat(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFAudioMediaType_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0008 */ +/* [local] */ + +#ifndef _WINGDI_ +typedef DWORD RGBQUAD; + +typedef /* [public][public] */ struct __MIDL___MIDL_itf_mfobjects_0000_0008_0001 + { + DWORD biSize; + LONG biWidth; + LONG biHeight; + WORD biPlanes; + WORD biBitCount; + DWORD biCompression; + DWORD biSizeImage; + LONG biXPelsPerMeter; + LONG biYPelsPerMeter; + DWORD biClrUsed; + DWORD biClrImportant; + } BITMAPINFOHEADER; + +typedef /* [public] */ struct __MIDL___MIDL_itf_mfobjects_0000_0008_0002 + { + BITMAPINFOHEADER bmiHeader; + RGBQUAD bmiColors[ 1 ]; + } BITMAPINFO; + +#endif + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef /* [public] */ struct __MIDL___MIDL_itf_mfobjects_0000_0008_0003 + { + GUID guidMajorType; + GUID guidSubtype; + } MFT_REGISTER_TYPE_INFO; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#if !defined( _MFVIDEOFORMAT_ ) +#define _MFVIDEOFORMAT_ +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef +enum _MFVideoInterlaceMode + { + MFVideoInterlace_Unknown = 0, + MFVideoInterlace_Progressive = 2, + MFVideoInterlace_FieldInterleavedUpperFirst = 3, + MFVideoInterlace_FieldInterleavedLowerFirst = 4, + MFVideoInterlace_FieldSingleUpper = 5, + MFVideoInterlace_FieldSingleLower = 6, + MFVideoInterlace_MixedInterlaceOrProgressive = 7, + MFVideoInterlace_Last = ( MFVideoInterlace_MixedInterlaceOrProgressive + 1 ) , + MFVideoInterlace_ForceDWORD = 0x7fffffff + } MFVideoInterlaceMode; + +#define MFVideoInterlace_FieldSingleUpperFirst MFVideoInterlace_FieldSingleUpper +#define MFVideoInterlace_FieldSingleLowerFirst MFVideoInterlace_FieldSingleLower +typedef +enum _MFVideoTransferFunction + { + MFVideoTransFunc_Unknown = 0, + MFVideoTransFunc_10 = 1, + MFVideoTransFunc_18 = 2, + MFVideoTransFunc_20 = 3, + MFVideoTransFunc_22 = 4, + MFVideoTransFunc_709 = 5, + MFVideoTransFunc_240M = 6, + MFVideoTransFunc_sRGB = 7, + MFVideoTransFunc_28 = 8, + MFVideoTransFunc_Log_100 = 9, + MFVideoTransFunc_Log_316 = 10, + MFVideoTransFunc_709_sym = 11, + MFVideoTransFunc_2020_const = 12, + MFVideoTransFunc_2020 = 13, + MFVideoTransFunc_26 = 14, + MFVideoTransFunc_2084 = 15, + MFVideoTransFunc_HLG = 16, + MFVideoTransFunc_10_rel = 17, + MFVideoTransFunc_Last = ( MFVideoTransFunc_10_rel + 1 ) , + MFVideoTransFunc_ForceDWORD = 0x7fffffff + } MFVideoTransferFunction; + +typedef +enum _MFVideoPrimaries + { + MFVideoPrimaries_Unknown = 0, + MFVideoPrimaries_reserved = 1, + MFVideoPrimaries_BT709 = 2, + MFVideoPrimaries_BT470_2_SysM = 3, + MFVideoPrimaries_BT470_2_SysBG = 4, + MFVideoPrimaries_SMPTE170M = 5, + MFVideoPrimaries_SMPTE240M = 6, + MFVideoPrimaries_EBU3213 = 7, + MFVideoPrimaries_SMPTE_C = 8, + MFVideoPrimaries_BT2020 = 9, + MFVideoPrimaries_XYZ = 10, + MFVideoPrimaries_DCI_P3 = 11, + MFVideoPrimaries_ACES = 12, + MFVideoPrimaries_Last = ( MFVideoPrimaries_ACES + 1 ) , + MFVideoPrimaries_ForceDWORD = 0x7fffffff + } MFVideoPrimaries; + +typedef +enum _MFVideoLighting + { + MFVideoLighting_Unknown = 0, + MFVideoLighting_bright = 1, + MFVideoLighting_office = 2, + MFVideoLighting_dim = 3, + MFVideoLighting_dark = 4, + MFVideoLighting_Last = ( MFVideoLighting_dark + 1 ) , + MFVideoLighting_ForceDWORD = 0x7fffffff + } MFVideoLighting; + +typedef +enum _MFVideoTransferMatrix + { + MFVideoTransferMatrix_Unknown = 0, + MFVideoTransferMatrix_BT709 = 1, + MFVideoTransferMatrix_BT601 = 2, + MFVideoTransferMatrix_SMPTE240M = 3, + MFVideoTransferMatrix_BT2020_10 = 4, + MFVideoTransferMatrix_BT2020_12 = 5, + MFVideoTransferMatrix_Last = ( MFVideoTransferMatrix_BT2020_12 + 1 ) , + MFVideoTransferMatrix_ForceDWORD = 0x7fffffff + } MFVideoTransferMatrix; + +typedef +enum _MFVideoChromaSubsampling + { + MFVideoChromaSubsampling_Unknown = 0, + MFVideoChromaSubsampling_ProgressiveChroma = 0x8, + MFVideoChromaSubsampling_Horizontally_Cosited = 0x4, + MFVideoChromaSubsampling_Vertically_Cosited = 0x2, + MFVideoChromaSubsampling_Vertically_AlignedChromaPlanes = 0x1, + MFVideoChromaSubsampling_MPEG2 = ( MFVideoChromaSubsampling_Horizontally_Cosited | MFVideoChromaSubsampling_Vertically_AlignedChromaPlanes ) , + MFVideoChromaSubsampling_MPEG1 = MFVideoChromaSubsampling_Vertically_AlignedChromaPlanes, + MFVideoChromaSubsampling_DV_PAL = ( MFVideoChromaSubsampling_Horizontally_Cosited | MFVideoChromaSubsampling_Vertically_Cosited ) , + MFVideoChromaSubsampling_Cosited = ( ( MFVideoChromaSubsampling_Horizontally_Cosited | MFVideoChromaSubsampling_Vertically_Cosited ) | MFVideoChromaSubsampling_Vertically_AlignedChromaPlanes ) , + MFVideoChromaSubsampling_Last = ( MFVideoChromaSubsampling_Cosited + 1 ) , + MFVideoChromaSubsampling_ForceDWORD = 0x7fffffff + } MFVideoChromaSubsampling; + +typedef +enum _MFNominalRange + { + MFNominalRange_Unknown = 0, + MFNominalRange_Normal = 1, + MFNominalRange_Wide = 2, + MFNominalRange_0_255 = 1, + MFNominalRange_16_235 = 2, + MFNominalRange_48_208 = 3, + MFNominalRange_64_127 = 4, + MFNominalRange_Last = ( MFNominalRange_64_127 + 1 ) , + MFNominalRange_ForceDWORD = 0x7fffffff + } MFNominalRange; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +typedef +enum _MFVideoFlags + { + MFVideoFlag_PAD_TO_Mask = ( 0x1 | 0x2 ) , + MFVideoFlag_PAD_TO_None = ( 0 * 0x1 ) , + MFVideoFlag_PAD_TO_4x3 = ( 1 * 0x1 ) , + MFVideoFlag_PAD_TO_16x9 = ( 2 * 0x1 ) , + MFVideoFlag_SrcContentHintMask = ( ( 0x4 | 0x8 ) | 0x10 ) , + MFVideoFlag_SrcContentHintNone = ( 0 * 0x4 ) , + MFVideoFlag_SrcContentHint16x9 = ( 1 * 0x4 ) , + MFVideoFlag_SrcContentHint235_1 = ( 2 * 0x4 ) , + MFVideoFlag_AnalogProtected = 0x20, + MFVideoFlag_DigitallyProtected = 0x40, + MFVideoFlag_ProgressiveContent = 0x80, + MFVideoFlag_FieldRepeatCountMask = ( ( 0x100 | 0x200 ) | 0x400 ) , + MFVideoFlag_FieldRepeatCountShift = 8, + MFVideoFlag_ProgressiveSeqReset = 0x800, + MFVideoFlag_PanScanEnabled = 0x20000, + MFVideoFlag_LowerFieldFirst = 0x40000, + MFVideoFlag_BottomUpLinearRep = 0x80000, + MFVideoFlags_DXVASurface = 0x100000, + MFVideoFlags_RenderTargetSurface = 0x400000, + MFVideoFlags_ForceQWORD = 0x7fffffff + } MFVideoFlags; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef struct _MFRatio + { + DWORD Numerator; + DWORD Denominator; + } MFRatio; + +typedef struct _MFOffset + { + WORD fract; + short value; + } MFOffset; + +typedef struct _MFVideoArea + { + MFOffset OffsetX; + MFOffset OffsetY; + SIZE Area; + } MFVideoArea; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +#pragma warning(push) +#pragma warning(disable:4820) // Disable C4820: padding after data member +#endif +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +typedef struct _MFVideoInfo + { + DWORD dwWidth; + DWORD dwHeight; + MFRatio PixelAspectRatio; + MFVideoChromaSubsampling SourceChromaSubsampling; + MFVideoInterlaceMode InterlaceMode; + MFVideoTransferFunction TransferFunction; + MFVideoPrimaries ColorPrimaries; + MFVideoTransferMatrix TransferMatrix; + MFVideoLighting SourceLighting; + MFRatio FramesPerSecond; + MFNominalRange NominalRange; + MFVideoArea GeometricAperture; + MFVideoArea MinimumDisplayAperture; + MFVideoArea PanScanAperture; + unsigned __int64 VideoFlags; + } MFVideoInfo; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +#pragma warning(pop) +#endif +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef struct __MFAYUVSample + { + BYTE bCrValue; + BYTE bCbValue; + BYTE bYValue; + BYTE bSampleAlpha8; + } MFAYUVSample; + +typedef struct _MFARGB + { + BYTE rgbBlue; + BYTE rgbGreen; + BYTE rgbRed; + BYTE rgbAlpha; + } MFARGB; + +typedef union _MFPaletteEntry + { + MFARGB ARGB; + MFAYUVSample AYCbCr; + } MFPaletteEntry; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +#pragma warning(push) +#pragma warning(disable:4820) // Disable C4820: padding after data member +#endif +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +typedef struct _MFVideoSurfaceInfo + { + DWORD Format; + DWORD PaletteEntries; + /* [size_is] */ MFPaletteEntry Palette[ 1 ]; + } MFVideoSurfaceInfo; + +typedef struct _MFVideoCompressedInfo + { + LONGLONG AvgBitrate; + LONGLONG AvgBitErrorRate; + DWORD MaxKeyFrameSpacing; + } MFVideoCompressedInfo; + +typedef struct _MFVIDEOFORMAT + { + DWORD dwSize; + MFVideoInfo videoInfo; + GUID guidFormat; + MFVideoCompressedInfo compressedInfo; + MFVideoSurfaceInfo surfaceInfo; + } MFVIDEOFORMAT; + +#if defined(_MSC_VER) && (_MSC_VER >= 1600) +#pragma warning(pop) +#endif +typedef +enum _MFStandardVideoFormat + { + MFStdVideoFormat_reserved = 0, + MFStdVideoFormat_NTSC = ( MFStdVideoFormat_reserved + 1 ) , + MFStdVideoFormat_PAL = ( MFStdVideoFormat_NTSC + 1 ) , + MFStdVideoFormat_DVD_NTSC = ( MFStdVideoFormat_PAL + 1 ) , + MFStdVideoFormat_DVD_PAL = ( MFStdVideoFormat_DVD_NTSC + 1 ) , + MFStdVideoFormat_DV_PAL = ( MFStdVideoFormat_DVD_PAL + 1 ) , + MFStdVideoFormat_DV_NTSC = ( MFStdVideoFormat_DV_PAL + 1 ) , + MFStdVideoFormat_ATSC_SD480i = ( MFStdVideoFormat_DV_NTSC + 1 ) , + MFStdVideoFormat_ATSC_HD1080i = ( MFStdVideoFormat_ATSC_SD480i + 1 ) , + MFStdVideoFormat_ATSC_HD720p = ( MFStdVideoFormat_ATSC_HD1080i + 1 ) + } MFStandardVideoFormat; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#endif + +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0008_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0008_v0_0_s_ifspec; + +#ifndef __IMFVideoMediaType_INTERFACE_DEFINED__ +#define __IMFVideoMediaType_INTERFACE_DEFINED__ + +/* interface IMFVideoMediaType */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFVideoMediaType; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("b99f381f-a8f9-47a2-a5af-ca3a225a3890") + IMFVideoMediaType : public IMFMediaType + { + public: + virtual const MFVIDEOFORMAT *STDMETHODCALLTYPE GetVideoFormat( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVideoRepresentation( + /* [in] */ GUID guidRepresentation, + /* [annotation][out] */ + _Out_ LPVOID *ppvRepresentation, + /* [in] */ LONG lStride) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFVideoMediaTypeVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFVideoMediaType * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFVideoMediaType * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFVideoMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [full][out][in] */ PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [out] */ MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + IMFVideoMediaType * This, + REFGUID guidKey, + REFPROPVARIANT Value, + /* [out] */ BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + IMFVideoMediaType * This, + IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [out] */ UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [out] */ UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [out] */ double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [out] */ GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [out] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [size_is][out] */ LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [size_is][size_is][out] */ LPWSTR *ppwszValue, + /* [out] */ UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [out] */ UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [size_is][out] */ UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [size_is][size_is][out] */ UINT8 **ppBuf, + /* [out] */ UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + IMFVideoMediaType * This, + REFGUID guidKey, + REFIID riid, + /* [iid_is][out] */ LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + IMFVideoMediaType * This, + REFGUID guidKey, + REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + IMFVideoMediaType * This, + REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + IMFVideoMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + IMFVideoMediaType * This, + REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + IMFVideoMediaType * This, + REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + IMFVideoMediaType * This, + REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + IMFVideoMediaType * This, + REFGUID guidKey, + REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [string][in] */ LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [size_is][in] */ const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + IMFVideoMediaType * This, + REFGUID guidKey, + /* [in] */ IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + IMFVideoMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + IMFVideoMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + IMFVideoMediaType * This, + /* [out] */ UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + IMFVideoMediaType * This, + UINT32 unIndex, + /* [out] */ GUID *pguidKey, + /* [full][out][in] */ PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + IMFVideoMediaType * This, + /* [in] */ IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *GetMajorType )( + IMFVideoMediaType * This, + /* [out] */ GUID *pguidMajorType); + + HRESULT ( STDMETHODCALLTYPE *IsCompressedFormat )( + IMFVideoMediaType * This, + /* [out] */ BOOL *pfCompressed); + + HRESULT ( STDMETHODCALLTYPE *IsEqual )( + IMFVideoMediaType * This, + /* [in] */ IMFMediaType *pIMediaType, + /* [out] */ DWORD *pdwFlags); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *GetRepresentation )( + IMFVideoMediaType * This, + /* [in] */ GUID guidRepresentation, + /* [annotation][out] */ + _Out_ LPVOID *ppvRepresentation); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *FreeRepresentation )( + IMFVideoMediaType * This, + /* [in] */ GUID guidRepresentation, + /* [in] */ LPVOID pvRepresentation); + + const MFVIDEOFORMAT *( STDMETHODCALLTYPE *GetVideoFormat )( + IMFVideoMediaType * This); + + HRESULT ( STDMETHODCALLTYPE *GetVideoRepresentation )( + IMFVideoMediaType * This, + /* [in] */ GUID guidRepresentation, + /* [annotation][out] */ + _Out_ LPVOID *ppvRepresentation, + /* [in] */ LONG lStride); + + END_INTERFACE + } IMFVideoMediaTypeVtbl; + + interface IMFVideoMediaType + { + CONST_VTBL struct IMFVideoMediaTypeVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFVideoMediaType_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFVideoMediaType_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFVideoMediaType_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFVideoMediaType_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFVideoMediaType_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFVideoMediaType_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFVideoMediaType_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFVideoMediaType_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFVideoMediaType_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFVideoMediaType_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFVideoMediaType_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFVideoMediaType_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFVideoMediaType_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFVideoMediaType_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFVideoMediaType_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFVideoMediaType_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFVideoMediaType_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFVideoMediaType_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFVideoMediaType_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFVideoMediaType_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFVideoMediaType_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFVideoMediaType_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFVideoMediaType_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFVideoMediaType_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFVideoMediaType_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFVideoMediaType_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFVideoMediaType_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFVideoMediaType_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFVideoMediaType_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFVideoMediaType_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFVideoMediaType_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFVideoMediaType_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFVideoMediaType_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFVideoMediaType_GetMajorType(This,pguidMajorType) \ + ( (This)->lpVtbl -> GetMajorType(This,pguidMajorType) ) + +#define IMFVideoMediaType_IsCompressedFormat(This,pfCompressed) \ + ( (This)->lpVtbl -> IsCompressedFormat(This,pfCompressed) ) + +#define IMFVideoMediaType_IsEqual(This,pIMediaType,pdwFlags) \ + ( (This)->lpVtbl -> IsEqual(This,pIMediaType,pdwFlags) ) + +#define IMFVideoMediaType_GetRepresentation(This,guidRepresentation,ppvRepresentation) \ + ( (This)->lpVtbl -> GetRepresentation(This,guidRepresentation,ppvRepresentation) ) + +#define IMFVideoMediaType_FreeRepresentation(This,guidRepresentation,pvRepresentation) \ + ( (This)->lpVtbl -> FreeRepresentation(This,guidRepresentation,pvRepresentation) ) + + +#define IMFVideoMediaType_GetVideoFormat(This) \ + ( (This)->lpVtbl -> GetVideoFormat(This) ) + +#define IMFVideoMediaType_GetVideoRepresentation(This,guidRepresentation,ppvRepresentation,lStride) \ + ( (This)->lpVtbl -> GetVideoRepresentation(This,guidRepresentation,ppvRepresentation,lStride) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFVideoMediaType_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0009 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0009_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0009_v0_0_s_ifspec; + +#ifndef __IMFAsyncResult_INTERFACE_DEFINED__ +#define __IMFAsyncResult_INTERFACE_DEFINED__ + +/* interface IMFAsyncResult */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFAsyncResult; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ac6b7889-0740-4d51-8619-905994a55cc6") + IMFAsyncResult : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetState( + /* [out] */ __RPC__deref_out_opt IUnknown **ppunkState) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStatus( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetStatus( + /* [in] */ HRESULT hrStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetObject( + /* [out] */ __RPC__deref_out_opt IUnknown **ppObject) = 0; + + virtual /* [local] */ IUnknown *STDMETHODCALLTYPE GetStateNoAddRef( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFAsyncResultVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFAsyncResult * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFAsyncResult * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFAsyncResult * This); + + HRESULT ( STDMETHODCALLTYPE *GetState )( + __RPC__in IMFAsyncResult * This, + /* [out] */ __RPC__deref_out_opt IUnknown **ppunkState); + + HRESULT ( STDMETHODCALLTYPE *GetStatus )( + __RPC__in IMFAsyncResult * This); + + HRESULT ( STDMETHODCALLTYPE *SetStatus )( + __RPC__in IMFAsyncResult * This, + /* [in] */ HRESULT hrStatus); + + HRESULT ( STDMETHODCALLTYPE *GetObject )( + __RPC__in IMFAsyncResult * This, + /* [out] */ __RPC__deref_out_opt IUnknown **ppObject); + + /* [local] */ IUnknown *( STDMETHODCALLTYPE *GetStateNoAddRef )( + IMFAsyncResult * This); + + END_INTERFACE + } IMFAsyncResultVtbl; + + interface IMFAsyncResult + { + CONST_VTBL struct IMFAsyncResultVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFAsyncResult_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFAsyncResult_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFAsyncResult_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFAsyncResult_GetState(This,ppunkState) \ + ( (This)->lpVtbl -> GetState(This,ppunkState) ) + +#define IMFAsyncResult_GetStatus(This) \ + ( (This)->lpVtbl -> GetStatus(This) ) + +#define IMFAsyncResult_SetStatus(This,hrStatus) \ + ( (This)->lpVtbl -> SetStatus(This,hrStatus) ) + +#define IMFAsyncResult_GetObject(This,ppObject) \ + ( (This)->lpVtbl -> GetObject(This,ppObject) ) + +#define IMFAsyncResult_GetStateNoAddRef(This) \ + ( (This)->lpVtbl -> GetStateNoAddRef(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFAsyncResult_INTERFACE_DEFINED__ */ + + +#ifndef __IMFAsyncCallback_INTERFACE_DEFINED__ +#define __IMFAsyncCallback_INTERFACE_DEFINED__ + +/* interface IMFAsyncCallback */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFAsyncCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("a27003cf-2354-4f2a-8d6a-ab7cff15437e") + IMFAsyncCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetParameters( + /* [out] */ __RPC__out DWORD *pdwFlags, + /* [out] */ __RPC__out DWORD *pdwQueue) = 0; + + virtual HRESULT STDMETHODCALLTYPE Invoke( + /* [in] */ __RPC__in_opt IMFAsyncResult *pAsyncResult) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFAsyncCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFAsyncCallback * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFAsyncCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFAsyncCallback * This); + + HRESULT ( STDMETHODCALLTYPE *GetParameters )( + __RPC__in IMFAsyncCallback * This, + /* [out] */ __RPC__out DWORD *pdwFlags, + /* [out] */ __RPC__out DWORD *pdwQueue); + + HRESULT ( STDMETHODCALLTYPE *Invoke )( + __RPC__in IMFAsyncCallback * This, + /* [in] */ __RPC__in_opt IMFAsyncResult *pAsyncResult); + + END_INTERFACE + } IMFAsyncCallbackVtbl; + + interface IMFAsyncCallback + { + CONST_VTBL struct IMFAsyncCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFAsyncCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFAsyncCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFAsyncCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFAsyncCallback_GetParameters(This,pdwFlags,pdwQueue) \ + ( (This)->lpVtbl -> GetParameters(This,pdwFlags,pdwQueue) ) + +#define IMFAsyncCallback_Invoke(This,pAsyncResult) \ + ( (This)->lpVtbl -> Invoke(This,pAsyncResult) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFAsyncCallback_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0011 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0011_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0011_v0_0_s_ifspec; + +#ifndef __IMFAsyncCallbackLogging_INTERFACE_DEFINED__ +#define __IMFAsyncCallbackLogging_INTERFACE_DEFINED__ + +/* interface IMFAsyncCallbackLogging */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFAsyncCallbackLogging; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("c7a4dca1-f5f0-47b6-b92b-bf0106d25791") + IMFAsyncCallbackLogging : public IMFAsyncCallback + { + public: + virtual void *STDMETHODCALLTYPE GetObjectPointer( void) = 0; + + virtual DWORD STDMETHODCALLTYPE GetObjectTag( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFAsyncCallbackLoggingVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFAsyncCallbackLogging * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFAsyncCallbackLogging * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFAsyncCallbackLogging * This); + + HRESULT ( STDMETHODCALLTYPE *GetParameters )( + IMFAsyncCallbackLogging * This, + /* [out] */ DWORD *pdwFlags, + /* [out] */ DWORD *pdwQueue); + + HRESULT ( STDMETHODCALLTYPE *Invoke )( + IMFAsyncCallbackLogging * This, + /* [in] */ IMFAsyncResult *pAsyncResult); + + void *( STDMETHODCALLTYPE *GetObjectPointer )( + IMFAsyncCallbackLogging * This); + + DWORD ( STDMETHODCALLTYPE *GetObjectTag )( + IMFAsyncCallbackLogging * This); + + END_INTERFACE + } IMFAsyncCallbackLoggingVtbl; + + interface IMFAsyncCallbackLogging + { + CONST_VTBL struct IMFAsyncCallbackLoggingVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFAsyncCallbackLogging_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFAsyncCallbackLogging_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFAsyncCallbackLogging_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFAsyncCallbackLogging_GetParameters(This,pdwFlags,pdwQueue) \ + ( (This)->lpVtbl -> GetParameters(This,pdwFlags,pdwQueue) ) + +#define IMFAsyncCallbackLogging_Invoke(This,pAsyncResult) \ + ( (This)->lpVtbl -> Invoke(This,pAsyncResult) ) + + +#define IMFAsyncCallbackLogging_GetObjectPointer(This) \ + ( (This)->lpVtbl -> GetObjectPointer(This) ) + +#define IMFAsyncCallbackLogging_GetObjectTag(This) \ + ( (This)->lpVtbl -> GetObjectTag(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFAsyncCallbackLogging_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0012 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +#define MFASYNC_FAST_IO_PROCESSING_CALLBACK 0x00000001 +#define MFASYNC_SIGNAL_CALLBACK 0x00000002 +#define MFASYNC_BLOCKING_CALLBACK 0x00000004 +#define MFASYNC_REPLY_CALLBACK 0x00000008 +#define MFASYNC_LOCALIZE_REMOTE_CALLBACK 0x00000010 +#define MFASYNC_CALLBACK_QUEUE_UNDEFINED 0x00000000 +#define MFASYNC_CALLBACK_QUEUE_STANDARD 0x00000001 +#define MFASYNC_CALLBACK_QUEUE_RT 0x00000002 +#define MFASYNC_CALLBACK_QUEUE_IO 0x00000003 +#define MFASYNC_CALLBACK_QUEUE_TIMER 0x00000004 +#define MFASYNC_CALLBACK_QUEUE_MULTITHREADED 0x00000005 +#define MFASYNC_CALLBACK_QUEUE_LONG_FUNCTION 0x00000007 +#define MFASYNC_CALLBACK_QUEUE_PRIVATE_MASK 0xFFFF0000 +#define MFASYNC_CALLBACK_QUEUE_ALL 0xFFFFFFFF + +enum __MIDL___MIDL_itf_mfobjects_0000_0012_0001 + { + MEUnknown = 0, + MEError = 1, + MEExtendedType = 2, + MENonFatalError = 3, + MEGenericV1Anchor = MENonFatalError, + MESessionUnknown = 100, + MESessionTopologySet = 101, + MESessionTopologiesCleared = 102, + MESessionStarted = 103, + MESessionPaused = 104, + MESessionStopped = 105, + MESessionClosed = 106, + MESessionEnded = 107, + MESessionRateChanged = 108, + MESessionScrubSampleComplete = 109, + MESessionCapabilitiesChanged = 110, + MESessionTopologyStatus = 111, + MESessionNotifyPresentationTime = 112, + MENewPresentation = 113, + MELicenseAcquisitionStart = 114, + MELicenseAcquisitionCompleted = 115, + MEIndividualizationStart = 116, + MEIndividualizationCompleted = 117, + MEEnablerProgress = 118, + MEEnablerCompleted = 119, + MEPolicyError = 120, + MEPolicyReport = 121, + MEBufferingStarted = 122, + MEBufferingStopped = 123, + MEConnectStart = 124, + MEConnectEnd = 125, + MEReconnectStart = 126, + MEReconnectEnd = 127, + MERendererEvent = 128, + MESessionStreamSinkFormatChanged = 129, + MESessionV1Anchor = MESessionStreamSinkFormatChanged, + MESourceUnknown = 200, + MESourceStarted = 201, + MEStreamStarted = 202, + MESourceSeeked = 203, + MEStreamSeeked = 204, + MENewStream = 205, + MEUpdatedStream = 206, + MESourceStopped = 207, + MEStreamStopped = 208, + MESourcePaused = 209, + MEStreamPaused = 210, + MEEndOfPresentation = 211, + MEEndOfStream = 212, + MEMediaSample = 213, + MEStreamTick = 214, + MEStreamThinMode = 215, + MEStreamFormatChanged = 216, + MESourceRateChanged = 217, + MEEndOfPresentationSegment = 218, + MESourceCharacteristicsChanged = 219, + MESourceRateChangeRequested = 220, + MESourceMetadataChanged = 221, + MESequencerSourceTopologyUpdated = 222, + MESourceV1Anchor = MESequencerSourceTopologyUpdated, + MESinkUnknown = 300, + MEStreamSinkStarted = 301, + MEStreamSinkStopped = 302, + MEStreamSinkPaused = 303, + MEStreamSinkRateChanged = 304, + MEStreamSinkRequestSample = 305, + MEStreamSinkMarker = 306, + MEStreamSinkPrerolled = 307, + MEStreamSinkScrubSampleComplete = 308, + MEStreamSinkFormatChanged = 309, + MEStreamSinkDeviceChanged = 310, + MEQualityNotify = 311, + MESinkInvalidated = 312, + MEAudioSessionNameChanged = 313, + MEAudioSessionVolumeChanged = 314, + MEAudioSessionDeviceRemoved = 315, + MEAudioSessionServerShutdown = 316, + MEAudioSessionGroupingParamChanged = 317, + MEAudioSessionIconChanged = 318, + MEAudioSessionFormatChanged = 319, + MEAudioSessionDisconnected = 320, + MEAudioSessionExclusiveModeOverride = 321, + MESinkV1Anchor = MEAudioSessionExclusiveModeOverride, + MECaptureAudioSessionVolumeChanged = 322, + MECaptureAudioSessionDeviceRemoved = 323, + MECaptureAudioSessionFormatChanged = 324, + MECaptureAudioSessionDisconnected = 325, + MECaptureAudioSessionExclusiveModeOverride = 326, + MECaptureAudioSessionServerShutdown = 327, + MESinkV2Anchor = MECaptureAudioSessionServerShutdown, + METrustUnknown = 400, + MEPolicyChanged = 401, + MEContentProtectionMessage = 402, + MEPolicySet = 403, + METrustV1Anchor = MEPolicySet, + MEWMDRMLicenseBackupCompleted = 500, + MEWMDRMLicenseBackupProgress = 501, + MEWMDRMLicenseRestoreCompleted = 502, + MEWMDRMLicenseRestoreProgress = 503, + MEWMDRMLicenseAcquisitionCompleted = 506, + MEWMDRMIndividualizationCompleted = 508, + MEWMDRMIndividualizationProgress = 513, + MEWMDRMProximityCompleted = 514, + MEWMDRMLicenseStoreCleaned = 515, + MEWMDRMRevocationDownloadCompleted = 516, + MEWMDRMV1Anchor = MEWMDRMRevocationDownloadCompleted, + METransformUnknown = 600, + METransformNeedInput = ( METransformUnknown + 1 ) , + METransformHaveOutput = ( METransformNeedInput + 1 ) , + METransformDrainComplete = ( METransformHaveOutput + 1 ) , + METransformMarker = ( METransformDrainComplete + 1 ) , + METransformInputStreamStateChanged = ( METransformMarker + 1 ) , + MEByteStreamCharacteristicsChanged = 700, + MEVideoCaptureDeviceRemoved = 800, + MEVideoCaptureDevicePreempted = 801, + MEStreamSinkFormatInvalidated = 802, + MEEncodingParameters = 803, + MEContentProtectionMetadata = 900, + MEDeviceThermalStateChanged = 950, + MEReservedMax = 10000 + } ; +typedef DWORD MediaEventType; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0012_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0012_v0_0_s_ifspec; + +#ifndef __IMFMediaEvent_INTERFACE_DEFINED__ +#define __IMFMediaEvent_INTERFACE_DEFINED__ + +/* interface IMFMediaEvent */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEvent; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("DF598932-F10C-4E39-BBA2-C308F101DAA3") + IMFMediaEvent : public IMFAttributes + { + public: + virtual HRESULT STDMETHODCALLTYPE GetType( + /* [out] */ __RPC__out MediaEventType *pmet) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetExtendedType( + /* [out] */ __RPC__out GUID *pguidExtendedType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStatus( + /* [out] */ __RPC__out HRESULT *phrStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetValue( + /* [out] */ __RPC__out PROPVARIANT *pvValue) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEventVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaEvent * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaEvent * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaEvent * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + __RPC__in IMFMediaEvent * This, + __RPC__in_opt IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cchBufSize) LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(( *pcchLength + 1 ) ) LPWSTR *ppwszValue, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cbBufSize) UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbSize) UINT8 **ppBuf, + /* [out] */ __RPC__out UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + __RPC__in IMFMediaEvent * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + __RPC__in REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [string][in] */ __RPC__in_string LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [size_is][in] */ __RPC__in_ecount_full(cbBufSize) const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + __RPC__in IMFMediaEvent * This, + __RPC__in REFGUID guidKey, + /* [in] */ __RPC__in_opt IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + __RPC__in IMFMediaEvent * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + __RPC__in IMFMediaEvent * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + __RPC__in IMFMediaEvent * This, + /* [out] */ __RPC__out UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + __RPC__in IMFMediaEvent * This, + UINT32 unIndex, + /* [out] */ __RPC__out GUID *pguidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + __RPC__in IMFMediaEvent * This, + /* [in] */ __RPC__in_opt IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *GetType )( + __RPC__in IMFMediaEvent * This, + /* [out] */ __RPC__out MediaEventType *pmet); + + HRESULT ( STDMETHODCALLTYPE *GetExtendedType )( + __RPC__in IMFMediaEvent * This, + /* [out] */ __RPC__out GUID *pguidExtendedType); + + HRESULT ( STDMETHODCALLTYPE *GetStatus )( + __RPC__in IMFMediaEvent * This, + /* [out] */ __RPC__out HRESULT *phrStatus); + + HRESULT ( STDMETHODCALLTYPE *GetValue )( + __RPC__in IMFMediaEvent * This, + /* [out] */ __RPC__out PROPVARIANT *pvValue); + + END_INTERFACE + } IMFMediaEventVtbl; + + interface IMFMediaEvent + { + CONST_VTBL struct IMFMediaEventVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEvent_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEvent_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEvent_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEvent_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFMediaEvent_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFMediaEvent_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFMediaEvent_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFMediaEvent_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFMediaEvent_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFMediaEvent_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFMediaEvent_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFMediaEvent_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFMediaEvent_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFMediaEvent_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFMediaEvent_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFMediaEvent_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFMediaEvent_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFMediaEvent_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFMediaEvent_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFMediaEvent_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFMediaEvent_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFMediaEvent_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFMediaEvent_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFMediaEvent_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFMediaEvent_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFMediaEvent_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFMediaEvent_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFMediaEvent_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFMediaEvent_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFMediaEvent_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFMediaEvent_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFMediaEvent_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFMediaEvent_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFMediaEvent_GetType(This,pmet) \ + ( (This)->lpVtbl -> GetType(This,pmet) ) + +#define IMFMediaEvent_GetExtendedType(This,pguidExtendedType) \ + ( (This)->lpVtbl -> GetExtendedType(This,pguidExtendedType) ) + +#define IMFMediaEvent_GetStatus(This,phrStatus) \ + ( (This)->lpVtbl -> GetStatus(This,phrStatus) ) + +#define IMFMediaEvent_GetValue(This,pvValue) \ + ( (This)->lpVtbl -> GetValue(This,pvValue) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEvent_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0013 */ +/* [local] */ + +#define MF_EVENT_FLAG_NO_WAIT 0x00000001 + + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0013_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0013_v0_0_s_ifspec; + +#ifndef __IMFMediaEventGenerator_INTERFACE_DEFINED__ +#define __IMFMediaEventGenerator_INTERFACE_DEFINED__ + +/* interface IMFMediaEventGenerator */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEventGenerator; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("2CD0BD52-BCD5-4B89-B62C-EADC0C031E7D") + IMFMediaEventGenerator : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetEvent( + /* [in] */ DWORD dwFlags, + /* [out] */ __RPC__deref_out_opt IMFMediaEvent **ppEvent) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE BeginGetEvent( + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE EndGetEvent( + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueueEvent( + /* [in] */ MediaEventType met, + /* [in] */ __RPC__in REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ __RPC__in_opt const PROPVARIANT *pvValue) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEventGeneratorVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFMediaEventGenerator * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFMediaEventGenerator * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFMediaEventGenerator * This); + + HRESULT ( STDMETHODCALLTYPE *GetEvent )( + __RPC__in IMFMediaEventGenerator * This, + /* [in] */ DWORD dwFlags, + /* [out] */ __RPC__deref_out_opt IMFMediaEvent **ppEvent); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginGetEvent )( + IMFMediaEventGenerator * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndGetEvent )( + IMFMediaEventGenerator * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent); + + HRESULT ( STDMETHODCALLTYPE *QueueEvent )( + __RPC__in IMFMediaEventGenerator * This, + /* [in] */ MediaEventType met, + /* [in] */ __RPC__in REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ __RPC__in_opt const PROPVARIANT *pvValue); + + END_INTERFACE + } IMFMediaEventGeneratorVtbl; + + interface IMFMediaEventGenerator + { + CONST_VTBL struct IMFMediaEventGeneratorVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEventGenerator_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEventGenerator_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEventGenerator_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEventGenerator_GetEvent(This,dwFlags,ppEvent) \ + ( (This)->lpVtbl -> GetEvent(This,dwFlags,ppEvent) ) + +#define IMFMediaEventGenerator_BeginGetEvent(This,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginGetEvent(This,pCallback,punkState) ) + +#define IMFMediaEventGenerator_EndGetEvent(This,pResult,ppEvent) \ + ( (This)->lpVtbl -> EndGetEvent(This,pResult,ppEvent) ) + +#define IMFMediaEventGenerator_QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) \ + ( (This)->lpVtbl -> QueueEvent(This,met,guidExtendedType,hrStatus,pvValue) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaEventGenerator_RemoteBeginGetEvent_Proxy( + __RPC__in IMFMediaEventGenerator * This, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + + +void __RPC_STUB IMFMediaEventGenerator_RemoteBeginGetEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaEventGenerator_RemoteEndGetEvent_Proxy( + __RPC__in IMFMediaEventGenerator * This, + /* [in] */ __RPC__in_opt IUnknown *pResult, + /* [out] */ __RPC__out DWORD *pcbEvent, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbEvent) BYTE **ppbEvent); + + +void __RPC_STUB IMFMediaEventGenerator_RemoteEndGetEvent_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMFMediaEventGenerator_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0014 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0014_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0014_v0_0_s_ifspec; + +#ifndef __IMFRemoteAsyncCallback_INTERFACE_DEFINED__ +#define __IMFRemoteAsyncCallback_INTERFACE_DEFINED__ + +/* interface IMFRemoteAsyncCallback */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFRemoteAsyncCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("a27003d0-2354-4f2a-8d6a-ab7cff15437e") + IMFRemoteAsyncCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE Invoke( + /* [in] */ HRESULT hr, + /* [in] */ __RPC__in_opt IUnknown *pRemoteResult) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFRemoteAsyncCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFRemoteAsyncCallback * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFRemoteAsyncCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFRemoteAsyncCallback * This); + + HRESULT ( STDMETHODCALLTYPE *Invoke )( + __RPC__in IMFRemoteAsyncCallback * This, + /* [in] */ HRESULT hr, + /* [in] */ __RPC__in_opt IUnknown *pRemoteResult); + + END_INTERFACE + } IMFRemoteAsyncCallbackVtbl; + + interface IMFRemoteAsyncCallback + { + CONST_VTBL struct IMFRemoteAsyncCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFRemoteAsyncCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFRemoteAsyncCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFRemoteAsyncCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFRemoteAsyncCallback_Invoke(This,hr,pRemoteResult) \ + ( (This)->lpVtbl -> Invoke(This,hr,pRemoteResult) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFRemoteAsyncCallback_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0015 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +typedef +enum _MFBYTESTREAM_SEEK_ORIGIN + { + msoBegin = 0, + msoCurrent = ( msoBegin + 1 ) + } MFBYTESTREAM_SEEK_ORIGIN; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0015_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0015_v0_0_s_ifspec; + +#ifndef __IMFByteStream_INTERFACE_DEFINED__ +#define __IMFByteStream_INTERFACE_DEFINED__ + +/* interface IMFByteStream */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFByteStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("ad4c1b00-4bf7-422f-9175-756693d9130d") + IMFByteStream : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetCapabilities( + /* [out] */ __RPC__out DWORD *pdwCapabilities) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetLength( + /* [out] */ __RPC__out QWORD *pqwLength) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetLength( + /* [in] */ QWORD qwLength) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetCurrentPosition( + /* [out] */ __RPC__out QWORD *pqwPosition) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetCurrentPosition( + /* [in] */ QWORD qwPosition) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsEndOfStream( + /* [out] */ __RPC__out BOOL *pfEndOfStream) = 0; + + virtual HRESULT STDMETHODCALLTYPE Read( + /* [size_is][out] */ __RPC__out_ecount_full(cb) BYTE *pb, + /* [in] */ ULONG cb, + /* [out] */ __RPC__out ULONG *pcbRead) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE BeginRead( + /* [annotation][out] */ + _Out_writes_bytes_(cb) BYTE *pb, + /* [in] */ ULONG cb, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE EndRead( + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ ULONG *pcbRead) = 0; + + virtual HRESULT STDMETHODCALLTYPE Write( + /* [size_is][in] */ __RPC__in_ecount_full(cb) const BYTE *pb, + /* [in] */ ULONG cb, + /* [out] */ __RPC__out ULONG *pcbWritten) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE BeginWrite( + /* [annotation][in] */ + _In_reads_bytes_(cb) const BYTE *pb, + /* [in] */ ULONG cb, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE EndWrite( + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ ULONG *pcbWritten) = 0; + + virtual HRESULT STDMETHODCALLTYPE Seek( + /* [in] */ MFBYTESTREAM_SEEK_ORIGIN SeekOrigin, + /* [in] */ LONGLONG llSeekOffset, + /* [in] */ DWORD dwSeekFlags, + /* [out] */ __RPC__out QWORD *pqwCurrentPosition) = 0; + + virtual HRESULT STDMETHODCALLTYPE Flush( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFByteStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFByteStream * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFByteStream * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFByteStream * This); + + HRESULT ( STDMETHODCALLTYPE *GetCapabilities )( + __RPC__in IMFByteStream * This, + /* [out] */ __RPC__out DWORD *pdwCapabilities); + + HRESULT ( STDMETHODCALLTYPE *GetLength )( + __RPC__in IMFByteStream * This, + /* [out] */ __RPC__out QWORD *pqwLength); + + HRESULT ( STDMETHODCALLTYPE *SetLength )( + __RPC__in IMFByteStream * This, + /* [in] */ QWORD qwLength); + + HRESULT ( STDMETHODCALLTYPE *GetCurrentPosition )( + __RPC__in IMFByteStream * This, + /* [out] */ __RPC__out QWORD *pqwPosition); + + HRESULT ( STDMETHODCALLTYPE *SetCurrentPosition )( + __RPC__in IMFByteStream * This, + /* [in] */ QWORD qwPosition); + + HRESULT ( STDMETHODCALLTYPE *IsEndOfStream )( + __RPC__in IMFByteStream * This, + /* [out] */ __RPC__out BOOL *pfEndOfStream); + + HRESULT ( STDMETHODCALLTYPE *Read )( + __RPC__in IMFByteStream * This, + /* [size_is][out] */ __RPC__out_ecount_full(cb) BYTE *pb, + /* [in] */ ULONG cb, + /* [out] */ __RPC__out ULONG *pcbRead); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginRead )( + IMFByteStream * This, + /* [annotation][out] */ + _Out_writes_bytes_(cb) BYTE *pb, + /* [in] */ ULONG cb, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndRead )( + IMFByteStream * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ ULONG *pcbRead); + + HRESULT ( STDMETHODCALLTYPE *Write )( + __RPC__in IMFByteStream * This, + /* [size_is][in] */ __RPC__in_ecount_full(cb) const BYTE *pb, + /* [in] */ ULONG cb, + /* [out] */ __RPC__out ULONG *pcbWritten); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *BeginWrite )( + IMFByteStream * This, + /* [annotation][in] */ + _In_reads_bytes_(cb) const BYTE *pb, + /* [in] */ ULONG cb, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *EndWrite )( + IMFByteStream * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ ULONG *pcbWritten); + + HRESULT ( STDMETHODCALLTYPE *Seek )( + __RPC__in IMFByteStream * This, + /* [in] */ MFBYTESTREAM_SEEK_ORIGIN SeekOrigin, + /* [in] */ LONGLONG llSeekOffset, + /* [in] */ DWORD dwSeekFlags, + /* [out] */ __RPC__out QWORD *pqwCurrentPosition); + + HRESULT ( STDMETHODCALLTYPE *Flush )( + __RPC__in IMFByteStream * This); + + HRESULT ( STDMETHODCALLTYPE *Close )( + __RPC__in IMFByteStream * This); + + END_INTERFACE + } IMFByteStreamVtbl; + + interface IMFByteStream + { + CONST_VTBL struct IMFByteStreamVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFByteStream_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFByteStream_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFByteStream_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFByteStream_GetCapabilities(This,pdwCapabilities) \ + ( (This)->lpVtbl -> GetCapabilities(This,pdwCapabilities) ) + +#define IMFByteStream_GetLength(This,pqwLength) \ + ( (This)->lpVtbl -> GetLength(This,pqwLength) ) + +#define IMFByteStream_SetLength(This,qwLength) \ + ( (This)->lpVtbl -> SetLength(This,qwLength) ) + +#define IMFByteStream_GetCurrentPosition(This,pqwPosition) \ + ( (This)->lpVtbl -> GetCurrentPosition(This,pqwPosition) ) + +#define IMFByteStream_SetCurrentPosition(This,qwPosition) \ + ( (This)->lpVtbl -> SetCurrentPosition(This,qwPosition) ) + +#define IMFByteStream_IsEndOfStream(This,pfEndOfStream) \ + ( (This)->lpVtbl -> IsEndOfStream(This,pfEndOfStream) ) + +#define IMFByteStream_Read(This,pb,cb,pcbRead) \ + ( (This)->lpVtbl -> Read(This,pb,cb,pcbRead) ) + +#define IMFByteStream_BeginRead(This,pb,cb,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginRead(This,pb,cb,pCallback,punkState) ) + +#define IMFByteStream_EndRead(This,pResult,pcbRead) \ + ( (This)->lpVtbl -> EndRead(This,pResult,pcbRead) ) + +#define IMFByteStream_Write(This,pb,cb,pcbWritten) \ + ( (This)->lpVtbl -> Write(This,pb,cb,pcbWritten) ) + +#define IMFByteStream_BeginWrite(This,pb,cb,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginWrite(This,pb,cb,pCallback,punkState) ) + +#define IMFByteStream_EndWrite(This,pResult,pcbWritten) \ + ( (This)->lpVtbl -> EndWrite(This,pResult,pcbWritten) ) + +#define IMFByteStream_Seek(This,SeekOrigin,llSeekOffset,dwSeekFlags,pqwCurrentPosition) \ + ( (This)->lpVtbl -> Seek(This,SeekOrigin,llSeekOffset,dwSeekFlags,pqwCurrentPosition) ) + +#define IMFByteStream_Flush(This) \ + ( (This)->lpVtbl -> Flush(This) ) + +#define IMFByteStream_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFByteStream_RemoteBeginRead_Proxy( + __RPC__in IMFByteStream * This, + /* [in] */ ULONG cb, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + + +void __RPC_STUB IMFByteStream_RemoteBeginRead_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFByteStream_RemoteEndRead_Proxy( + __RPC__in IMFByteStream * This, + /* [in] */ __RPC__in_opt IUnknown *punkResult, + /* [length_is][size_is][out][in] */ __RPC__inout_ecount_part(cb, *pcbRead) BYTE *pb, + /* [in] */ ULONG cb, + /* [out][in] */ __RPC__inout ULONG *pcbRead); + + +void __RPC_STUB IMFByteStream_RemoteEndRead_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFByteStream_RemoteBeginWrite_Proxy( + __RPC__in IMFByteStream * This, + /* [size_is][in] */ __RPC__in_ecount_full(cb) const BYTE *pb, + /* [in] */ ULONG cb, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + + +void __RPC_STUB IMFByteStream_RemoteBeginWrite_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFByteStream_RemoteEndWrite_Proxy( + __RPC__in IMFByteStream * This, + /* [in] */ __RPC__in_opt IUnknown *punkResult, + /* [out] */ __RPC__out ULONG *pcbWritten); + + +void __RPC_STUB IMFByteStream_RemoteEndWrite_Stub( + IRpcStubBuffer *This, + IRpcChannelBuffer *_pRpcChannelBuffer, + PRPC_MESSAGE _pRpcMessage, + DWORD *_pdwStubPhase); + + + +#endif /* __IMFByteStream_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0016 */ +/* [local] */ + +#define MFBYTESTREAM_IS_READABLE 0x00000001 +#define MFBYTESTREAM_IS_WRITABLE 0x00000002 +#define MFBYTESTREAM_IS_SEEKABLE 0x00000004 +#define MFBYTESTREAM_IS_REMOTE 0x00000008 +#define MFBYTESTREAM_IS_DIRECTORY 0x00000080 +#define MFBYTESTREAM_HAS_SLOW_SEEK 0x00000100 +#define MFBYTESTREAM_IS_PARTIALLY_DOWNLOADED 0x00000200 +#if (WINVER >= _WIN32_WINNT_WIN7) +#define MFBYTESTREAM_SHARE_WRITE 0x00000400 +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#if (WINVER >= _WIN32_WINNT_WIN8) +#define MFBYTESTREAM_DOES_NOT_USE_NETWORK 0x00000800 +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#define MFBYTESTREAM_SEEK_FLAG_CANCEL_PENDING_IO 0x00000001 +EXTERN_GUID( MF_BYTESTREAM_ORIGIN_NAME, 0xfc358288, 0x3cb6, 0x460c, 0xa4, 0x24, 0xb6, 0x68, 0x12, 0x60, 0x37, 0x5a); +EXTERN_GUID( MF_BYTESTREAM_CONTENT_TYPE, 0xfc358289, 0x3cb6, 0x460c, 0xa4, 0x24, 0xb6, 0x68, 0x12, 0x60, 0x37, 0x5a); +EXTERN_GUID( MF_BYTESTREAM_DURATION, 0xfc35828a, 0x3cb6, 0x460c, 0xa4, 0x24, 0xb6, 0x68, 0x12, 0x60, 0x37, 0x5a); +EXTERN_GUID( MF_BYTESTREAM_LAST_MODIFIED_TIME, 0xfc35828b, 0x3cb6, 0x460c, 0xa4, 0x24, 0xb6, 0x68, 0x12, 0x60, 0x37, 0x5a); +#if (WINVER >= _WIN32_WINNT_WIN7) +EXTERN_GUID( MF_BYTESTREAM_IFO_FILE_URI, 0xfc35828c, 0x3cb6, 0x460c, 0xa4, 0x24, 0xb6, 0x68, 0x12, 0x60, 0x37, 0x5a); +EXTERN_GUID( MF_BYTESTREAM_DLNA_PROFILE_ID, 0xfc35828d, 0x3cb6, 0x460c, 0xa4, 0x24, 0xb6, 0x68, 0x12, 0x60, 0x37, 0x5a); +EXTERN_GUID( MF_BYTESTREAM_EFFECTIVE_URL, 0x9afa0209, 0x89d1, 0x42af, 0x84, 0x56, 0x1d, 0xe6, 0xb5, 0x62, 0xd6, 0x91); +EXTERN_GUID( MF_BYTESTREAM_TRANSCODED, 0xb6c5c282, 0x4dc9, 0x4db9, 0xab, 0x48, 0xcf, 0x3b, 0x6d, 0x8b, 0xc5, 0xe0 ); +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +EXTERN_GUID(CLSID_MFByteStreamProxyClassFactory, 0x770e8e77, 0x4916, 0x441c, 0xa9, 0xa7, 0xb3, 0x42, 0xd0, 0xee, 0xbc, 0x71 ); + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0016_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0016_v0_0_s_ifspec; + +#ifndef __IMFByteStreamProxyClassFactory_INTERFACE_DEFINED__ +#define __IMFByteStreamProxyClassFactory_INTERFACE_DEFINED__ + +/* interface IMFByteStreamProxyClassFactory */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFByteStreamProxyClassFactory; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("a6b43f84-5c0a-42e8-a44d-b1857a76992f") + IMFByteStreamProxyClassFactory : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CreateByteStreamProxy( + /* [in] */ __RPC__in_opt IMFByteStream *pByteStream, + /* [unique][in] */ __RPC__in_opt IMFAttributes *pAttributes, + /* [in] */ __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppvObject) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFByteStreamProxyClassFactoryVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFByteStreamProxyClassFactory * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFByteStreamProxyClassFactory * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFByteStreamProxyClassFactory * This); + + HRESULT ( STDMETHODCALLTYPE *CreateByteStreamProxy )( + __RPC__in IMFByteStreamProxyClassFactory * This, + /* [in] */ __RPC__in_opt IMFByteStream *pByteStream, + /* [unique][in] */ __RPC__in_opt IMFAttributes *pAttributes, + /* [in] */ __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppvObject); + + END_INTERFACE + } IMFByteStreamProxyClassFactoryVtbl; + + interface IMFByteStreamProxyClassFactory + { + CONST_VTBL struct IMFByteStreamProxyClassFactoryVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFByteStreamProxyClassFactory_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFByteStreamProxyClassFactory_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFByteStreamProxyClassFactory_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFByteStreamProxyClassFactory_CreateByteStreamProxy(This,pByteStream,pAttributes,riid,ppvObject) \ + ( (This)->lpVtbl -> CreateByteStreamProxy(This,pByteStream,pAttributes,riid,ppvObject) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFByteStreamProxyClassFactory_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0017 */ +/* [local] */ + +typedef /* [public] */ +enum __MIDL___MIDL_itf_mfobjects_0000_0017_0001 + { + MF_ACCESSMODE_READ = 1, + MF_ACCESSMODE_WRITE = 2, + MF_ACCESSMODE_READWRITE = 3 + } MF_FILE_ACCESSMODE; + +typedef /* [public] */ +enum __MIDL___MIDL_itf_mfobjects_0000_0017_0002 + { + MF_OPENMODE_FAIL_IF_NOT_EXIST = 0, + MF_OPENMODE_FAIL_IF_EXIST = 1, + MF_OPENMODE_RESET_IF_EXIST = 2, + MF_OPENMODE_APPEND_IF_EXIST = 3, + MF_OPENMODE_DELETE_IF_EXIST = 4 + } MF_FILE_OPENMODE; + +typedef /* [public] */ +enum __MIDL___MIDL_itf_mfobjects_0000_0017_0003 + { + MF_FILEFLAGS_NONE = 0, + MF_FILEFLAGS_NOBUFFERING = 0x1, + MF_FILEFLAGS_ALLOW_WRITE_SHARING = 0x2 + } MF_FILE_FLAGS; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0017_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0017_v0_0_s_ifspec; + +#ifndef __IMFSampleOutputStream_INTERFACE_DEFINED__ +#define __IMFSampleOutputStream_INTERFACE_DEFINED__ + +/* interface IMFSampleOutputStream */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFSampleOutputStream; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("8feed468-6f7e-440d-869a-49bdd283ad0d") + IMFSampleOutputStream : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE BeginWriteSample( + /* [in] */ __RPC__in_opt IMFSample *pSample, + /* [in] */ __RPC__in_opt IMFAsyncCallback *pCallback, + /* [in] */ __RPC__in_opt IUnknown *punkState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndWriteSample( + /* [in] */ __RPC__in_opt IMFAsyncResult *pResult) = 0; + + virtual HRESULT STDMETHODCALLTYPE Close( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFSampleOutputStreamVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFSampleOutputStream * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFSampleOutputStream * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFSampleOutputStream * This); + + HRESULT ( STDMETHODCALLTYPE *BeginWriteSample )( + __RPC__in IMFSampleOutputStream * This, + /* [in] */ __RPC__in_opt IMFSample *pSample, + /* [in] */ __RPC__in_opt IMFAsyncCallback *pCallback, + /* [in] */ __RPC__in_opt IUnknown *punkState); + + HRESULT ( STDMETHODCALLTYPE *EndWriteSample )( + __RPC__in IMFSampleOutputStream * This, + /* [in] */ __RPC__in_opt IMFAsyncResult *pResult); + + HRESULT ( STDMETHODCALLTYPE *Close )( + __RPC__in IMFSampleOutputStream * This); + + END_INTERFACE + } IMFSampleOutputStreamVtbl; + + interface IMFSampleOutputStream + { + CONST_VTBL struct IMFSampleOutputStreamVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFSampleOutputStream_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFSampleOutputStream_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFSampleOutputStream_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFSampleOutputStream_BeginWriteSample(This,pSample,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginWriteSample(This,pSample,pCallback,punkState) ) + +#define IMFSampleOutputStream_EndWriteSample(This,pResult) \ + ( (This)->lpVtbl -> EndWriteSample(This,pResult) ) + +#define IMFSampleOutputStream_Close(This) \ + ( (This)->lpVtbl -> Close(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFSampleOutputStream_INTERFACE_DEFINED__ */ + + +#ifndef __IMFCollection_INTERFACE_DEFINED__ +#define __IMFCollection_INTERFACE_DEFINED__ + +/* interface IMFCollection */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFCollection; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5BC8A76B-869A-46a3-9B03-FA218A66AEBE") + IMFCollection : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetElementCount( + /* [out] */ __RPC__out DWORD *pcElements) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetElement( + /* [in] */ DWORD dwElementIndex, + /* [out] */ __RPC__deref_out_opt IUnknown **ppUnkElement) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddElement( + /* [in] */ __RPC__in_opt IUnknown *pUnkElement) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveElement( + /* [in] */ DWORD dwElementIndex, + /* [out] */ __RPC__deref_out_opt IUnknown **ppUnkElement) = 0; + + virtual HRESULT STDMETHODCALLTYPE InsertElementAt( + /* [in] */ DWORD dwIndex, + /* [in] */ __RPC__in_opt IUnknown *pUnknown) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveAllElements( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFCollectionVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFCollection * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFCollection * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFCollection * This); + + HRESULT ( STDMETHODCALLTYPE *GetElementCount )( + __RPC__in IMFCollection * This, + /* [out] */ __RPC__out DWORD *pcElements); + + HRESULT ( STDMETHODCALLTYPE *GetElement )( + __RPC__in IMFCollection * This, + /* [in] */ DWORD dwElementIndex, + /* [out] */ __RPC__deref_out_opt IUnknown **ppUnkElement); + + HRESULT ( STDMETHODCALLTYPE *AddElement )( + __RPC__in IMFCollection * This, + /* [in] */ __RPC__in_opt IUnknown *pUnkElement); + + HRESULT ( STDMETHODCALLTYPE *RemoveElement )( + __RPC__in IMFCollection * This, + /* [in] */ DWORD dwElementIndex, + /* [out] */ __RPC__deref_out_opt IUnknown **ppUnkElement); + + HRESULT ( STDMETHODCALLTYPE *InsertElementAt )( + __RPC__in IMFCollection * This, + /* [in] */ DWORD dwIndex, + /* [in] */ __RPC__in_opt IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *RemoveAllElements )( + __RPC__in IMFCollection * This); + + END_INTERFACE + } IMFCollectionVtbl; + + interface IMFCollection + { + CONST_VTBL struct IMFCollectionVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFCollection_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFCollection_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFCollection_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFCollection_GetElementCount(This,pcElements) \ + ( (This)->lpVtbl -> GetElementCount(This,pcElements) ) + +#define IMFCollection_GetElement(This,dwElementIndex,ppUnkElement) \ + ( (This)->lpVtbl -> GetElement(This,dwElementIndex,ppUnkElement) ) + +#define IMFCollection_AddElement(This,pUnkElement) \ + ( (This)->lpVtbl -> AddElement(This,pUnkElement) ) + +#define IMFCollection_RemoveElement(This,dwElementIndex,ppUnkElement) \ + ( (This)->lpVtbl -> RemoveElement(This,dwElementIndex,ppUnkElement) ) + +#define IMFCollection_InsertElementAt(This,dwIndex,pUnknown) \ + ( (This)->lpVtbl -> InsertElementAt(This,dwIndex,pUnknown) ) + +#define IMFCollection_RemoveAllElements(This) \ + ( (This)->lpVtbl -> RemoveAllElements(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFCollection_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMediaEventQueue_INTERFACE_DEFINED__ +#define __IMFMediaEventQueue_INTERFACE_DEFINED__ + +/* interface IMFMediaEventQueue */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFMediaEventQueue; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("36f846fc-2256-48b6-b58e-e2b638316581") + IMFMediaEventQueue : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetEvent( + /* [in] */ DWORD dwFlags, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent) = 0; + + virtual HRESULT STDMETHODCALLTYPE BeginGetEvent( + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState) = 0; + + virtual HRESULT STDMETHODCALLTYPE EndGetEvent( + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueueEvent( + /* [in] */ IMFMediaEvent *pEvent) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueueEventParamVar( + /* [in] */ MediaEventType met, + /* [in] */ REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ const PROPVARIANT *pvValue) = 0; + + virtual HRESULT STDMETHODCALLTYPE QueueEventParamUnk( + /* [in] */ MediaEventType met, + /* [in] */ REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ IUnknown *pUnk) = 0; + + virtual HRESULT STDMETHODCALLTYPE Shutdown( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMediaEventQueueVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMediaEventQueue * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMediaEventQueue * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMediaEventQueue * This); + + HRESULT ( STDMETHODCALLTYPE *GetEvent )( + IMFMediaEventQueue * This, + /* [in] */ DWORD dwFlags, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent); + + HRESULT ( STDMETHODCALLTYPE *BeginGetEvent )( + IMFMediaEventQueue * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + HRESULT ( STDMETHODCALLTYPE *EndGetEvent )( + IMFMediaEventQueue * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent); + + HRESULT ( STDMETHODCALLTYPE *QueueEvent )( + IMFMediaEventQueue * This, + /* [in] */ IMFMediaEvent *pEvent); + + HRESULT ( STDMETHODCALLTYPE *QueueEventParamVar )( + IMFMediaEventQueue * This, + /* [in] */ MediaEventType met, + /* [in] */ REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ const PROPVARIANT *pvValue); + + HRESULT ( STDMETHODCALLTYPE *QueueEventParamUnk )( + IMFMediaEventQueue * This, + /* [in] */ MediaEventType met, + /* [in] */ REFGUID guidExtendedType, + /* [in] */ HRESULT hrStatus, + /* [unique][in] */ IUnknown *pUnk); + + HRESULT ( STDMETHODCALLTYPE *Shutdown )( + IMFMediaEventQueue * This); + + END_INTERFACE + } IMFMediaEventQueueVtbl; + + interface IMFMediaEventQueue + { + CONST_VTBL struct IMFMediaEventQueueVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMediaEventQueue_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMediaEventQueue_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMediaEventQueue_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMediaEventQueue_GetEvent(This,dwFlags,ppEvent) \ + ( (This)->lpVtbl -> GetEvent(This,dwFlags,ppEvent) ) + +#define IMFMediaEventQueue_BeginGetEvent(This,pCallback,punkState) \ + ( (This)->lpVtbl -> BeginGetEvent(This,pCallback,punkState) ) + +#define IMFMediaEventQueue_EndGetEvent(This,pResult,ppEvent) \ + ( (This)->lpVtbl -> EndGetEvent(This,pResult,ppEvent) ) + +#define IMFMediaEventQueue_QueueEvent(This,pEvent) \ + ( (This)->lpVtbl -> QueueEvent(This,pEvent) ) + +#define IMFMediaEventQueue_QueueEventParamVar(This,met,guidExtendedType,hrStatus,pvValue) \ + ( (This)->lpVtbl -> QueueEventParamVar(This,met,guidExtendedType,hrStatus,pvValue) ) + +#define IMFMediaEventQueue_QueueEventParamUnk(This,met,guidExtendedType,hrStatus,pUnk) \ + ( (This)->lpVtbl -> QueueEventParamUnk(This,met,guidExtendedType,hrStatus,pUnk) ) + +#define IMFMediaEventQueue_Shutdown(This) \ + ( (This)->lpVtbl -> Shutdown(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMediaEventQueue_INTERFACE_DEFINED__ */ + + +#ifndef __IMFActivate_INTERFACE_DEFINED__ +#define __IMFActivate_INTERFACE_DEFINED__ + +/* interface IMFActivate */ +/* [unique][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFActivate; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("7FEE9E9A-4A89-47a6-899C-B6A53A70FB67") + IMFActivate : public IMFAttributes + { + public: + virtual HRESULT STDMETHODCALLTYPE ActivateObject( + /* [in] */ __RPC__in REFIID riid, + /* [retval][iid_is][out] */ __RPC__deref_out_opt void **ppv) = 0; + + virtual HRESULT STDMETHODCALLTYPE ShutdownObject( void) = 0; + + virtual HRESULT STDMETHODCALLTYPE DetachObject( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFActivateVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFActivate * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFActivate * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFActivate * This); + + HRESULT ( STDMETHODCALLTYPE *GetItem )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *GetItemType )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out MF_ATTRIBUTE_TYPE *pType); + + HRESULT ( STDMETHODCALLTYPE *CompareItem )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *Compare )( + __RPC__in IMFActivate * This, + __RPC__in_opt IMFAttributes *pTheirs, + MF_ATTRIBUTES_MATCH_TYPE MatchType, + /* [out] */ __RPC__out BOOL *pbResult); + + HRESULT ( STDMETHODCALLTYPE *GetUINT32 )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetUINT64 )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT64 *punValue); + + HRESULT ( STDMETHODCALLTYPE *GetDouble )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out double *pfValue); + + HRESULT ( STDMETHODCALLTYPE *GetGUID )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out GUID *pguidValue); + + HRESULT ( STDMETHODCALLTYPE *GetStringLength )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetString )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cchBufSize) LPWSTR pwszValue, + UINT32 cchBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedString )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(( *pcchLength + 1 ) ) LPWSTR *ppwszValue, + /* [out] */ __RPC__out UINT32 *pcchLength); + + HRESULT ( STDMETHODCALLTYPE *GetBlobSize )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [out] */ __RPC__out UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetBlob )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [size_is][out] */ __RPC__out_ecount_full(cbBufSize) UINT8 *pBuf, + UINT32 cbBufSize, + /* [full][out][in] */ __RPC__inout_opt UINT32 *pcbBlobSize); + + HRESULT ( STDMETHODCALLTYPE *GetAllocatedBlob )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbSize) UINT8 **ppBuf, + /* [out] */ __RPC__out UINT32 *pcbSize); + + HRESULT ( STDMETHODCALLTYPE *GetUnknown )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + __RPC__in REFIID riid, + /* [iid_is][out] */ __RPC__deref_out_opt LPVOID *ppv); + + HRESULT ( STDMETHODCALLTYPE *SetItem )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + __RPC__in REFPROPVARIANT Value); + + HRESULT ( STDMETHODCALLTYPE *DeleteItem )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey); + + HRESULT ( STDMETHODCALLTYPE *DeleteAllItems )( + __RPC__in IMFActivate * This); + + HRESULT ( STDMETHODCALLTYPE *SetUINT32 )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + UINT32 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetUINT64 )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + UINT64 unValue); + + HRESULT ( STDMETHODCALLTYPE *SetDouble )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + double fValue); + + HRESULT ( STDMETHODCALLTYPE *SetGUID )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + __RPC__in REFGUID guidValue); + + HRESULT ( STDMETHODCALLTYPE *SetString )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [string][in] */ __RPC__in_string LPCWSTR wszValue); + + HRESULT ( STDMETHODCALLTYPE *SetBlob )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [size_is][in] */ __RPC__in_ecount_full(cbBufSize) const UINT8 *pBuf, + UINT32 cbBufSize); + + HRESULT ( STDMETHODCALLTYPE *SetUnknown )( + __RPC__in IMFActivate * This, + __RPC__in REFGUID guidKey, + /* [in] */ __RPC__in_opt IUnknown *pUnknown); + + HRESULT ( STDMETHODCALLTYPE *LockStore )( + __RPC__in IMFActivate * This); + + HRESULT ( STDMETHODCALLTYPE *UnlockStore )( + __RPC__in IMFActivate * This); + + HRESULT ( STDMETHODCALLTYPE *GetCount )( + __RPC__in IMFActivate * This, + /* [out] */ __RPC__out UINT32 *pcItems); + + HRESULT ( STDMETHODCALLTYPE *GetItemByIndex )( + __RPC__in IMFActivate * This, + UINT32 unIndex, + /* [out] */ __RPC__out GUID *pguidKey, + /* [full][out][in] */ __RPC__inout_opt PROPVARIANT *pValue); + + HRESULT ( STDMETHODCALLTYPE *CopyAllItems )( + __RPC__in IMFActivate * This, + /* [in] */ __RPC__in_opt IMFAttributes *pDest); + + HRESULT ( STDMETHODCALLTYPE *ActivateObject )( + __RPC__in IMFActivate * This, + /* [in] */ __RPC__in REFIID riid, + /* [retval][iid_is][out] */ __RPC__deref_out_opt void **ppv); + + HRESULT ( STDMETHODCALLTYPE *ShutdownObject )( + __RPC__in IMFActivate * This); + + HRESULT ( STDMETHODCALLTYPE *DetachObject )( + __RPC__in IMFActivate * This); + + END_INTERFACE + } IMFActivateVtbl; + + interface IMFActivate + { + CONST_VTBL struct IMFActivateVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFActivate_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFActivate_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFActivate_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFActivate_GetItem(This,guidKey,pValue) \ + ( (This)->lpVtbl -> GetItem(This,guidKey,pValue) ) + +#define IMFActivate_GetItemType(This,guidKey,pType) \ + ( (This)->lpVtbl -> GetItemType(This,guidKey,pType) ) + +#define IMFActivate_CompareItem(This,guidKey,Value,pbResult) \ + ( (This)->lpVtbl -> CompareItem(This,guidKey,Value,pbResult) ) + +#define IMFActivate_Compare(This,pTheirs,MatchType,pbResult) \ + ( (This)->lpVtbl -> Compare(This,pTheirs,MatchType,pbResult) ) + +#define IMFActivate_GetUINT32(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT32(This,guidKey,punValue) ) + +#define IMFActivate_GetUINT64(This,guidKey,punValue) \ + ( (This)->lpVtbl -> GetUINT64(This,guidKey,punValue) ) + +#define IMFActivate_GetDouble(This,guidKey,pfValue) \ + ( (This)->lpVtbl -> GetDouble(This,guidKey,pfValue) ) + +#define IMFActivate_GetGUID(This,guidKey,pguidValue) \ + ( (This)->lpVtbl -> GetGUID(This,guidKey,pguidValue) ) + +#define IMFActivate_GetStringLength(This,guidKey,pcchLength) \ + ( (This)->lpVtbl -> GetStringLength(This,guidKey,pcchLength) ) + +#define IMFActivate_GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) \ + ( (This)->lpVtbl -> GetString(This,guidKey,pwszValue,cchBufSize,pcchLength) ) + +#define IMFActivate_GetAllocatedString(This,guidKey,ppwszValue,pcchLength) \ + ( (This)->lpVtbl -> GetAllocatedString(This,guidKey,ppwszValue,pcchLength) ) + +#define IMFActivate_GetBlobSize(This,guidKey,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlobSize(This,guidKey,pcbBlobSize) ) + +#define IMFActivate_GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) \ + ( (This)->lpVtbl -> GetBlob(This,guidKey,pBuf,cbBufSize,pcbBlobSize) ) + +#define IMFActivate_GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) \ + ( (This)->lpVtbl -> GetAllocatedBlob(This,guidKey,ppBuf,pcbSize) ) + +#define IMFActivate_GetUnknown(This,guidKey,riid,ppv) \ + ( (This)->lpVtbl -> GetUnknown(This,guidKey,riid,ppv) ) + +#define IMFActivate_SetItem(This,guidKey,Value) \ + ( (This)->lpVtbl -> SetItem(This,guidKey,Value) ) + +#define IMFActivate_DeleteItem(This,guidKey) \ + ( (This)->lpVtbl -> DeleteItem(This,guidKey) ) + +#define IMFActivate_DeleteAllItems(This) \ + ( (This)->lpVtbl -> DeleteAllItems(This) ) + +#define IMFActivate_SetUINT32(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT32(This,guidKey,unValue) ) + +#define IMFActivate_SetUINT64(This,guidKey,unValue) \ + ( (This)->lpVtbl -> SetUINT64(This,guidKey,unValue) ) + +#define IMFActivate_SetDouble(This,guidKey,fValue) \ + ( (This)->lpVtbl -> SetDouble(This,guidKey,fValue) ) + +#define IMFActivate_SetGUID(This,guidKey,guidValue) \ + ( (This)->lpVtbl -> SetGUID(This,guidKey,guidValue) ) + +#define IMFActivate_SetString(This,guidKey,wszValue) \ + ( (This)->lpVtbl -> SetString(This,guidKey,wszValue) ) + +#define IMFActivate_SetBlob(This,guidKey,pBuf,cbBufSize) \ + ( (This)->lpVtbl -> SetBlob(This,guidKey,pBuf,cbBufSize) ) + +#define IMFActivate_SetUnknown(This,guidKey,pUnknown) \ + ( (This)->lpVtbl -> SetUnknown(This,guidKey,pUnknown) ) + +#define IMFActivate_LockStore(This) \ + ( (This)->lpVtbl -> LockStore(This) ) + +#define IMFActivate_UnlockStore(This) \ + ( (This)->lpVtbl -> UnlockStore(This) ) + +#define IMFActivate_GetCount(This,pcItems) \ + ( (This)->lpVtbl -> GetCount(This,pcItems) ) + +#define IMFActivate_GetItemByIndex(This,unIndex,pguidKey,pValue) \ + ( (This)->lpVtbl -> GetItemByIndex(This,unIndex,pguidKey,pValue) ) + +#define IMFActivate_CopyAllItems(This,pDest) \ + ( (This)->lpVtbl -> CopyAllItems(This,pDest) ) + + +#define IMFActivate_ActivateObject(This,riid,ppv) \ + ( (This)->lpVtbl -> ActivateObject(This,riid,ppv) ) + +#define IMFActivate_ShutdownObject(This) \ + ( (This)->lpVtbl -> ShutdownObject(This) ) + +#define IMFActivate_DetachObject(This) \ + ( (This)->lpVtbl -> DetachObject(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFActivate_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0021 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +typedef +enum _MF_Plugin_Type + { + MF_Plugin_Type_MFT = 0, + MF_Plugin_Type_MediaSource = 1, + MF_Plugin_Type_MFT_MatchOutputType = 2, + MF_Plugin_Type_Other = ( DWORD )-1 + } MF_Plugin_Type; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0021_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0021_v0_0_s_ifspec; + +#ifndef __IMFPluginControl_INTERFACE_DEFINED__ +#define __IMFPluginControl_INTERFACE_DEFINED__ + +/* interface IMFPluginControl */ +/* [unique][helpstring][uuid][local][object] */ + + +EXTERN_C const IID IID_IMFPluginControl; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("5c6c44bf-1db6-435b-9249-e8cd10fdec96") + IMFPluginControl : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetPreferredClsid( + DWORD pluginType, + /* [annotation] */ + _In_ LPCWSTR selector, + /* [annotation] */ + _Out_ CLSID *clsid) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetPreferredClsidByIndex( + DWORD pluginType, + DWORD index, + /* [annotation] */ + _Out_ LPWSTR *selector, + /* [annotation] */ + _Out_ CLSID *clsid) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetPreferredClsid( + DWORD pluginType, + /* [annotation] */ + _In_ LPCWSTR selector, + /* [annotation] */ + _In_opt_ const CLSID *clsid) = 0; + + virtual HRESULT STDMETHODCALLTYPE IsDisabled( + DWORD pluginType, + REFCLSID clsid) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetDisabledByIndex( + DWORD pluginType, + DWORD index, + /* [annotation] */ + _Out_ CLSID *clsid) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetDisabled( + DWORD pluginType, + REFCLSID clsid, + BOOL disabled) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFPluginControlVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFPluginControl * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFPluginControl * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFPluginControl * This); + + HRESULT ( STDMETHODCALLTYPE *GetPreferredClsid )( + IMFPluginControl * This, + DWORD pluginType, + /* [annotation] */ + _In_ LPCWSTR selector, + /* [annotation] */ + _Out_ CLSID *clsid); + + HRESULT ( STDMETHODCALLTYPE *GetPreferredClsidByIndex )( + IMFPluginControl * This, + DWORD pluginType, + DWORD index, + /* [annotation] */ + _Out_ LPWSTR *selector, + /* [annotation] */ + _Out_ CLSID *clsid); + + HRESULT ( STDMETHODCALLTYPE *SetPreferredClsid )( + IMFPluginControl * This, + DWORD pluginType, + /* [annotation] */ + _In_ LPCWSTR selector, + /* [annotation] */ + _In_opt_ const CLSID *clsid); + + HRESULT ( STDMETHODCALLTYPE *IsDisabled )( + IMFPluginControl * This, + DWORD pluginType, + REFCLSID clsid); + + HRESULT ( STDMETHODCALLTYPE *GetDisabledByIndex )( + IMFPluginControl * This, + DWORD pluginType, + DWORD index, + /* [annotation] */ + _Out_ CLSID *clsid); + + HRESULT ( STDMETHODCALLTYPE *SetDisabled )( + IMFPluginControl * This, + DWORD pluginType, + REFCLSID clsid, + BOOL disabled); + + END_INTERFACE + } IMFPluginControlVtbl; + + interface IMFPluginControl + { + CONST_VTBL struct IMFPluginControlVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFPluginControl_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFPluginControl_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFPluginControl_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFPluginControl_GetPreferredClsid(This,pluginType,selector,clsid) \ + ( (This)->lpVtbl -> GetPreferredClsid(This,pluginType,selector,clsid) ) + +#define IMFPluginControl_GetPreferredClsidByIndex(This,pluginType,index,selector,clsid) \ + ( (This)->lpVtbl -> GetPreferredClsidByIndex(This,pluginType,index,selector,clsid) ) + +#define IMFPluginControl_SetPreferredClsid(This,pluginType,selector,clsid) \ + ( (This)->lpVtbl -> SetPreferredClsid(This,pluginType,selector,clsid) ) + +#define IMFPluginControl_IsDisabled(This,pluginType,clsid) \ + ( (This)->lpVtbl -> IsDisabled(This,pluginType,clsid) ) + +#define IMFPluginControl_GetDisabledByIndex(This,pluginType,index,clsid) \ + ( (This)->lpVtbl -> GetDisabledByIndex(This,pluginType,index,clsid) ) + +#define IMFPluginControl_SetDisabled(This,pluginType,clsid,disabled) \ + ( (This)->lpVtbl -> SetDisabled(This,pluginType,clsid,disabled) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFPluginControl_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0022 */ +/* [local] */ + +typedef +enum MF_PLUGIN_CONTROL_POLICY + { + MF_PLUGIN_CONTROL_POLICY_USE_ALL_PLUGINS = 0, + MF_PLUGIN_CONTROL_POLICY_USE_APPROVED_PLUGINS = 1, + MF_PLUGIN_CONTROL_POLICY_USE_WEB_PLUGINS = 2, + MF_PLUGIN_CONTROL_POLICY_USE_WEB_PLUGINS_EDGEMODE = 3 + } MF_PLUGIN_CONTROL_POLICY; + + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0022_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0022_v0_0_s_ifspec; + +#ifndef __IMFPluginControl2_INTERFACE_DEFINED__ +#define __IMFPluginControl2_INTERFACE_DEFINED__ + +/* interface IMFPluginControl2 */ +/* [unique][helpstring][uuid][local][object] */ + + +EXTERN_C const IID IID_IMFPluginControl2; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("C6982083-3DDC-45CB-AF5E-0F7A8CE4DE77") + IMFPluginControl2 : public IMFPluginControl + { + public: + virtual HRESULT STDMETHODCALLTYPE SetPolicy( + /* [in] */ MF_PLUGIN_CONTROL_POLICY policy) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFPluginControl2Vtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFPluginControl2 * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFPluginControl2 * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFPluginControl2 * This); + + HRESULT ( STDMETHODCALLTYPE *GetPreferredClsid )( + IMFPluginControl2 * This, + DWORD pluginType, + /* [annotation] */ + _In_ LPCWSTR selector, + /* [annotation] */ + _Out_ CLSID *clsid); + + HRESULT ( STDMETHODCALLTYPE *GetPreferredClsidByIndex )( + IMFPluginControl2 * This, + DWORD pluginType, + DWORD index, + /* [annotation] */ + _Out_ LPWSTR *selector, + /* [annotation] */ + _Out_ CLSID *clsid); + + HRESULT ( STDMETHODCALLTYPE *SetPreferredClsid )( + IMFPluginControl2 * This, + DWORD pluginType, + /* [annotation] */ + _In_ LPCWSTR selector, + /* [annotation] */ + _In_opt_ const CLSID *clsid); + + HRESULT ( STDMETHODCALLTYPE *IsDisabled )( + IMFPluginControl2 * This, + DWORD pluginType, + REFCLSID clsid); + + HRESULT ( STDMETHODCALLTYPE *GetDisabledByIndex )( + IMFPluginControl2 * This, + DWORD pluginType, + DWORD index, + /* [annotation] */ + _Out_ CLSID *clsid); + + HRESULT ( STDMETHODCALLTYPE *SetDisabled )( + IMFPluginControl2 * This, + DWORD pluginType, + REFCLSID clsid, + BOOL disabled); + + HRESULT ( STDMETHODCALLTYPE *SetPolicy )( + IMFPluginControl2 * This, + /* [in] */ MF_PLUGIN_CONTROL_POLICY policy); + + END_INTERFACE + } IMFPluginControl2Vtbl; + + interface IMFPluginControl2 + { + CONST_VTBL struct IMFPluginControl2Vtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFPluginControl2_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFPluginControl2_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFPluginControl2_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFPluginControl2_GetPreferredClsid(This,pluginType,selector,clsid) \ + ( (This)->lpVtbl -> GetPreferredClsid(This,pluginType,selector,clsid) ) + +#define IMFPluginControl2_GetPreferredClsidByIndex(This,pluginType,index,selector,clsid) \ + ( (This)->lpVtbl -> GetPreferredClsidByIndex(This,pluginType,index,selector,clsid) ) + +#define IMFPluginControl2_SetPreferredClsid(This,pluginType,selector,clsid) \ + ( (This)->lpVtbl -> SetPreferredClsid(This,pluginType,selector,clsid) ) + +#define IMFPluginControl2_IsDisabled(This,pluginType,clsid) \ + ( (This)->lpVtbl -> IsDisabled(This,pluginType,clsid) ) + +#define IMFPluginControl2_GetDisabledByIndex(This,pluginType,index,clsid) \ + ( (This)->lpVtbl -> GetDisabledByIndex(This,pluginType,index,clsid) ) + +#define IMFPluginControl2_SetDisabled(This,pluginType,clsid,disabled) \ + ( (This)->lpVtbl -> SetDisabled(This,pluginType,clsid,disabled) ) + + +#define IMFPluginControl2_SetPolicy(This,policy) \ + ( (This)->lpVtbl -> SetPolicy(This,policy) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFPluginControl2_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0023 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0023_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0023_v0_0_s_ifspec; + +#ifndef __IMFDXGIDeviceManager_INTERFACE_DEFINED__ +#define __IMFDXGIDeviceManager_INTERFACE_DEFINED__ + +/* interface IMFDXGIDeviceManager */ +/* [unique][helpstring][uuid][local][object] */ + + +EXTERN_C const IID IID_IMFDXGIDeviceManager; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("eb533d5d-2db6-40f8-97a9-494692014f07") + IMFDXGIDeviceManager : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE CloseDeviceHandle( + /* [annotation] */ + _In_ HANDLE hDevice) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetVideoService( + /* [annotation] */ + _In_ HANDLE hDevice, + /* [annotation] */ + _In_ REFIID riid, + /* [annotation] */ + _Outptr_ void **ppService) = 0; + + virtual HRESULT STDMETHODCALLTYPE LockDevice( + /* [annotation] */ + _In_ HANDLE hDevice, + /* [annotation] */ + _In_ REFIID riid, + /* [annotation] */ + _Outptr_ void **ppUnkDevice, + /* [annotation] */ + _In_ BOOL fBlock) = 0; + + virtual HRESULT STDMETHODCALLTYPE OpenDeviceHandle( + /* [annotation] */ + _Out_ HANDLE *phDevice) = 0; + + virtual HRESULT STDMETHODCALLTYPE ResetDevice( + /* [annotation] */ + _In_ IUnknown *pUnkDevice, + /* [annotation] */ + _In_ UINT resetToken) = 0; + + virtual HRESULT STDMETHODCALLTYPE TestDevice( + /* [annotation] */ + _In_ HANDLE hDevice) = 0; + + virtual HRESULT STDMETHODCALLTYPE UnlockDevice( + /* [annotation] */ + _In_ HANDLE hDevice, + /* [annotation] */ + _In_ BOOL fSaveState) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFDXGIDeviceManagerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFDXGIDeviceManager * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFDXGIDeviceManager * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFDXGIDeviceManager * This); + + HRESULT ( STDMETHODCALLTYPE *CloseDeviceHandle )( + IMFDXGIDeviceManager * This, + /* [annotation] */ + _In_ HANDLE hDevice); + + HRESULT ( STDMETHODCALLTYPE *GetVideoService )( + IMFDXGIDeviceManager * This, + /* [annotation] */ + _In_ HANDLE hDevice, + /* [annotation] */ + _In_ REFIID riid, + /* [annotation] */ + _Outptr_ void **ppService); + + HRESULT ( STDMETHODCALLTYPE *LockDevice )( + IMFDXGIDeviceManager * This, + /* [annotation] */ + _In_ HANDLE hDevice, + /* [annotation] */ + _In_ REFIID riid, + /* [annotation] */ + _Outptr_ void **ppUnkDevice, + /* [annotation] */ + _In_ BOOL fBlock); + + HRESULT ( STDMETHODCALLTYPE *OpenDeviceHandle )( + IMFDXGIDeviceManager * This, + /* [annotation] */ + _Out_ HANDLE *phDevice); + + HRESULT ( STDMETHODCALLTYPE *ResetDevice )( + IMFDXGIDeviceManager * This, + /* [annotation] */ + _In_ IUnknown *pUnkDevice, + /* [annotation] */ + _In_ UINT resetToken); + + HRESULT ( STDMETHODCALLTYPE *TestDevice )( + IMFDXGIDeviceManager * This, + /* [annotation] */ + _In_ HANDLE hDevice); + + HRESULT ( STDMETHODCALLTYPE *UnlockDevice )( + IMFDXGIDeviceManager * This, + /* [annotation] */ + _In_ HANDLE hDevice, + /* [annotation] */ + _In_ BOOL fSaveState); + + END_INTERFACE + } IMFDXGIDeviceManagerVtbl; + + interface IMFDXGIDeviceManager + { + CONST_VTBL struct IMFDXGIDeviceManagerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFDXGIDeviceManager_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFDXGIDeviceManager_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFDXGIDeviceManager_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFDXGIDeviceManager_CloseDeviceHandle(This,hDevice) \ + ( (This)->lpVtbl -> CloseDeviceHandle(This,hDevice) ) + +#define IMFDXGIDeviceManager_GetVideoService(This,hDevice,riid,ppService) \ + ( (This)->lpVtbl -> GetVideoService(This,hDevice,riid,ppService) ) + +#define IMFDXGIDeviceManager_LockDevice(This,hDevice,riid,ppUnkDevice,fBlock) \ + ( (This)->lpVtbl -> LockDevice(This,hDevice,riid,ppUnkDevice,fBlock) ) + +#define IMFDXGIDeviceManager_OpenDeviceHandle(This,phDevice) \ + ( (This)->lpVtbl -> OpenDeviceHandle(This,phDevice) ) + +#define IMFDXGIDeviceManager_ResetDevice(This,pUnkDevice,resetToken) \ + ( (This)->lpVtbl -> ResetDevice(This,pUnkDevice,resetToken) ) + +#define IMFDXGIDeviceManager_TestDevice(This,hDevice) \ + ( (This)->lpVtbl -> TestDevice(This,hDevice) ) + +#define IMFDXGIDeviceManager_UnlockDevice(This,hDevice,fSaveState) \ + ( (This)->lpVtbl -> UnlockDevice(This,hDevice,fSaveState) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFDXGIDeviceManager_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0024 */ +/* [local] */ + +typedef +enum _MF_STREAM_STATE + { + MF_STREAM_STATE_STOPPED = 0, + MF_STREAM_STATE_PAUSED = ( MF_STREAM_STATE_STOPPED + 1 ) , + MF_STREAM_STATE_RUNNING = ( MF_STREAM_STATE_PAUSED + 1 ) + } MF_STREAM_STATE; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +#if (NTDDI_VERSION >= NTDDI_WIN10_RS2) + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0024_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0024_v0_0_s_ifspec; + +#ifndef __IMFMuxStreamAttributesManager_INTERFACE_DEFINED__ +#define __IMFMuxStreamAttributesManager_INTERFACE_DEFINED__ + +/* interface IMFMuxStreamAttributesManager */ +/* [unique][helpstring][uuid][local][object] */ + + +EXTERN_C const IID IID_IMFMuxStreamAttributesManager; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("CE8BD576-E440-43B3-BE34-1E53F565F7E8") + IMFMuxStreamAttributesManager : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetStreamCount( + /* [annotation] */ + _Out_ DWORD *pdwMuxStreamCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAttributes( + /* [annotation] */ + _In_ DWORD dwMuxStreamIndex, + /* [annotation] */ + _COM_Outptr_ IMFAttributes **ppStreamAttributes) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMuxStreamAttributesManagerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMuxStreamAttributesManager * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMuxStreamAttributesManager * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMuxStreamAttributesManager * This); + + HRESULT ( STDMETHODCALLTYPE *GetStreamCount )( + IMFMuxStreamAttributesManager * This, + /* [annotation] */ + _Out_ DWORD *pdwMuxStreamCount); + + HRESULT ( STDMETHODCALLTYPE *GetAttributes )( + IMFMuxStreamAttributesManager * This, + /* [annotation] */ + _In_ DWORD dwMuxStreamIndex, + /* [annotation] */ + _COM_Outptr_ IMFAttributes **ppStreamAttributes); + + END_INTERFACE + } IMFMuxStreamAttributesManagerVtbl; + + interface IMFMuxStreamAttributesManager + { + CONST_VTBL struct IMFMuxStreamAttributesManagerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMuxStreamAttributesManager_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMuxStreamAttributesManager_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMuxStreamAttributesManager_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMuxStreamAttributesManager_GetStreamCount(This,pdwMuxStreamCount) \ + ( (This)->lpVtbl -> GetStreamCount(This,pdwMuxStreamCount) ) + +#define IMFMuxStreamAttributesManager_GetAttributes(This,dwMuxStreamIndex,ppStreamAttributes) \ + ( (This)->lpVtbl -> GetAttributes(This,dwMuxStreamIndex,ppStreamAttributes) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMuxStreamAttributesManager_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMuxStreamMediaTypeManager_INTERFACE_DEFINED__ +#define __IMFMuxStreamMediaTypeManager_INTERFACE_DEFINED__ + +/* interface IMFMuxStreamMediaTypeManager */ +/* [unique][helpstring][uuid][local][object] */ + + +EXTERN_C const IID IID_IMFMuxStreamMediaTypeManager; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("505A2C72-42F7-4690-AEAB-8F513D0FFDB8") + IMFMuxStreamMediaTypeManager : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetStreamCount( + /* [annotation] */ + _Out_ DWORD *pdwMuxStreamCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetMediaType( + /* [annotation] */ + _In_ DWORD dwMuxStreamIndex, + /* [annotation] */ + _COM_Outptr_ IMFMediaType **ppMediaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamConfigurationCount( + /* [annotation] */ + _Out_ DWORD *pdwCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddStreamConfiguration( + /* [annotation] */ + _In_ ULONGLONG ullStreamMask) = 0; + + virtual HRESULT STDMETHODCALLTYPE RemoveStreamConfiguration( + /* [annotation] */ + _In_ ULONGLONG ullStreamMask) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamConfiguration( + /* [annotation] */ + _In_ DWORD ulIndex, + /* [annotation] */ + _Out_ ULONGLONG *pullStreamMask) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMuxStreamMediaTypeManagerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMuxStreamMediaTypeManager * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMuxStreamMediaTypeManager * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMuxStreamMediaTypeManager * This); + + HRESULT ( STDMETHODCALLTYPE *GetStreamCount )( + IMFMuxStreamMediaTypeManager * This, + /* [annotation] */ + _Out_ DWORD *pdwMuxStreamCount); + + HRESULT ( STDMETHODCALLTYPE *GetMediaType )( + IMFMuxStreamMediaTypeManager * This, + /* [annotation] */ + _In_ DWORD dwMuxStreamIndex, + /* [annotation] */ + _COM_Outptr_ IMFMediaType **ppMediaType); + + HRESULT ( STDMETHODCALLTYPE *GetStreamConfigurationCount )( + IMFMuxStreamMediaTypeManager * This, + /* [annotation] */ + _Out_ DWORD *pdwCount); + + HRESULT ( STDMETHODCALLTYPE *AddStreamConfiguration )( + IMFMuxStreamMediaTypeManager * This, + /* [annotation] */ + _In_ ULONGLONG ullStreamMask); + + HRESULT ( STDMETHODCALLTYPE *RemoveStreamConfiguration )( + IMFMuxStreamMediaTypeManager * This, + /* [annotation] */ + _In_ ULONGLONG ullStreamMask); + + HRESULT ( STDMETHODCALLTYPE *GetStreamConfiguration )( + IMFMuxStreamMediaTypeManager * This, + /* [annotation] */ + _In_ DWORD ulIndex, + /* [annotation] */ + _Out_ ULONGLONG *pullStreamMask); + + END_INTERFACE + } IMFMuxStreamMediaTypeManagerVtbl; + + interface IMFMuxStreamMediaTypeManager + { + CONST_VTBL struct IMFMuxStreamMediaTypeManagerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMuxStreamMediaTypeManager_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMuxStreamMediaTypeManager_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMuxStreamMediaTypeManager_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMuxStreamMediaTypeManager_GetStreamCount(This,pdwMuxStreamCount) \ + ( (This)->lpVtbl -> GetStreamCount(This,pdwMuxStreamCount) ) + +#define IMFMuxStreamMediaTypeManager_GetMediaType(This,dwMuxStreamIndex,ppMediaType) \ + ( (This)->lpVtbl -> GetMediaType(This,dwMuxStreamIndex,ppMediaType) ) + +#define IMFMuxStreamMediaTypeManager_GetStreamConfigurationCount(This,pdwCount) \ + ( (This)->lpVtbl -> GetStreamConfigurationCount(This,pdwCount) ) + +#define IMFMuxStreamMediaTypeManager_AddStreamConfiguration(This,ullStreamMask) \ + ( (This)->lpVtbl -> AddStreamConfiguration(This,ullStreamMask) ) + +#define IMFMuxStreamMediaTypeManager_RemoveStreamConfiguration(This,ullStreamMask) \ + ( (This)->lpVtbl -> RemoveStreamConfiguration(This,ullStreamMask) ) + +#define IMFMuxStreamMediaTypeManager_GetStreamConfiguration(This,ulIndex,pullStreamMask) \ + ( (This)->lpVtbl -> GetStreamConfiguration(This,ulIndex,pullStreamMask) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMuxStreamMediaTypeManager_INTERFACE_DEFINED__ */ + + +#ifndef __IMFMuxStreamSampleManager_INTERFACE_DEFINED__ +#define __IMFMuxStreamSampleManager_INTERFACE_DEFINED__ + +/* interface IMFMuxStreamSampleManager */ +/* [unique][helpstring][uuid][local][object] */ + + +EXTERN_C const IID IID_IMFMuxStreamSampleManager; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("74ABBC19-B1CC-4E41-BB8B-9D9B86A8F6CA") + IMFMuxStreamSampleManager : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetStreamCount( + /* [annotation] */ + _Out_ DWORD *pdwMuxStreamCount) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetSample( + /* [annotation] */ + _In_ DWORD dwMuxStreamIndex, + /* [annotation] */ + _COM_Outptr_ IMFSample **ppSample) = 0; + + virtual ULONGLONG STDMETHODCALLTYPE GetStreamConfiguration( void) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFMuxStreamSampleManagerVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFMuxStreamSampleManager * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFMuxStreamSampleManager * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFMuxStreamSampleManager * This); + + HRESULT ( STDMETHODCALLTYPE *GetStreamCount )( + IMFMuxStreamSampleManager * This, + /* [annotation] */ + _Out_ DWORD *pdwMuxStreamCount); + + HRESULT ( STDMETHODCALLTYPE *GetSample )( + IMFMuxStreamSampleManager * This, + /* [annotation] */ + _In_ DWORD dwMuxStreamIndex, + /* [annotation] */ + _COM_Outptr_ IMFSample **ppSample); + + ULONGLONG ( STDMETHODCALLTYPE *GetStreamConfiguration )( + IMFMuxStreamSampleManager * This); + + END_INTERFACE + } IMFMuxStreamSampleManagerVtbl; + + interface IMFMuxStreamSampleManager + { + CONST_VTBL struct IMFMuxStreamSampleManagerVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFMuxStreamSampleManager_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFMuxStreamSampleManager_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFMuxStreamSampleManager_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFMuxStreamSampleManager_GetStreamCount(This,pdwMuxStreamCount) \ + ( (This)->lpVtbl -> GetStreamCount(This,pdwMuxStreamCount) ) + +#define IMFMuxStreamSampleManager_GetSample(This,dwMuxStreamIndex,ppSample) \ + ( (This)->lpVtbl -> GetSample(This,dwMuxStreamIndex,ppSample) ) + +#define IMFMuxStreamSampleManager_GetStreamConfiguration(This) \ + ( (This)->lpVtbl -> GetStreamConfiguration(This) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFMuxStreamSampleManager_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mfobjects_0000_0027 */ +/* [local] */ + +#endif // (WINVER >=_WIN32_WINNT_WIN10_RS2) +#endif // WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +#pragma endregion + + +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0027_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mfobjects_0000_0027_v0_0_s_ifspec; + +/* Additional Prototypes for ALL interfaces */ + +unsigned long __RPC_USER BSTR_UserSize( __RPC__in unsigned long *, unsigned long , __RPC__in BSTR * ); +unsigned char * __RPC_USER BSTR_UserMarshal( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * ); +unsigned char * __RPC_USER BSTR_UserUnmarshal(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * ); +void __RPC_USER BSTR_UserFree( __RPC__in unsigned long *, __RPC__in BSTR * ); + +unsigned long __RPC_USER LPSAFEARRAY_UserSize( __RPC__in unsigned long *, unsigned long , __RPC__in LPSAFEARRAY * ); +unsigned char * __RPC_USER LPSAFEARRAY_UserMarshal( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in LPSAFEARRAY * ); +unsigned char * __RPC_USER LPSAFEARRAY_UserUnmarshal(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out LPSAFEARRAY * ); +void __RPC_USER LPSAFEARRAY_UserFree( __RPC__in unsigned long *, __RPC__in LPSAFEARRAY * ); + +unsigned long __RPC_USER BSTR_UserSize64( __RPC__in unsigned long *, unsigned long , __RPC__in BSTR * ); +unsigned char * __RPC_USER BSTR_UserMarshal64( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in BSTR * ); +unsigned char * __RPC_USER BSTR_UserUnmarshal64(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out BSTR * ); +void __RPC_USER BSTR_UserFree64( __RPC__in unsigned long *, __RPC__in BSTR * ); + +unsigned long __RPC_USER LPSAFEARRAY_UserSize64( __RPC__in unsigned long *, unsigned long , __RPC__in LPSAFEARRAY * ); +unsigned char * __RPC_USER LPSAFEARRAY_UserMarshal64( __RPC__in unsigned long *, __RPC__inout_xcount(0) unsigned char *, __RPC__in LPSAFEARRAY * ); +unsigned char * __RPC_USER LPSAFEARRAY_UserUnmarshal64(__RPC__in unsigned long *, __RPC__in_xcount(0) unsigned char *, __RPC__out LPSAFEARRAY * ); +void __RPC_USER LPSAFEARRAY_UserFree64( __RPC__in unsigned long *, __RPC__in LPSAFEARRAY * ); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFMediaEventGenerator_BeginGetEvent_Proxy( + IMFMediaEventGenerator * This, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaEventGenerator_BeginGetEvent_Stub( + __RPC__in IMFMediaEventGenerator * This, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFMediaEventGenerator_EndGetEvent_Proxy( + IMFMediaEventGenerator * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ IMFMediaEvent **ppEvent); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFMediaEventGenerator_EndGetEvent_Stub( + __RPC__in IMFMediaEventGenerator * This, + /* [in] */ __RPC__in_opt IUnknown *pResult, + /* [out] */ __RPC__out DWORD *pcbEvent, + /* [size_is][size_is][out] */ __RPC__deref_out_ecount_full_opt(*pcbEvent) BYTE **ppbEvent); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFByteStream_BeginRead_Proxy( + IMFByteStream * This, + /* [annotation][out] */ + _Out_writes_bytes_(cb) BYTE *pb, + /* [in] */ ULONG cb, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFByteStream_BeginRead_Stub( + __RPC__in IMFByteStream * This, + /* [in] */ ULONG cb, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFByteStream_EndRead_Proxy( + IMFByteStream * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ ULONG *pcbRead); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFByteStream_EndRead_Stub( + __RPC__in IMFByteStream * This, + /* [in] */ __RPC__in_opt IUnknown *punkResult, + /* [length_is][size_is][out][in] */ __RPC__inout_ecount_part(cb, *pcbRead) BYTE *pb, + /* [in] */ ULONG cb, + /* [out][in] */ __RPC__inout ULONG *pcbRead); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFByteStream_BeginWrite_Proxy( + IMFByteStream * This, + /* [annotation][in] */ + _In_reads_bytes_(cb) const BYTE *pb, + /* [in] */ ULONG cb, + /* [in] */ IMFAsyncCallback *pCallback, + /* [in] */ IUnknown *punkState); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFByteStream_BeginWrite_Stub( + __RPC__in IMFByteStream * This, + /* [size_is][in] */ __RPC__in_ecount_full(cb) const BYTE *pb, + /* [in] */ ULONG cb, + /* [in] */ __RPC__in_opt IMFRemoteAsyncCallback *pCallback); + +/* [local] */ HRESULT STDMETHODCALLTYPE IMFByteStream_EndWrite_Proxy( + IMFByteStream * This, + /* [in] */ IMFAsyncResult *pResult, + /* [annotation][out] */ + _Out_ ULONG *pcbWritten); + + +/* [call_as] */ HRESULT STDMETHODCALLTYPE IMFByteStream_EndWrite_Stub( + __RPC__in IMFByteStream * This, + /* [in] */ __RPC__in_opt IUnknown *punkResult, + /* [out] */ __RPC__out ULONG *pcbWritten); + + + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/util/test/demos/dx/official/mftransform.h b/util/test/demos/dx/official/mftransform.h new file mode 100644 index 000000000..b6b2c432d --- /dev/null +++ b/util/test/demos/dx/official/mftransform.h @@ -0,0 +1,1317 @@ + + +/* this ALWAYS GENERATED file contains the definitions for the interfaces */ + + + /* File created by MIDL compiler version 8.01.0622 */ +/* @@MIDL_FILE_HEADING( ) */ + + + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCNDR_H_VERSION__ +#define __REQUIRED_RPCNDR_H_VERSION__ 500 +#endif + +/* verify that the version is high enough to compile this file*/ +#ifndef __REQUIRED_RPCSAL_H_VERSION__ +#define __REQUIRED_RPCSAL_H_VERSION__ 100 +#endif + +#include "rpc.h" +#include "rpcndr.h" + +#ifndef __RPCNDR_H_VERSION__ +#error this stub requires an updated version of +#endif /* __RPCNDR_H_VERSION__ */ + +#ifndef COM_NO_WINDOWS_H +#include "windows.h" +#include "ole2.h" +#endif /*COM_NO_WINDOWS_H*/ + +#ifndef __mftransform_h__ +#define __mftransform_h__ + +#if defined(_MSC_VER) && (_MSC_VER >= 1020) +#pragma once +#endif + +/* Forward Declarations */ + +#ifndef __IMFTransform_FWD_DEFINED__ +#define __IMFTransform_FWD_DEFINED__ +typedef interface IMFTransform IMFTransform; + +#endif /* __IMFTransform_FWD_DEFINED__ */ + + +#ifndef __IMFDeviceTransform_FWD_DEFINED__ +#define __IMFDeviceTransform_FWD_DEFINED__ +typedef interface IMFDeviceTransform IMFDeviceTransform; + +#endif /* __IMFDeviceTransform_FWD_DEFINED__ */ + + +#ifndef __IMFDeviceTransformCallback_FWD_DEFINED__ +#define __IMFDeviceTransformCallback_FWD_DEFINED__ +typedef interface IMFDeviceTransformCallback IMFDeviceTransformCallback; + +#endif /* __IMFDeviceTransformCallback_FWD_DEFINED__ */ + + +/* header files for imported files */ +#include "mfobjects.h" + +#ifdef __cplusplus +extern "C"{ +#endif + + +/* interface __MIDL_itf_mftransform_0000_0000 */ +/* [local] */ + +#include "winapifamily.h" +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) + +enum _MFT_INPUT_DATA_BUFFER_FLAGS + { + MFT_INPUT_DATA_BUFFER_PLACEHOLDER = 0xffffffff + } ; + +enum _MFT_OUTPUT_DATA_BUFFER_FLAGS + { + MFT_OUTPUT_DATA_BUFFER_INCOMPLETE = 0x1000000, + MFT_OUTPUT_DATA_BUFFER_FORMAT_CHANGE = 0x100, + MFT_OUTPUT_DATA_BUFFER_STREAM_END = 0x200, + MFT_OUTPUT_DATA_BUFFER_NO_SAMPLE = 0x300 + } ; + +enum _MFT_INPUT_STATUS_FLAGS + { + MFT_INPUT_STATUS_ACCEPT_DATA = 0x1 + } ; + +enum _MFT_OUTPUT_STATUS_FLAGS + { + MFT_OUTPUT_STATUS_SAMPLE_READY = 0x1 + } ; + +enum _MFT_INPUT_STREAM_INFO_FLAGS + { + MFT_INPUT_STREAM_WHOLE_SAMPLES = 0x1, + MFT_INPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER = 0x2, + MFT_INPUT_STREAM_FIXED_SAMPLE_SIZE = 0x4, + MFT_INPUT_STREAM_HOLDS_BUFFERS = 0x8, + MFT_INPUT_STREAM_DOES_NOT_ADDREF = 0x100, + MFT_INPUT_STREAM_REMOVABLE = 0x200, + MFT_INPUT_STREAM_OPTIONAL = 0x400, + MFT_INPUT_STREAM_PROCESSES_IN_PLACE = 0x800 + } ; + +enum _MFT_OUTPUT_STREAM_INFO_FLAGS + { + MFT_OUTPUT_STREAM_WHOLE_SAMPLES = 0x1, + MFT_OUTPUT_STREAM_SINGLE_SAMPLE_PER_BUFFER = 0x2, + MFT_OUTPUT_STREAM_FIXED_SAMPLE_SIZE = 0x4, + MFT_OUTPUT_STREAM_DISCARDABLE = 0x8, + MFT_OUTPUT_STREAM_OPTIONAL = 0x10, + MFT_OUTPUT_STREAM_PROVIDES_SAMPLES = 0x100, + MFT_OUTPUT_STREAM_CAN_PROVIDE_SAMPLES = 0x200, + MFT_OUTPUT_STREAM_LAZY_READ = 0x400, + MFT_OUTPUT_STREAM_REMOVABLE = 0x800 + } ; + +enum _MFT_SET_TYPE_FLAGS + { + MFT_SET_TYPE_TEST_ONLY = 0x1 + } ; + +enum _MFT_PROCESS_OUTPUT_FLAGS + { + MFT_PROCESS_OUTPUT_DISCARD_WHEN_NO_BUFFER = 0x1, + MFT_PROCESS_OUTPUT_REGENERATE_LAST_OUTPUT = 0x2 + } ; + +enum _MFT_PROCESS_OUTPUT_STATUS + { + MFT_PROCESS_OUTPUT_STATUS_NEW_STREAMS = 0x100 + } ; + +enum _MFT_DRAIN_TYPE + { + MFT_DRAIN_PRODUCE_TAILS = 0, + MFT_DRAIN_NO_TAILS = 0x1 + } ; +#define MFT_STREAMS_UNLIMITED 0xFFFFFFFF +#define MFT_OUTPUT_BOUND_LOWER_UNBOUNDED MINLONGLONG +#define MFT_OUTPUT_BOUND_UPPER_UNBOUNDED MAXLONGLONG +typedef /* [v1_enum] */ +enum _MFT_MESSAGE_TYPE + { + MFT_MESSAGE_COMMAND_FLUSH = 0, + MFT_MESSAGE_COMMAND_DRAIN = 0x1, + MFT_MESSAGE_SET_D3D_MANAGER = 0x2, + MFT_MESSAGE_DROP_SAMPLES = 0x3, + MFT_MESSAGE_COMMAND_TICK = 0x4, + MFT_MESSAGE_NOTIFY_BEGIN_STREAMING = 0x10000000, + MFT_MESSAGE_NOTIFY_END_STREAMING = 0x10000001, + MFT_MESSAGE_NOTIFY_END_OF_STREAM = 0x10000002, + MFT_MESSAGE_NOTIFY_START_OF_STREAM = 0x10000003, + MFT_MESSAGE_NOTIFY_RELEASE_RESOURCES = 0x10000004, + MFT_MESSAGE_NOTIFY_REACQUIRE_RESOURCES = 0x10000005, + MFT_MESSAGE_NOTIFY_EVENT = 0x10000006, + MFT_MESSAGE_COMMAND_SET_OUTPUT_STREAM_STATE = 0x10000007, + MFT_MESSAGE_COMMAND_FLUSH_OUTPUT_STREAM = 0x10000008, + MFT_MESSAGE_COMMAND_MARKER = 0x20000000 + } MFT_MESSAGE_TYPE; + +typedef struct _MFT_INPUT_STREAM_INFO + { + LONGLONG hnsMaxLatency; + DWORD dwFlags; + DWORD cbSize; + DWORD cbMaxLookahead; + DWORD cbAlignment; + } MFT_INPUT_STREAM_INFO; + +typedef struct _MFT_OUTPUT_STREAM_INFO + { + DWORD dwFlags; + DWORD cbSize; + DWORD cbAlignment; + } MFT_OUTPUT_STREAM_INFO; + +typedef struct _MFT_OUTPUT_DATA_BUFFER + { + DWORD dwStreamID; + IMFSample *pSample; + DWORD dwStatus; + IMFCollection *pEvents; + } MFT_OUTPUT_DATA_BUFFER; + +typedef struct _MFT_OUTPUT_DATA_BUFFER *PMFT_OUTPUT_DATA_BUFFER; + +// +// redefine all the method names to have MFT at the beginning so they don't class with DMO methods. +// +#ifdef MFT_UNIQUE_METHOD_NAMES +#define GetStreamLimits MFTGetStreamLimits +#define GetStreamCount MFTGetStreamCount +#define GetStreamIDs MFTGetStreamIDs +#define GetInputStreamInfo MFTGetInputStreamInfo +#define GetOutputStreamInfo MFTGetOutputStreamInfo +#define DeleteInputStream MFTDeleteInputStream +#define AddInputStreams MFTAddInputStreams +#define GetInputAvailableType MFTGetInputAvailableType +#define GetOutputAvailableType MFTGetOutputAvailableType +#define SetInputType MFTSetInputType +#define SetOutputType MFTSetOutputType +#define GetInputCurrentType MFTGetInputCurrentType +#define GetOutputCurrentType MFTGetOutputCurrentType +#define GetInputStatus MFTGetInputStatus +#define GetOutputStatus MFTGetOutputStatus +#define SetOutputBounds MFTSetOutputBounds +#define ProcessEvent MFTProcessEvent +#define ProcessMessage MFTProcessMessage +#define ProcessInput MFTProcessInput +#define ProcessOutput MFTProcessOutput +#endif + + +extern RPC_IF_HANDLE __MIDL_itf_mftransform_0000_0000_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mftransform_0000_0000_v0_0_s_ifspec; + +#ifndef __IMFTransform_INTERFACE_DEFINED__ +#define __IMFTransform_INTERFACE_DEFINED__ + +/* interface IMFTransform */ +/* [uuid][object] */ + + +EXTERN_C const IID IID_IMFTransform; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("bf94c121-5b05-4e6f-8000-ba598961414d") + IMFTransform : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE GetStreamLimits( + /* [out] */ __RPC__out DWORD *pdwInputMinimum, + /* [out] */ __RPC__out DWORD *pdwInputMaximum, + /* [out] */ __RPC__out DWORD *pdwOutputMinimum, + /* [out] */ __RPC__out DWORD *pdwOutputMaximum) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamCount( + /* [out] */ __RPC__out DWORD *pcInputStreams, + /* [out] */ __RPC__out DWORD *pcOutputStreams) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamIDs( + DWORD dwInputIDArraySize, + /* [size_is][out] */ __RPC__out_ecount_full(dwInputIDArraySize) DWORD *pdwInputIDs, + DWORD dwOutputIDArraySize, + /* [size_is][out] */ __RPC__out_ecount_full(dwOutputIDArraySize) DWORD *pdwOutputIDs) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputStreamInfo( + DWORD dwInputStreamID, + /* [out] */ __RPC__out MFT_INPUT_STREAM_INFO *pStreamInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputStreamInfo( + DWORD dwOutputStreamID, + /* [out] */ __RPC__out MFT_OUTPUT_STREAM_INFO *pStreamInfo) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetAttributes( + /* [out] */ __RPC__deref_out_opt IMFAttributes **pAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputStreamAttributes( + DWORD dwInputStreamID, + /* [out] */ __RPC__deref_out_opt IMFAttributes **pAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputStreamAttributes( + DWORD dwOutputStreamID, + /* [out] */ __RPC__deref_out_opt IMFAttributes **pAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE DeleteInputStream( + DWORD dwStreamID) = 0; + + virtual HRESULT STDMETHODCALLTYPE AddInputStreams( + DWORD cStreams, + /* [in] */ __RPC__in DWORD *adwStreamIDs) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputAvailableType( + DWORD dwInputStreamID, + DWORD dwTypeIndex, + /* [out] */ __RPC__deref_out_opt IMFMediaType **ppType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputAvailableType( + DWORD dwOutputStreamID, + DWORD dwTypeIndex, + /* [out] */ __RPC__deref_out_opt IMFMediaType **ppType) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInputType( + DWORD dwInputStreamID, + /* [in] */ __RPC__in_opt IMFMediaType *pType, + DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetOutputType( + DWORD dwOutputStreamID, + /* [in] */ __RPC__in_opt IMFMediaType *pType, + DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputCurrentType( + DWORD dwInputStreamID, + /* [out] */ __RPC__deref_out_opt IMFMediaType **ppType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputCurrentType( + DWORD dwOutputStreamID, + /* [out] */ __RPC__deref_out_opt IMFMediaType **ppType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputStatus( + DWORD dwInputStreamID, + /* [out] */ __RPC__out DWORD *pdwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputStatus( + /* [out] */ __RPC__out DWORD *pdwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetOutputBounds( + LONGLONG hnsLowerBound, + LONGLONG hnsUpperBound) = 0; + + virtual HRESULT STDMETHODCALLTYPE ProcessEvent( + DWORD dwInputStreamID, + /* [in] */ __RPC__in_opt IMFMediaEvent *pEvent) = 0; + + virtual HRESULT STDMETHODCALLTYPE ProcessMessage( + MFT_MESSAGE_TYPE eMessage, + ULONG_PTR ulParam) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE ProcessInput( + DWORD dwInputStreamID, + IMFSample *pSample, + DWORD dwFlags) = 0; + + virtual /* [local] */ HRESULT STDMETHODCALLTYPE ProcessOutput( + DWORD dwFlags, + DWORD cOutputBufferCount, + /* [size_is][out][in] */ MFT_OUTPUT_DATA_BUFFER *pOutputSamples, + /* [out] */ DWORD *pdwStatus) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFTransformVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + __RPC__in IMFTransform * This, + /* [in] */ __RPC__in REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + __RPC__in IMFTransform * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + __RPC__in IMFTransform * This); + + HRESULT ( STDMETHODCALLTYPE *GetStreamLimits )( + __RPC__in IMFTransform * This, + /* [out] */ __RPC__out DWORD *pdwInputMinimum, + /* [out] */ __RPC__out DWORD *pdwInputMaximum, + /* [out] */ __RPC__out DWORD *pdwOutputMinimum, + /* [out] */ __RPC__out DWORD *pdwOutputMaximum); + + HRESULT ( STDMETHODCALLTYPE *GetStreamCount )( + __RPC__in IMFTransform * This, + /* [out] */ __RPC__out DWORD *pcInputStreams, + /* [out] */ __RPC__out DWORD *pcOutputStreams); + + HRESULT ( STDMETHODCALLTYPE *GetStreamIDs )( + __RPC__in IMFTransform * This, + DWORD dwInputIDArraySize, + /* [size_is][out] */ __RPC__out_ecount_full(dwInputIDArraySize) DWORD *pdwInputIDs, + DWORD dwOutputIDArraySize, + /* [size_is][out] */ __RPC__out_ecount_full(dwOutputIDArraySize) DWORD *pdwOutputIDs); + + HRESULT ( STDMETHODCALLTYPE *GetInputStreamInfo )( + __RPC__in IMFTransform * This, + DWORD dwInputStreamID, + /* [out] */ __RPC__out MFT_INPUT_STREAM_INFO *pStreamInfo); + + HRESULT ( STDMETHODCALLTYPE *GetOutputStreamInfo )( + __RPC__in IMFTransform * This, + DWORD dwOutputStreamID, + /* [out] */ __RPC__out MFT_OUTPUT_STREAM_INFO *pStreamInfo); + + HRESULT ( STDMETHODCALLTYPE *GetAttributes )( + __RPC__in IMFTransform * This, + /* [out] */ __RPC__deref_out_opt IMFAttributes **pAttributes); + + HRESULT ( STDMETHODCALLTYPE *GetInputStreamAttributes )( + __RPC__in IMFTransform * This, + DWORD dwInputStreamID, + /* [out] */ __RPC__deref_out_opt IMFAttributes **pAttributes); + + HRESULT ( STDMETHODCALLTYPE *GetOutputStreamAttributes )( + __RPC__in IMFTransform * This, + DWORD dwOutputStreamID, + /* [out] */ __RPC__deref_out_opt IMFAttributes **pAttributes); + + HRESULT ( STDMETHODCALLTYPE *DeleteInputStream )( + __RPC__in IMFTransform * This, + DWORD dwStreamID); + + HRESULT ( STDMETHODCALLTYPE *AddInputStreams )( + __RPC__in IMFTransform * This, + DWORD cStreams, + /* [in] */ __RPC__in DWORD *adwStreamIDs); + + HRESULT ( STDMETHODCALLTYPE *GetInputAvailableType )( + __RPC__in IMFTransform * This, + DWORD dwInputStreamID, + DWORD dwTypeIndex, + /* [out] */ __RPC__deref_out_opt IMFMediaType **ppType); + + HRESULT ( STDMETHODCALLTYPE *GetOutputAvailableType )( + __RPC__in IMFTransform * This, + DWORD dwOutputStreamID, + DWORD dwTypeIndex, + /* [out] */ __RPC__deref_out_opt IMFMediaType **ppType); + + HRESULT ( STDMETHODCALLTYPE *SetInputType )( + __RPC__in IMFTransform * This, + DWORD dwInputStreamID, + /* [in] */ __RPC__in_opt IMFMediaType *pType, + DWORD dwFlags); + + HRESULT ( STDMETHODCALLTYPE *SetOutputType )( + __RPC__in IMFTransform * This, + DWORD dwOutputStreamID, + /* [in] */ __RPC__in_opt IMFMediaType *pType, + DWORD dwFlags); + + HRESULT ( STDMETHODCALLTYPE *GetInputCurrentType )( + __RPC__in IMFTransform * This, + DWORD dwInputStreamID, + /* [out] */ __RPC__deref_out_opt IMFMediaType **ppType); + + HRESULT ( STDMETHODCALLTYPE *GetOutputCurrentType )( + __RPC__in IMFTransform * This, + DWORD dwOutputStreamID, + /* [out] */ __RPC__deref_out_opt IMFMediaType **ppType); + + HRESULT ( STDMETHODCALLTYPE *GetInputStatus )( + __RPC__in IMFTransform * This, + DWORD dwInputStreamID, + /* [out] */ __RPC__out DWORD *pdwFlags); + + HRESULT ( STDMETHODCALLTYPE *GetOutputStatus )( + __RPC__in IMFTransform * This, + /* [out] */ __RPC__out DWORD *pdwFlags); + + HRESULT ( STDMETHODCALLTYPE *SetOutputBounds )( + __RPC__in IMFTransform * This, + LONGLONG hnsLowerBound, + LONGLONG hnsUpperBound); + + HRESULT ( STDMETHODCALLTYPE *ProcessEvent )( + __RPC__in IMFTransform * This, + DWORD dwInputStreamID, + /* [in] */ __RPC__in_opt IMFMediaEvent *pEvent); + + HRESULT ( STDMETHODCALLTYPE *ProcessMessage )( + __RPC__in IMFTransform * This, + MFT_MESSAGE_TYPE eMessage, + ULONG_PTR ulParam); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *ProcessInput )( + IMFTransform * This, + DWORD dwInputStreamID, + IMFSample *pSample, + DWORD dwFlags); + + /* [local] */ HRESULT ( STDMETHODCALLTYPE *ProcessOutput )( + IMFTransform * This, + DWORD dwFlags, + DWORD cOutputBufferCount, + /* [size_is][out][in] */ MFT_OUTPUT_DATA_BUFFER *pOutputSamples, + /* [out] */ DWORD *pdwStatus); + + END_INTERFACE + } IMFTransformVtbl; + + interface IMFTransform + { + CONST_VTBL struct IMFTransformVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFTransform_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFTransform_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFTransform_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFTransform_GetStreamLimits(This,pdwInputMinimum,pdwInputMaximum,pdwOutputMinimum,pdwOutputMaximum) \ + ( (This)->lpVtbl -> GetStreamLimits(This,pdwInputMinimum,pdwInputMaximum,pdwOutputMinimum,pdwOutputMaximum) ) + +#define IMFTransform_GetStreamCount(This,pcInputStreams,pcOutputStreams) \ + ( (This)->lpVtbl -> GetStreamCount(This,pcInputStreams,pcOutputStreams) ) + +#define IMFTransform_GetStreamIDs(This,dwInputIDArraySize,pdwInputIDs,dwOutputIDArraySize,pdwOutputIDs) \ + ( (This)->lpVtbl -> GetStreamIDs(This,dwInputIDArraySize,pdwInputIDs,dwOutputIDArraySize,pdwOutputIDs) ) + +#define IMFTransform_GetInputStreamInfo(This,dwInputStreamID,pStreamInfo) \ + ( (This)->lpVtbl -> GetInputStreamInfo(This,dwInputStreamID,pStreamInfo) ) + +#define IMFTransform_GetOutputStreamInfo(This,dwOutputStreamID,pStreamInfo) \ + ( (This)->lpVtbl -> GetOutputStreamInfo(This,dwOutputStreamID,pStreamInfo) ) + +#define IMFTransform_GetAttributes(This,pAttributes) \ + ( (This)->lpVtbl -> GetAttributes(This,pAttributes) ) + +#define IMFTransform_GetInputStreamAttributes(This,dwInputStreamID,pAttributes) \ + ( (This)->lpVtbl -> GetInputStreamAttributes(This,dwInputStreamID,pAttributes) ) + +#define IMFTransform_GetOutputStreamAttributes(This,dwOutputStreamID,pAttributes) \ + ( (This)->lpVtbl -> GetOutputStreamAttributes(This,dwOutputStreamID,pAttributes) ) + +#define IMFTransform_DeleteInputStream(This,dwStreamID) \ + ( (This)->lpVtbl -> DeleteInputStream(This,dwStreamID) ) + +#define IMFTransform_AddInputStreams(This,cStreams,adwStreamIDs) \ + ( (This)->lpVtbl -> AddInputStreams(This,cStreams,adwStreamIDs) ) + +#define IMFTransform_GetInputAvailableType(This,dwInputStreamID,dwTypeIndex,ppType) \ + ( (This)->lpVtbl -> GetInputAvailableType(This,dwInputStreamID,dwTypeIndex,ppType) ) + +#define IMFTransform_GetOutputAvailableType(This,dwOutputStreamID,dwTypeIndex,ppType) \ + ( (This)->lpVtbl -> GetOutputAvailableType(This,dwOutputStreamID,dwTypeIndex,ppType) ) + +#define IMFTransform_SetInputType(This,dwInputStreamID,pType,dwFlags) \ + ( (This)->lpVtbl -> SetInputType(This,dwInputStreamID,pType,dwFlags) ) + +#define IMFTransform_SetOutputType(This,dwOutputStreamID,pType,dwFlags) \ + ( (This)->lpVtbl -> SetOutputType(This,dwOutputStreamID,pType,dwFlags) ) + +#define IMFTransform_GetInputCurrentType(This,dwInputStreamID,ppType) \ + ( (This)->lpVtbl -> GetInputCurrentType(This,dwInputStreamID,ppType) ) + +#define IMFTransform_GetOutputCurrentType(This,dwOutputStreamID,ppType) \ + ( (This)->lpVtbl -> GetOutputCurrentType(This,dwOutputStreamID,ppType) ) + +#define IMFTransform_GetInputStatus(This,dwInputStreamID,pdwFlags) \ + ( (This)->lpVtbl -> GetInputStatus(This,dwInputStreamID,pdwFlags) ) + +#define IMFTransform_GetOutputStatus(This,pdwFlags) \ + ( (This)->lpVtbl -> GetOutputStatus(This,pdwFlags) ) + +#define IMFTransform_SetOutputBounds(This,hnsLowerBound,hnsUpperBound) \ + ( (This)->lpVtbl -> SetOutputBounds(This,hnsLowerBound,hnsUpperBound) ) + +#define IMFTransform_ProcessEvent(This,dwInputStreamID,pEvent) \ + ( (This)->lpVtbl -> ProcessEvent(This,dwInputStreamID,pEvent) ) + +#define IMFTransform_ProcessMessage(This,eMessage,ulParam) \ + ( (This)->lpVtbl -> ProcessMessage(This,eMessage,ulParam) ) + +#define IMFTransform_ProcessInput(This,dwInputStreamID,pSample,dwFlags) \ + ( (This)->lpVtbl -> ProcessInput(This,dwInputStreamID,pSample,dwFlags) ) + +#define IMFTransform_ProcessOutput(This,dwFlags,cOutputBufferCount,pOutputSamples,pdwStatus) \ + ( (This)->lpVtbl -> ProcessOutput(This,dwFlags,cOutputBufferCount,pOutputSamples,pdwStatus) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFTransform_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mftransform_0000_0001 */ +/* [local] */ + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +typedef +enum _DeviceStreamState + { + DeviceStreamState_Stop = 0, + DeviceStreamState_Pause = ( DeviceStreamState_Stop + 1 ) , + DeviceStreamState_Run = ( DeviceStreamState_Pause + 1 ) , + DeviceStreamState_Disabled = ( DeviceStreamState_Run + 1 ) + } DeviceStreamState; + +typedef enum _DeviceStreamState *PDeviceStreamState; + +EXTERN_GUID(MEDeviceStreamCreated, 0x0252a1cf, 0x3540, 0x43b4, 0x91, 0x64, 0xd7, 0x2e, 0xb4, 0x05, 0xfa, 0x40); +#if (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +typedef struct _STREAM_MEDIUM + { + GUID gidMedium; + UINT32 unMediumInstance; + } STREAM_MEDIUM; + +typedef struct _STREAM_MEDIUM *PSTREAM_MEDIUM; + +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +// +// Define the MFT methods back so we don't accidentally hose the IMediaObject interface. +// +#ifdef MFT_UNIQUE_METHOD_NAMES +#undef GetStreamLimits +#undef GetStreamCount +#undef GetStreamIDs +#undef GetInputStreamInfo +#undef GetOutputStreamInfo +#undef DeleteInputStream +#undef AddInputStreams +#undef GetInputAvailableType +#undef GetOutputAvailableType +#undef SetInputType +#undef SetOutputType +#undef GetInputCurrentType +#undef GetOutputCurrentType +#undef GetInputStatus +#undef GetOutputStatus +#undef SetOutputBounds +#undef ProcessMessage +#undef ProcessInput +#undef ProcessOutput +#endif +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_CLSID = { { 0xc57a84c0, 0x1a80, 0x40a3, {0x97, 0xb5, 0x92, 0x72, 0xa4, 0x3, 0xc8, 0xae} }, 0x01 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_CATEGORY = { { 0xc57a84c0, 0x1a80, 0x40a3, {0x97, 0xb5, 0x92, 0x72, 0xa4, 0x3, 0xc8, 0xae} }, 0x02 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_EXATTRIBUTE_SUPPORTED = { { 0x456fe843, 0x3c87, 0x40c0, {0x94, 0x9d, 0x14, 0x9, 0xc9, 0x7d, 0xab, 0x2c} }, 0x01 }; +EXTERN_C const DECLSPEC_SELECTANY PROPERTYKEY MFPKEY_MULTICHANNEL_CHANNEL_MASK = { { 0x58bdaf8c, 0x3224, 0x4692, { 0x86, 0xd0, 0x44, 0xd6, 0x5c, 0x5b, 0xf8, 0x2b } }, 0x01 }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_D3D_AWARE = { 0xeaa35c29, 0x775e, 0x488e, { 0x9b, 0x61, 0xb3, 0x28, 0x3e, 0x49, 0x58, 0x3b } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_REQUIRED_SAMPLE_COUNT = { 0x18802c61, 0x324b, 0x4952, { 0xab, 0xd0, 0x17, 0x6f, 0xf5, 0xc6, 0x96, 0xff } }; + EXTERN_C const DECLSPEC_SELECTANY GUID MFT_END_STREAMING_AWARE = { 0x70fbc845, 0xb07e, 0x4089, { 0xb0, 0x64, 0x39, 0x9d, 0xc6, 0x11, 0xf, 0x29 } }; + EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_AUDIO_ENDPOINT_AWARE = { 0xc0381701, 0x805c, 0x42b2,{ 0xac, 0x8d, 0xe2, 0xb4, 0xbf, 0x21, 0xf4, 0xf8 } }; + EXTERN_C const DECLSPEC_SELECTANY GUID MFT_AUDIO_DECODER_AUDIO_ENDPOINT_ID = { 0xc7ccdd6e, 0x5398, 0x4695,{ 0x8b, 0xe7, 0x51, 0xb3, 0xe9, 0x51, 0x11, 0xbd } }; + EXTERN_C const DECLSPEC_SELECTANY GUID MFT_AUDIO_DECODER_SPATIAL_METADATA_CLIENT = { 0x5987df4, 0x1270, 0x4999,{ 0x92, 0x5f, 0x8e, 0x93, 0x9a, 0x7c, 0xa, 0xf7 } }; +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) + + +extern RPC_IF_HANDLE __MIDL_itf_mftransform_0000_0001_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mftransform_0000_0001_v0_0_s_ifspec; + +#ifndef __IMFDeviceTransform_INTERFACE_DEFINED__ +#define __IMFDeviceTransform_INTERFACE_DEFINED__ + +/* interface IMFDeviceTransform */ +/* [local][uuid][object] */ + + +EXTERN_C const IID IID_IMFDeviceTransform; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("D818FBD8-FC46-42F2-87AC-1EA2D1F9BF32") + IMFDeviceTransform : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE InitializeTransform( + /* [annotation][in] */ + _In_ IMFAttributes *pAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputAvailableType( + /* [annotation][in] */ + _In_ DWORD dwInputStreamID, + /* [annotation][in] */ + _In_ DWORD dwTypeIndex, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaType **pMediaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputCurrentType( + /* [annotation][in] */ + _In_ DWORD dwInputStreamID, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaType **pMediaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputStreamAttributes( + /* [annotation][in] */ + _In_ DWORD dwInputStreamID, + /* [annotation][out] */ + _COM_Outptr_ IMFAttributes **ppAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputAvailableType( + /* [annotation][in] */ + _In_ DWORD dwOutputStreamID, + /* [annotation][in] */ + _In_ DWORD dwTypeIndex, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaType **pMediaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputCurrentType( + /* [annotation][in] */ + _In_ DWORD dwOutputStreamID, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaType **pMediaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputStreamAttributes( + /* [annotation][in] */ + _In_ DWORD dwOutputStreamID, + /* [annotation][out] */ + _COM_Outptr_ IMFAttributes **ppAttributes) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamCount( + /* [annotation][out] */ + _Out_ DWORD *pcInputStreams, + /* [annotation][out] */ + _Out_ DWORD *pcOutputStreams) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetStreamIDs( + /* [annotation][in] */ + _In_ DWORD dwInputIDArraySize, + /* [annotation][out] */ + _Out_ DWORD *pdwInputStreamIds, + /* [annotation][in] */ + _In_ DWORD dwOutputIDArraySize, + /* [annotation][out] */ + _Out_ DWORD *pdwOutputStreamIds) = 0; + + virtual HRESULT STDMETHODCALLTYPE ProcessEvent( + /* [annotation][in] */ + _In_ DWORD dwInputStreamID, + /* [annotation][in] */ + _In_ IMFMediaEvent *pEvent) = 0; + + virtual HRESULT STDMETHODCALLTYPE ProcessInput( + /* [annotation][in] */ + _In_ DWORD dwInputStreamID, + /* [annotation][in] */ + _In_ IMFSample *pSample, + /* [annotation][in] */ + _In_ DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE ProcessMessage( + /* [annotation][in] */ + _In_ MFT_MESSAGE_TYPE eMessage, + /* [annotation][in] */ + _In_ ULONG_PTR ulParam) = 0; + + virtual HRESULT STDMETHODCALLTYPE ProcessOutput( + /* [annotation][in] */ + _In_ DWORD dwFlags, + /* [annotation][in] */ + _In_ DWORD cOutputBufferCount, + /* [size_is][annotation][out][in] */ + _Inout_ MFT_OUTPUT_DATA_BUFFER *pOutputSample, + /* [annotation][out] */ + _Out_ DWORD *pdwStatus) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetInputStreamState( + /* [annotation][in] */ + _In_ DWORD dwStreamID, + /* [annotation][in] */ + _In_ IMFMediaType *pMediaType, + /* [annotation][in] */ + _In_ DeviceStreamState value, + /* [annotation][in] */ + _In_ DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputStreamState( + /* [annotation][in] */ + _In_ DWORD dwStreamID, + /* [annotation][out] */ + _Out_ DeviceStreamState *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE SetOutputStreamState( + /* [annotation][in] */ + _In_ DWORD dwStreamID, + /* [annotation][in] */ + _In_ IMFMediaType *pMediaType, + /* [annotation][in] */ + _In_ DeviceStreamState value, + /* [annotation][in] */ + _In_ DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetOutputStreamState( + /* [annotation][in] */ + _In_ DWORD dwStreamID, + /* [annotation][out] */ + _Out_ DeviceStreamState *value) = 0; + + virtual HRESULT STDMETHODCALLTYPE GetInputStreamPreferredState( + /* [annotation][in] */ + _In_ DWORD dwStreamID, + /* [annotation][out] */ + _Out_ DeviceStreamState *value, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaType **ppMediaType) = 0; + + virtual HRESULT STDMETHODCALLTYPE FlushInputStream( + /* [annotation][in] */ + _In_ DWORD dwStreamIndex, + /* [annotation][in] */ + _In_ DWORD dwFlags) = 0; + + virtual HRESULT STDMETHODCALLTYPE FlushOutputStream( + /* [annotation][in] */ + _In_ DWORD dwStreamIndex, + /* [annotation][in] */ + _In_ DWORD dwFlags) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFDeviceTransformVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFDeviceTransform * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFDeviceTransform * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFDeviceTransform * This); + + HRESULT ( STDMETHODCALLTYPE *InitializeTransform )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ IMFAttributes *pAttributes); + + HRESULT ( STDMETHODCALLTYPE *GetInputAvailableType )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwInputStreamID, + /* [annotation][in] */ + _In_ DWORD dwTypeIndex, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaType **pMediaType); + + HRESULT ( STDMETHODCALLTYPE *GetInputCurrentType )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwInputStreamID, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaType **pMediaType); + + HRESULT ( STDMETHODCALLTYPE *GetInputStreamAttributes )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwInputStreamID, + /* [annotation][out] */ + _COM_Outptr_ IMFAttributes **ppAttributes); + + HRESULT ( STDMETHODCALLTYPE *GetOutputAvailableType )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwOutputStreamID, + /* [annotation][in] */ + _In_ DWORD dwTypeIndex, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaType **pMediaType); + + HRESULT ( STDMETHODCALLTYPE *GetOutputCurrentType )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwOutputStreamID, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaType **pMediaType); + + HRESULT ( STDMETHODCALLTYPE *GetOutputStreamAttributes )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwOutputStreamID, + /* [annotation][out] */ + _COM_Outptr_ IMFAttributes **ppAttributes); + + HRESULT ( STDMETHODCALLTYPE *GetStreamCount )( + IMFDeviceTransform * This, + /* [annotation][out] */ + _Out_ DWORD *pcInputStreams, + /* [annotation][out] */ + _Out_ DWORD *pcOutputStreams); + + HRESULT ( STDMETHODCALLTYPE *GetStreamIDs )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwInputIDArraySize, + /* [annotation][out] */ + _Out_ DWORD *pdwInputStreamIds, + /* [annotation][in] */ + _In_ DWORD dwOutputIDArraySize, + /* [annotation][out] */ + _Out_ DWORD *pdwOutputStreamIds); + + HRESULT ( STDMETHODCALLTYPE *ProcessEvent )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwInputStreamID, + /* [annotation][in] */ + _In_ IMFMediaEvent *pEvent); + + HRESULT ( STDMETHODCALLTYPE *ProcessInput )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwInputStreamID, + /* [annotation][in] */ + _In_ IMFSample *pSample, + /* [annotation][in] */ + _In_ DWORD dwFlags); + + HRESULT ( STDMETHODCALLTYPE *ProcessMessage )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ MFT_MESSAGE_TYPE eMessage, + /* [annotation][in] */ + _In_ ULONG_PTR ulParam); + + HRESULT ( STDMETHODCALLTYPE *ProcessOutput )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwFlags, + /* [annotation][in] */ + _In_ DWORD cOutputBufferCount, + /* [size_is][annotation][out][in] */ + _Inout_ MFT_OUTPUT_DATA_BUFFER *pOutputSample, + /* [annotation][out] */ + _Out_ DWORD *pdwStatus); + + HRESULT ( STDMETHODCALLTYPE *SetInputStreamState )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwStreamID, + /* [annotation][in] */ + _In_ IMFMediaType *pMediaType, + /* [annotation][in] */ + _In_ DeviceStreamState value, + /* [annotation][in] */ + _In_ DWORD dwFlags); + + HRESULT ( STDMETHODCALLTYPE *GetInputStreamState )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwStreamID, + /* [annotation][out] */ + _Out_ DeviceStreamState *value); + + HRESULT ( STDMETHODCALLTYPE *SetOutputStreamState )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwStreamID, + /* [annotation][in] */ + _In_ IMFMediaType *pMediaType, + /* [annotation][in] */ + _In_ DeviceStreamState value, + /* [annotation][in] */ + _In_ DWORD dwFlags); + + HRESULT ( STDMETHODCALLTYPE *GetOutputStreamState )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwStreamID, + /* [annotation][out] */ + _Out_ DeviceStreamState *value); + + HRESULT ( STDMETHODCALLTYPE *GetInputStreamPreferredState )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwStreamID, + /* [annotation][out] */ + _Out_ DeviceStreamState *value, + /* [annotation][out] */ + _COM_Outptr_ IMFMediaType **ppMediaType); + + HRESULT ( STDMETHODCALLTYPE *FlushInputStream )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwStreamIndex, + /* [annotation][in] */ + _In_ DWORD dwFlags); + + HRESULT ( STDMETHODCALLTYPE *FlushOutputStream )( + IMFDeviceTransform * This, + /* [annotation][in] */ + _In_ DWORD dwStreamIndex, + /* [annotation][in] */ + _In_ DWORD dwFlags); + + END_INTERFACE + } IMFDeviceTransformVtbl; + + interface IMFDeviceTransform + { + CONST_VTBL struct IMFDeviceTransformVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFDeviceTransform_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFDeviceTransform_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFDeviceTransform_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFDeviceTransform_InitializeTransform(This,pAttributes) \ + ( (This)->lpVtbl -> InitializeTransform(This,pAttributes) ) + +#define IMFDeviceTransform_GetInputAvailableType(This,dwInputStreamID,dwTypeIndex,pMediaType) \ + ( (This)->lpVtbl -> GetInputAvailableType(This,dwInputStreamID,dwTypeIndex,pMediaType) ) + +#define IMFDeviceTransform_GetInputCurrentType(This,dwInputStreamID,pMediaType) \ + ( (This)->lpVtbl -> GetInputCurrentType(This,dwInputStreamID,pMediaType) ) + +#define IMFDeviceTransform_GetInputStreamAttributes(This,dwInputStreamID,ppAttributes) \ + ( (This)->lpVtbl -> GetInputStreamAttributes(This,dwInputStreamID,ppAttributes) ) + +#define IMFDeviceTransform_GetOutputAvailableType(This,dwOutputStreamID,dwTypeIndex,pMediaType) \ + ( (This)->lpVtbl -> GetOutputAvailableType(This,dwOutputStreamID,dwTypeIndex,pMediaType) ) + +#define IMFDeviceTransform_GetOutputCurrentType(This,dwOutputStreamID,pMediaType) \ + ( (This)->lpVtbl -> GetOutputCurrentType(This,dwOutputStreamID,pMediaType) ) + +#define IMFDeviceTransform_GetOutputStreamAttributes(This,dwOutputStreamID,ppAttributes) \ + ( (This)->lpVtbl -> GetOutputStreamAttributes(This,dwOutputStreamID,ppAttributes) ) + +#define IMFDeviceTransform_GetStreamCount(This,pcInputStreams,pcOutputStreams) \ + ( (This)->lpVtbl -> GetStreamCount(This,pcInputStreams,pcOutputStreams) ) + +#define IMFDeviceTransform_GetStreamIDs(This,dwInputIDArraySize,pdwInputStreamIds,dwOutputIDArraySize,pdwOutputStreamIds) \ + ( (This)->lpVtbl -> GetStreamIDs(This,dwInputIDArraySize,pdwInputStreamIds,dwOutputIDArraySize,pdwOutputStreamIds) ) + +#define IMFDeviceTransform_ProcessEvent(This,dwInputStreamID,pEvent) \ + ( (This)->lpVtbl -> ProcessEvent(This,dwInputStreamID,pEvent) ) + +#define IMFDeviceTransform_ProcessInput(This,dwInputStreamID,pSample,dwFlags) \ + ( (This)->lpVtbl -> ProcessInput(This,dwInputStreamID,pSample,dwFlags) ) + +#define IMFDeviceTransform_ProcessMessage(This,eMessage,ulParam) \ + ( (This)->lpVtbl -> ProcessMessage(This,eMessage,ulParam) ) + +#define IMFDeviceTransform_ProcessOutput(This,dwFlags,cOutputBufferCount,pOutputSample,pdwStatus) \ + ( (This)->lpVtbl -> ProcessOutput(This,dwFlags,cOutputBufferCount,pOutputSample,pdwStatus) ) + +#define IMFDeviceTransform_SetInputStreamState(This,dwStreamID,pMediaType,value,dwFlags) \ + ( (This)->lpVtbl -> SetInputStreamState(This,dwStreamID,pMediaType,value,dwFlags) ) + +#define IMFDeviceTransform_GetInputStreamState(This,dwStreamID,value) \ + ( (This)->lpVtbl -> GetInputStreamState(This,dwStreamID,value) ) + +#define IMFDeviceTransform_SetOutputStreamState(This,dwStreamID,pMediaType,value,dwFlags) \ + ( (This)->lpVtbl -> SetOutputStreamState(This,dwStreamID,pMediaType,value,dwFlags) ) + +#define IMFDeviceTransform_GetOutputStreamState(This,dwStreamID,value) \ + ( (This)->lpVtbl -> GetOutputStreamState(This,dwStreamID,value) ) + +#define IMFDeviceTransform_GetInputStreamPreferredState(This,dwStreamID,value,ppMediaType) \ + ( (This)->lpVtbl -> GetInputStreamPreferredState(This,dwStreamID,value,ppMediaType) ) + +#define IMFDeviceTransform_FlushInputStream(This,dwStreamIndex,dwFlags) \ + ( (This)->lpVtbl -> FlushInputStream(This,dwStreamIndex,dwFlags) ) + +#define IMFDeviceTransform_FlushOutputStream(This,dwStreamIndex,dwFlags) \ + ( (This)->lpVtbl -> FlushOutputStream(This,dwStreamIndex,dwFlags) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFDeviceTransform_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mftransform_0000_0002 */ +/* [local] */ + +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD ) +#if (WINVER >= _WIN32_WINNT_WIN10) +EXTERN_GUID( MF_DMFT_FRAME_BUFFER_INFO, 0x396CE1C9, 0x67A9, 0x454C, 0x87, 0x97, 0x95, 0xA4, 0x57, 0x99, 0xD8, 0x04); + + +extern RPC_IF_HANDLE __MIDL_itf_mftransform_0000_0002_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mftransform_0000_0002_v0_0_s_ifspec; + +#ifndef __IMFDeviceTransformCallback_INTERFACE_DEFINED__ +#define __IMFDeviceTransformCallback_INTERFACE_DEFINED__ + +/* interface IMFDeviceTransformCallback */ +/* [local][helpstring][uuid][object] */ + + +EXTERN_C const IID IID_IMFDeviceTransformCallback; + +#if defined(__cplusplus) && !defined(CINTERFACE) + + MIDL_INTERFACE("6D5CB646-29EC-41FB-8179-8C4C6D750811") + IMFDeviceTransformCallback : public IUnknown + { + public: + virtual HRESULT STDMETHODCALLTYPE OnBufferSent( + /* [annotation][in] */ + _In_ IMFAttributes *pCallbackAttributes, + /* [annotation][in] */ + _In_ DWORD pinId) = 0; + + }; + + +#else /* C style interface */ + + typedef struct IMFDeviceTransformCallbackVtbl + { + BEGIN_INTERFACE + + HRESULT ( STDMETHODCALLTYPE *QueryInterface )( + IMFDeviceTransformCallback * This, + /* [in] */ REFIID riid, + /* [annotation][iid_is][out] */ + _COM_Outptr_ void **ppvObject); + + ULONG ( STDMETHODCALLTYPE *AddRef )( + IMFDeviceTransformCallback * This); + + ULONG ( STDMETHODCALLTYPE *Release )( + IMFDeviceTransformCallback * This); + + HRESULT ( STDMETHODCALLTYPE *OnBufferSent )( + IMFDeviceTransformCallback * This, + /* [annotation][in] */ + _In_ IMFAttributes *pCallbackAttributes, + /* [annotation][in] */ + _In_ DWORD pinId); + + END_INTERFACE + } IMFDeviceTransformCallbackVtbl; + + interface IMFDeviceTransformCallback + { + CONST_VTBL struct IMFDeviceTransformCallbackVtbl *lpVtbl; + }; + + + +#ifdef COBJMACROS + + +#define IMFDeviceTransformCallback_QueryInterface(This,riid,ppvObject) \ + ( (This)->lpVtbl -> QueryInterface(This,riid,ppvObject) ) + +#define IMFDeviceTransformCallback_AddRef(This) \ + ( (This)->lpVtbl -> AddRef(This) ) + +#define IMFDeviceTransformCallback_Release(This) \ + ( (This)->lpVtbl -> Release(This) ) + + +#define IMFDeviceTransformCallback_OnBufferSent(This,pCallbackAttributes,pinId) \ + ( (This)->lpVtbl -> OnBufferSent(This,pCallbackAttributes,pinId) ) + +#endif /* COBJMACROS */ + + +#endif /* C style interface */ + + + + +#endif /* __IMFDeviceTransformCallback_INTERFACE_DEFINED__ */ + + +/* interface __MIDL_itf_mftransform_0000_0003 */ +/* [local] */ + +#endif // (WINVER >= _WIN32_WINNT_WIN10 ) +#if (WINVER >= _WIN32_WINNT_WIN8) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_REQUIRED_SAMPLE_COUNT_PROGRESSIVE = { 0xb172d58e, 0xfa77, 0x4e48, { 0x8d, 0x2a, 0x1d, 0xf2, 0xd8, 0x50, 0xea, 0xc2 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT = { 0x851745d5, 0xc3d6, 0x476d, { 0x95, 0x27, 0x49, 0x8e, 0xf2, 0xd1, 0xd, 0x18 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT_PROGRESSIVE = { 0xf5523a5, 0x1cb2, 0x47c5, { 0xa5, 0x50, 0x2e, 0xeb, 0x84, 0xb4, 0xd1, 0x4a } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_SUPPORT_3DVIDEO = { 0x93f81b1, 0x4f2e, 0x4631, { 0x81, 0x68, 0x79, 0x34, 0x3, 0x2a, 0x1, 0xd3 } }; +typedef +enum _MF3DVideoOutputType + { + MF3DVideoOutputType_BaseView = 0, + MF3DVideoOutputType_Stereo = 1 + } MF3DVideoOutputType; + +EXTERN_C const DECLSPEC_SELECTANY GUID MF_ENABLE_3DVIDEO_OUTPUT = { 0xbdad7bca, 0xe5f, 0x4b10, { 0xab, 0x16, 0x26, 0xde, 0x38, 0x1b, 0x62, 0x93 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_D3D11_BINDFLAGS = { 0xeacf97ad, 0x065c, 0x4408, { 0xbe, 0xe3, 0xfd, 0xcb, 0xfd, 0x12, 0x8b, 0xe2 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_D3D11_USAGE = { 0xe85fe442, 0x2ca3, 0x486e, { 0xa9, 0xc7, 0x10, 0x9d, 0xda, 0x60, 0x98, 0x80 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_D3D11_AWARE = { 0x206b4fc8, 0xfcf9, 0x4c51, { 0xaf, 0xe3, 0x97, 0x64, 0x36, 0x9e, 0x33, 0xa0 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_D3D11_SHARED = { 0x7b8f32c3, 0x6d96, 0x4b89, { 0x92, 0x3, 0xdd, 0x38, 0xb6, 0x14, 0x14, 0xf3 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_D3D11_SHARED_WITHOUT_MUTEX = { 0x39dbd44d, 0x2e44, 0x4931, { 0xa4, 0xc8, 0x35, 0x2d, 0x3d, 0xc4, 0x21, 0x15 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_D3D11_ALLOW_DYNAMIC_YUV_TEXTURE = { 0xce06d49f, 0x613, 0x4b9d, { 0x86, 0xa6, 0xd8, 0xc4, 0xf9, 0xc1, 0x0, 0x75 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_D3D11_HW_PROTECTED = { 0x3a8ba9d9, 0x92ca, 0x4307, { 0xa3, 0x91, 0x69, 0x99, 0xdb, 0xf3, 0xb6, 0xce } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_SA_BUFFERS_PER_SAMPLE = { 0x873c5171, 0x1e3d, 0x4e25, { 0x98, 0x8d, 0xb4, 0x33, 0xce, 0x04, 0x19, 0x83 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_DECODER_EXPOSE_OUTPUT_TYPES_IN_NATIVE_ORDER = { 0xef80833f, 0xf8fa, 0x44d9, { 0x80, 0xd8, 0x41, 0xed, 0x62, 0x32, 0x67, 0xc } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_DECODER_QUALITY_MANAGEMENT_CUSTOM_CONTROL = { 0xa24e30d7, 0xde25, 0x4558, { 0xbb, 0xfb, 0x71, 0x7, 0xa, 0x2d, 0x33, 0x2e } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_DECODER_QUALITY_MANAGEMENT_RECOVERY_WITHOUT_ARTIFACTS = { 0xd8980deb, 0xa48, 0x425f, { 0x86, 0x23, 0x61, 0x1d, 0xb4, 0x1d, 0x38, 0x10 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_REMUX_MARK_I_PICTURE_AS_CLEAN_POINT = { 0x364e8f85, 0x3f2e, 0x436c, { 0xb2, 0xa2, 0x44, 0x40, 0xa0, 0x12, 0xa9, 0xe8} }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_DECODER_FINAL_VIDEO_RESOLUTION_HINT = { 0xdc2f8496, 0x15c4, 0x407a, { 0xb6, 0xf0, 0x1b, 0x66, 0xab, 0x5f, 0xbf, 0x53 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_ENCODER_SUPPORTS_CONFIG_EVENT = { 0x86a355ae, 0x3a77, 0x4ec4, { 0x9f, 0x31, 0x1, 0x14, 0x9a, 0x4e, 0x92, 0xde } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_ENUM_HARDWARE_VENDOR_ID_Attribute = { 0x3aecb0cc, 0x35b, 0x4bcc, { 0x81, 0x85, 0x2b, 0x8d, 0x55, 0x1e, 0xf3, 0xaf } }; +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN8) +#if (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Application Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) +EXTERN_C const DECLSPEC_SELECTANY GUID MF_TRANSFORM_ASYNC = { 0xf81a699a, 0x649a, 0x497d, { 0x8c, 0x73, 0x29, 0xf8, 0xfe, 0xd6, 0xad, 0x7a } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_TRANSFORM_ASYNC_UNLOCK = { 0xe5666d6b, 0x3422, 0x4eb6, { 0xa4, 0x21, 0xda, 0x7d, 0xb1, 0xf8, 0xe2, 0x7 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_TRANSFORM_FLAGS_Attribute = { 0x9359bb7e, 0x6275, 0x46c4, { 0xa0, 0x25, 0x1c, 0x1, 0xe4, 0x5f, 0x1a, 0x86 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MF_TRANSFORM_CATEGORY_Attribute = { 0xceabba49, 0x506d, 0x4757, { 0xa6, 0xff, 0x66, 0xc1, 0x84, 0x98, 0x7e, 0x4e } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_TRANSFORM_CLSID_Attribute = { 0x6821c42b, 0x65a4, 0x4e82, { 0x99, 0xbc, 0x9a, 0x88, 0x20, 0x5e, 0xcd, 0xc } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_INPUT_TYPES_Attributes = { 0x4276c9b1, 0x759d, 0x4bf3, { 0x9c, 0xd0, 0xd, 0x72, 0x3d, 0x13, 0x8f, 0x96 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_OUTPUT_TYPES_Attributes = { 0x8eae8cf3, 0xa44f, 0x4306, { 0xba, 0x5c, 0xbf, 0x5d, 0xda, 0x24, 0x28, 0x18 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_ENUM_HARDWARE_URL_Attribute = { 0x2fb866ac, 0xb078, 0x4942, { 0xab, 0x6c, 0x0, 0x3d, 0x5, 0xcd, 0xa6, 0x74 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_FRIENDLY_NAME_Attribute = { 0x314ffbae, 0x5b41, 0x4c95, { 0x9c, 0x19, 0x4e, 0x7d, 0x58, 0x6f, 0xac, 0xe3 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_CONNECTED_STREAM_ATTRIBUTE = { 0x71eeb820, 0xa59f, 0x4de2, {0xbc, 0xec, 0x38, 0xdb, 0x1d, 0xd6, 0x11, 0xa4} }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_CONNECTED_TO_HW_STREAM = { 0x34e6e728, 0x6d6, 0x4491, { 0xa5, 0x53, 0x47, 0x95, 0x65, 0xd, 0xb9, 0x12 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_PREFERRED_OUTPUTTYPE_Attribute = { 0x7e700499, 0x396a, 0x49ee, { 0xb1, 0xb4, 0xf6, 0x28, 0x2, 0x1e, 0x8c, 0x9d } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_PROCESS_LOCAL_Attribute = { 0x543186e4, 0x4649, 0x4e65, { 0xb5, 0x88, 0x4a, 0xa3, 0x52, 0xaf, 0xf3, 0x79 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_PREFERRED_ENCODER_PROFILE = { 0x53004909, 0x1ef5, 0x46d7, { 0xa1, 0x8e, 0x5a, 0x75, 0xf8, 0xb5, 0x90, 0x5f } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_HW_TIMESTAMP_WITH_QPC_Attribute = { 0x8d030fb8, 0xcc43, 0x4258, { 0xa2, 0x2e, 0x92, 0x10, 0xbe, 0xf8, 0x9b, 0xe4 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_FIELDOFUSE_UNLOCK_Attribute = { 0x8ec2e9fd, 0x9148, 0x410d, { 0x83, 0x1e, 0x70, 0x24, 0x39, 0x46, 0x1a, 0x8e } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_CODEC_MERIT_Attribute = { 0x88a7cb15, 0x7b07, 0x4a34, { 0x91, 0x28, 0xe6, 0x4c, 0x67, 0x3, 0xc4, 0xd3 } }; +EXTERN_C const DECLSPEC_SELECTANY GUID MFT_ENUM_TRANSCODE_ONLY_ATTRIBUTE = { 0x111ea8cd, 0xb62a, 0x4bdb, { 0x89, 0xf6, 0x67, 0xff, 0xcd, 0xc2, 0x45, 0x8b } }; +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) */ +#pragma endregion +#pragma region Desktop Family +#if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) +STDAPI +MFCreateTransformActivate( + _Out_ IMFActivate** ppActivate + ); +#endif /* WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_DESKTOP) */ +#pragma endregion +#endif // (WINVER >= _WIN32_WINNT_WIN7) +#pragma region Track Error Improvements +#if (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +EXTERN_GUID( MFT_AUDIO_DECODER_DEGRADATION_INFO_ATTRIBUTE, 0x6c3386ad, 0xec20, 0x430d, 0xb2, 0xa5, 0x50, 0x5c, 0x71, 0x78, 0xd9, 0xc4); +typedef +enum MFT_AUDIO_DECODER_DEGRADATION_REASON + { + MFT_AUDIO_DECODER_DEGRADATION_REASON_NONE = 0, + MFT_AUDIO_DECODER_DEGRADATION_REASON_LICENSING_REQUIREMENT = 1 + } MFT_AUDIO_DECODER_DEGRADATION_REASON; + +typedef +enum MFT_AUDIO_DECODER_DEGRADATION_TYPE + { + MFT_AUDIO_DECODER_DEGRADATION_TYPE_NONE = 0, + MFT_AUDIO_DECODER_DEGRADATION_TYPE_DOWNMIX2CHANNEL = 1, + MFT_AUDIO_DECODER_DEGRADATION_TYPE_DOWNMIX6CHANNEL = 2, + MFT_AUDIO_DECODER_DEGRADATION_TYPE_DOWNMIX8CHANNEL = 3 + } MFT_AUDIO_DECODER_DEGRADATION_TYPE; + +typedef struct MFAudioDecoderDegradationInfo + { + MFT_AUDIO_DECODER_DEGRADATION_REASON eDegradationReason; + MFT_AUDIO_DECODER_DEGRADATION_TYPE eType; + } MFAudioDecoderDegradationInfo; + +typedef struct _MFT_STREAM_STATE_PARAM + { + DWORD StreamId; + MF_STREAM_STATE State; + } MFT_STREAM_STATE_PARAM; + +typedef struct _MFT_STREAM_STATE_PARAM *PMFT_STREAM_STATE_PARAM; + +#endif // (WINVER >= _WIN32_WINNT_WINTHRESHOLD) +#pragma endregion + + +extern RPC_IF_HANDLE __MIDL_itf_mftransform_0000_0003_v0_0_c_ifspec; +extern RPC_IF_HANDLE __MIDL_itf_mftransform_0000_0003_v0_0_s_ifspec; + +/* Additional Prototypes for ALL interfaces */ + +/* end of Additional Prototypes */ + +#ifdef __cplusplus +} +#endif + +#endif + +