diff --git a/.hgignore b/.hgignore index abda625..af30f1f 100644 --- a/.hgignore +++ b/.hgignore @@ -19,3 +19,4 @@ CUETools.AVX/Win32 CUETools.AVX/x64 CUETools/TestResults/ bin/CUETools_2.1.4 +*.csproj.user diff --git a/CUETools.Codecs.WMA/COPYING b/CUETools.Codecs.WMA/COPYING new file mode 100644 index 0000000..3828e20 --- /dev/null +++ b/CUETools.Codecs.WMA/COPYING @@ -0,0 +1,503 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + diff --git a/CUETools.Codecs.WMA/CUETools.Codecs.WMA.csproj b/CUETools.Codecs.WMA/CUETools.Codecs.WMA.csproj new file mode 100644 index 0000000..134c493 --- /dev/null +++ b/CUETools.Codecs.WMA/CUETools.Codecs.WMA.csproj @@ -0,0 +1,113 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E} + Library + Properties + CUETools.Codecs.WMA + CUETools.Codecs.WMA + + + 3.5 + + + v2.0 + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + true + full + false + ..\bin\Debug\plugins\ + DEBUG;TRACE + prompt + 4 + true + AllRules.ruleset + + + pdbonly + true + ..\bin\Release\plugins\ + TRACE + prompt + 4 + true + AllRules.ruleset + + + + + + + + + + + True + True + Resources.resx + + + + + {6458A13A-30EF-45A9-9D58-E5031B17BEE2} + CUETools.Codecs + False + + + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8} + WindowsMediaLib + + + + + ResXFileCodeGenerator + Resources.Designer.cs + + + + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + true + + + False + Windows Installer 3.1 + true + + + + + \ No newline at end of file diff --git a/CUETools.Codecs.WMA/Properties/AssemblyInfo.cs b/CUETools.Codecs.WMA/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..f5c0cc0 --- /dev/null +++ b/CUETools.Codecs.WMA/Properties/AssemblyInfo.cs @@ -0,0 +1,35 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("CUETools.Codecs.WMA")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("CUETools.Codecs.WMA")] +[assembly: AssemblyCopyright("Copyright © 2013-2013 Grigory Chudov")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("af385bb5-1d2e-409b-97db-d491a0b96d9e")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Revision and Build Numbers +// by using the '*' as shown below: +[assembly: AssemblyVersion("2.1.4.0")] +[assembly: AssemblyFileVersion("2.1.4.0")] diff --git a/CUETools.Codecs.WMA/Properties/Resources.Designer.cs b/CUETools.Codecs.WMA/Properties/Resources.Designer.cs new file mode 100644 index 0000000..01d18a4 --- /dev/null +++ b/CUETools.Codecs.WMA/Properties/Resources.Designer.cs @@ -0,0 +1,99 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.239 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace CUETools.Codecs.WMA.Properties { + using System; + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("CUETools.Codecs.WMA.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + + /// + /// Looks up a localized string similar to Calculate MD5 hash for audio stream. + /// + internal static string DoMD5Description { + get { + return ResourceManager.GetString("DoMD5Description", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Decode each frame and compare with original. + /// + internal static string DoVerifyDescription { + get { + return ResourceManager.GetString("DoVerifyDescription", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Samples written differs from the expected sample count. + /// + internal static string ExceptionSampleCount { + get { + return ResourceManager.GetString("ExceptionSampleCount", resourceCulture); + } + } + + /// + /// Looks up a localized string similar to Validation failed. + /// + internal static string ExceptionValidationFailed { + get { + return ResourceManager.GetString("ExceptionValidationFailed", resourceCulture); + } + } + } +} diff --git a/CUETools.Codecs.WMA/Properties/Resources.resx b/CUETools.Codecs.WMA/Properties/Resources.resx new file mode 100644 index 0000000..55865cf --- /dev/null +++ b/CUETools.Codecs.WMA/Properties/Resources.resx @@ -0,0 +1,132 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Calculate MD5 hash for audio stream + + + Decode each frame and compare with original + + + Samples written differs from the expected sample count + + + Validation failed + + \ No newline at end of file diff --git a/CUETools.Codecs.WMA/Properties/Resources.ru-RU.resx b/CUETools.Codecs.WMA/Properties/Resources.ru-RU.resx new file mode 100644 index 0000000..53a8fcd --- /dev/null +++ b/CUETools.Codecs.WMA/Properties/Resources.ru-RU.resx @@ -0,0 +1,132 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Вычислять MD5-хеш аудиопотока + + + Декодировать каждый блок и сравнивать с оригиналом + + + Количество записанных сэмплов отличается от ожидавшегося + + + Ошибка верификации + + \ No newline at end of file diff --git a/CUETools.Codecs.WMA/WMAReader.cs b/CUETools.Codecs.WMA/WMAReader.cs new file mode 100644 index 0000000..4afdbd1 --- /dev/null +++ b/CUETools.Codecs.WMA/WMAReader.cs @@ -0,0 +1,377 @@ +/** + * CUETools.WMA: WMA audio decoder + * Copyright (c) 20139 Grigory Chudov + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +using System; +using System.Collections.Generic; +using System.Text; +using System.IO; +using WindowsMediaLib; +using WindowsMediaLib.Defs; +using System.Runtime.InteropServices; + +namespace CUETools.Codecs.WMA +{ + [AudioDecoderClass("builtin wma", "wma")] + public class WMAReader : IAudioSource + { + IWMSyncReader m_syncReader; + short m_wStreamNum = -1; + int m_dwAudioOutputNum = -1; + + AudioPCMConfig pcm; + + byte[] samplesBuffer; + int _samplesInBuffer, _samplesBufferOffset; + long _sampleCount = -1, _sampleOffset = 0; + + string _path; + //Stream _IO; + + public WMAReader(string path, Stream IO) + { + isValid(path); + bool pfIsProtected; + WMUtils.WMIsContentProtected(path, out pfIsProtected); + if (pfIsProtected) + throw new Exception("DRM present"); + WMUtils.WMCreateSyncReader(IntPtr.Zero, Rights.None, out m_syncReader); + + //m_syncReader.OpenStream() + m_syncReader.Open(path); + var pProfile = (m_syncReader as IWMProfile); + int dwStreamCount; + pProfile.GetStreamCount(out dwStreamCount); + for (int dwIndex = 0; dwIndex < dwStreamCount; dwIndex++) + { + IWMStreamConfig pConfig = null; + pProfile.GetStream(0, out pConfig); + try + { + Guid guid; + pConfig.GetStreamType(out guid); + if (MediaType.Audio != guid) + continue; + short wStreamNum; + pConfig.GetStreamNumber(out wStreamNum); + int dwBitrate = -1; + pConfig.GetBitrate(out dwBitrate); + var pIWMMediaProps = pConfig as IWMMediaProps; + int cbType = 0; + pIWMMediaProps.GetMediaType(null, ref cbType); + var mt = new AMMediaType(); + mt.formatSize = cbType; + pIWMMediaProps.GetMediaType(mt, ref cbType); + if (mt.formatType != FormatType.WaveEx) + continue; + if (mt.subType != MediaSubType.WMAudio_Lossless) + continue; + m_wStreamNum = wStreamNum; + break; + } + finally + { + Marshal.ReleaseComObject(pConfig); + } + } + if (m_wStreamNum == -1) + throw new Exception("No WMA lossless streams found"); + + m_syncReader.SetReadStreamSamples(m_wStreamNum, false); + bool pfCompressed; + m_syncReader.GetReadStreamSamples(m_wStreamNum, out pfCompressed); + if (pfCompressed) + throw new Exception("doesn't decompress"); + m_syncReader.GetOutputNumberForStream(m_wStreamNum, out m_dwAudioOutputNum); + IWMOutputMediaProps pProps; + m_syncReader.GetOutputProps(m_dwAudioOutputNum, out pProps); + var m_pWfx = new WaveFormatEx(); + try + { + StringBuilder sName = null; + AMMediaType pMediaType = null; + int cbType = 0; + + cbType = 0; + pMediaType = null; + pProps.GetMediaType(pMediaType, ref cbType); + + // Get the name of the output we'll be using + sName = null; + short iName = 0; + pProps.GetConnectionName(sName, ref iName); + + sName = new StringBuilder(iName); + pProps.GetConnectionName(sName, ref iName); + + pMediaType = new AMMediaType(); + pMediaType.formatSize = cbType - Marshal.SizeOf(typeof(AMMediaType)); + + // + // Get the value for MediaType + // + pProps.GetMediaType(pMediaType, ref cbType); + + try + { + if (MediaType.Audio != pMediaType.majorType) + throw new Exception("not Audio"); + if (FormatType.WaveEx != pMediaType.formatType) + throw new Exception("not WaveEx"); + Marshal.PtrToStructure(pMediaType.formatPtr, m_pWfx); + } + finally + { + WMUtils.FreeWMMediaType(pMediaType); + } + } + finally + { + Marshal.ReleaseComObject(pProps); + } + + //try + //{ + // AttrDataType wmtType; + // short cbLength = 0; + // short wAnyStream = 0; + // var pHeaderInfo = m_syncReader as IWMHeaderInfo; + // pHeaderInfo.GetAttributeByName(ref wAnyStream, Constants.g_wszWMDuration, out wmtType, null, ref cbLength); + // var pbValue = new byte[cbLength]; + // pHeaderInfo.GetAttributeByName(ref wAnyStream, Constants.g_wszWMDuration, out wmtType, pbValue, ref cbLength); + // var m_cnsFileDuration = BitConverter.ToInt64(pbValue, 0); + // _sampleCount = m_cnsFileDuration * m_pWfx.nSamplesPerSec / 10000000; + // // NOT ACCURATE ENOUGH (~1ms precision observed) + //} + //catch (COMException) + //{ + //} + + //try + //{ + // var pHeaderInfo = m_syncReader as IWMHeaderInfo2; + // int nCodec; + // pHeaderInfo.GetCodecInfoCount(out nCodec); + // for (int wIndex = 0; wIndex < nCodec; wIndex++) + // { + // CodecInfoType enumCodecType; + // short cchName = 0; + // short cchDescription = 0; + // short cbCodecInfo = 0; + // pHeaderInfo.GetCodecInfo(wIndex, ref cchName, null, + // ref cchDescription, null, out enumCodecType, + // ref cbCodecInfo, null); + // var pwszName = new StringBuilder(cchName); + // var pwszDescription = new StringBuilder(cchDescription); + // var pbCodecInfo = new byte[cbCodecInfo]; + // pHeaderInfo.GetCodecInfo(wIndex, ref cchName, pwszName, + // ref cchDescription, pwszDescription, out enumCodecType, + // ref cbCodecInfo, pbCodecInfo); + // if (enumCodecType == CodecInfoType.Audio) + // { + // // pbCodecInfo = {99,1} ??/ + // } + // } + //} + //catch (COMException) + //{ + //} + + pcm = new AudioPCMConfig(m_pWfx.wBitsPerSample, m_pWfx.nChannels, m_pWfx.nSamplesPerSec); + _path = path; + + int cbMax; + m_syncReader.GetMaxOutputSampleSize(m_dwAudioOutputNum, out cbMax); + //m_syncReader.GetMaxStreamSampleSize(m_wStreamNum, out cbMax); + //var ra = m_syncReader as IWMReaderAdvanced; + //ra.SetAllocateForOutput(m_dwAudioOutputNum, true); + + samplesBuffer = new byte[cbMax]; + } + + public void isValid(string filename) + { + int pdwDataSize = 0; + WMUtils.WMValidateData(null, ref pdwDataSize); + byte[] data = new byte[pdwDataSize]; + using (FileStream s = new FileStream(filename, FileMode.Open, FileAccess.Read)) + { + if (s.Read(data, 0, pdwDataSize) < pdwDataSize) + throw new Exception("partial read"); // TODO + } + WMUtils.WMValidateData(data, ref pdwDataSize); + } + + public void Close() + { + //_IO.Close(); + m_syncReader.Close(); + Marshal.ReleaseComObject(m_syncReader); + } + + public long Length + { + get + { + return _sampleCount; + } + } + + public long Remaining + { + get + { + return Length - Position; + } + } + + public long Position + { + get + { + return _sampleOffset - _samplesInBuffer; + } + set + { + if (_sampleCount < 0 || value > _sampleCount) + throw new Exception("seeking past end of stream"); + throw new NotSupportedException(); + //if (value < Position || value > _sampleOffset) + //{ + // if (seek_table != null && _IO.CanSeek) + // { + // int best_st = -1; + // for (int st = 0; st < seek_table.Length; st++) + // { + // if (seek_table[st].number <= value && + // (best_st == -1 || seek_table[st].number > seek_table[best_st].number)) + // best_st = st; + // } + // if (best_st != -1) + // { + // _framesBufferLength = 0; + // _samplesInBuffer = 0; + // _samplesBufferOffset = 0; + // _IO.Position = (long)seek_table[best_st].offset + first_frame_offset; + // _sampleOffset = seek_table[best_st].number; + // } + // } + // if (value < Position) + // throw new Exception("cannot seek backwards without seek table"); + //} + //while (value > _sampleOffset) + //{ + // _samplesInBuffer = 0; + // _samplesBufferOffset = 0; + + // fill_frames_buffer(); + // if (_framesBufferLength == 0) + // throw new Exception("seek failed"); + + // int bytesDecoded = DecodeFrame(_framesBuffer, _framesBufferOffset, _framesBufferLength); + // _framesBufferLength -= bytesDecoded; + // _framesBufferOffset += bytesDecoded; + + // _sampleOffset += _samplesInBuffer; + //}; + //int diff = _samplesInBuffer - (int)(_sampleOffset - value); + //_samplesInBuffer -= diff; + //_samplesBufferOffset += diff; + } + } + + public AudioPCMConfig PCM + { + get + { + return pcm; + } + } + + public string Path + { + get + { + return _path; + } + } + + const int BS = 4; + + public int Read(AudioBuffer buff, int maxLength) + { + buff.Prepare(this, maxLength); + + int offset = 0; + int sampleCount = buff.Length; + + while (_samplesInBuffer < sampleCount) + { + if (_samplesInBuffer > 0) + { + Array.Copy(samplesBuffer, _samplesBufferOffset * BS, buff.Bytes, offset * BS, _samplesInBuffer * BS); + sampleCount -= _samplesInBuffer; + offset += _samplesInBuffer; + _samplesInBuffer = 0; + _samplesBufferOffset = 0; + } + + INSSBuffer pSample; + long cnsSampleTime; + long cnsDuration; + SampleFlag flags; + int dwOutputNum; + short wStreamNum; + int dwLength; + IntPtr pdwBuffer; + try + { + m_syncReader.GetNextSample(m_wStreamNum, out pSample, out cnsSampleTime, out cnsDuration, out flags, out dwOutputNum, out wStreamNum); + } + catch (COMException ex) + { + // EOF + if (ex.ErrorCode == NSResults.E_NO_MORE_SAMPLES) + { + _sampleCount = _sampleOffset; + return offset; + } + throw ex; + } + //if (dwOutputNum != m_dwAudioOutputNum || wStreamNum != m_wStreamNum) + //{ + //} + pSample.GetBufferAndLength(out pdwBuffer, out dwLength); + Marshal.Copy(pdwBuffer, samplesBuffer, 0, dwLength); + Marshal.ReleaseComObject(pSample); + _samplesInBuffer = dwLength / BS; + _sampleOffset += _samplesInBuffer; + + //_samplesInBuffer -= _samplesBufferOffset; // can be set by Seek, otherwise zero + //_sampleOffset += _samplesInBuffer; + } + + Array.Copy(samplesBuffer, _samplesBufferOffset * BS, buff.Bytes, offset * BS, sampleCount * BS); + _samplesInBuffer -= sampleCount; + _samplesBufferOffset += sampleCount; + if (_samplesInBuffer == 0) + _samplesBufferOffset = 0; + return offset + sampleCount; + } + } +} diff --git a/CUETools.Processor/CUEConfig.cs b/CUETools.Processor/CUEConfig.cs index 2ca52a2..a6a2de8 100644 --- a/CUETools.Processor/CUEConfig.cs +++ b/CUETools.Processor/CUEConfig.cs @@ -171,7 +171,7 @@ namespace CUETools.Processor decoders.Add("takc", new CUEToolsUDC("takc", "tak", true, "", "", "takc.exe", "-d %I -")); decoders.Add("ffmpeg alac", new CUEToolsUDC("ffmpeg alac", "m4a", true, "", "", "ffmpeg.exe", "-v 0 -i %I -f wav -")); - decoders.Add("wma2wav", new CUEToolsUDC("wma2wav", "wma", true, "", "", "ffmpeg.exe", "-v 0 -i %I -f wav -")); + decoders.Add("wma2wav", new CUEToolsUDC("wma2wav", "wma", true, "", "", "wma2wav.exe", "-s -i %I -w -o -")); } else { @@ -186,7 +186,7 @@ namespace CUETools.Processor formats.Add("wav", new CUEToolsFormat("wav", CUEToolsTagger.TagLibSharp, true, false, true, false, true, encoders.GetDefault("wav", true), null, GetDefaultDecoder("wav"))); formats.Add("m4a", new CUEToolsFormat("m4a", CUEToolsTagger.TagLibSharp, true, true, false, false, true, encoders.GetDefault("m4a", true), encoders.GetDefault("m4a", false), GetDefaultDecoder("m4a"))); formats.Add("tak", new CUEToolsFormat("tak", CUEToolsTagger.APEv2, true, false, true, true, true, encoders.GetDefault("tak", true), null, "takc")); - formats.Add("wma", new CUEToolsFormat("wma", CUEToolsTagger.TagLibSharp, true, true, false, false, true, encoders.GetDefault("wma", true), null, "wma2wav")); + formats.Add("wma", new CUEToolsFormat("wma", CUEToolsTagger.TagLibSharp, true, true, false, false, true, encoders.GetDefault("wma", true), null, "builtin wma")); formats.Add("mp3", new CUEToolsFormat("mp3", CUEToolsTagger.TagLibSharp, false, true, false, false, true, null, encoders.GetDefault("mp3", false), null)); formats.Add("ogg", new CUEToolsFormat("ogg", CUEToolsTagger.TagLibSharp, false, true, false, false, true, null, encoders.GetDefault("ogg", false), null)); diff --git a/CUETools.Processor/CUEConfigAdvanced.cs b/CUETools.Processor/CUEConfigAdvanced.cs index 86c2141..85eafe4 100644 --- a/CUETools.Processor/CUEConfigAdvanced.cs +++ b/CUETools.Processor/CUEConfigAdvanced.cs @@ -52,7 +52,7 @@ namespace CUETools.Processor [DefaultValue(""), Category("Proxy"), DisplayName("Proxy auth password")] public string ProxyPassword { get; set; } - [DefaultValue(true), Category("Cache"), DisplayName("Cache metadata")] + [DefaultValue(true), DisplayName("Cache metadata")] public bool CacheMetadata { get; set; } [DefaultValue(new string[] { "folder.jpg", "cover.jpg", "albumart.jpg", "thumbnail.jpg", "albumartlarge.jpg", "front.jpg", "%album%.jpg" })] diff --git a/CUETools/CUETools.sln b/CUETools/CUETools.sln index 4fe2960..574dd4c 100644 --- a/CUETools/CUETools.sln +++ b/CUETools/CUETools.sln @@ -175,6 +175,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Third Party Libraries", "Th EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "taglib-sharp", "..\taglib-sharp\src\taglib-sharp.csproj", "{6B143A39-C7B2-4743-9917-92262C60E9A6}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WindowsMediaLib", "..\WindowsMediaLib\WindowsMediaLib.csproj", "{7EA4160F-3BBD-47C9-A38C-4053B64B24A8}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CUETools.Codecs.WMA", "..\CUETools.Codecs.WMA\CUETools.Codecs.WMA.csproj", "{082D6B9E-326E-4D15-9798-DE70A6EDAE9E}" +EndProject Global GlobalSection(TestCaseManagementSettings) = postSolution CategoryFile = CUETools1.vsmdi @@ -1042,6 +1046,34 @@ Global {6B143A39-C7B2-4743-9917-92262C60E9A6}.Release|Win32.ActiveCfg = Release|Any CPU {6B143A39-C7B2-4743-9917-92262C60E9A6}.Release|x64.ActiveCfg = Release|Any CPU {6B143A39-C7B2-4743-9917-92262C60E9A6}.Release|x86.ActiveCfg = Release|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Debug|Win32.ActiveCfg = Debug|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Debug|x64.ActiveCfg = Debug|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Debug|x86.ActiveCfg = Debug|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Release|Any CPU.Build.0 = Release|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Release|Win32.ActiveCfg = Release|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Release|x64.ActiveCfg = Release|Any CPU + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8}.Release|x86.ActiveCfg = Release|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Debug|Any CPU.Build.0 = Debug|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Debug|Win32.ActiveCfg = Debug|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Debug|x64.ActiveCfg = Debug|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Debug|x86.ActiveCfg = Debug|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Release|Any CPU.ActiveCfg = Release|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Release|Any CPU.Build.0 = Release|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Release|Win32.ActiveCfg = Release|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Release|x64.ActiveCfg = Release|Any CPU + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E}.Release|x86.ActiveCfg = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -1077,6 +1109,7 @@ Global {082D6B9E-326E-4D15-9798-EDAE9EDE70A6} = {93B7AE1D-DEF6-4A04-A222-5CDE09DF262D} {1AF02E2C-2CB2-44B5-B417-37653071FEC6} = {93B7AE1D-DEF6-4A04-A222-5CDE09DF262D} {DFE55765-564C-4B8F-993B-A94C4D1C212E} = {93B7AE1D-DEF6-4A04-A222-5CDE09DF262D} + {082D6B9E-326E-4D15-9798-DE70A6EDAE9E} = {93B7AE1D-DEF6-4A04-A222-5CDE09DF262D} {04945FB2-8410-4F14-8262-2ED18DCDACD6} = {D9D97BB6-002F-4858-8EF2-49B4C4C4DDB4} {A430AD28-B76A-4ED0-AF7D-D13B8969297F} = {D9D97BB6-002F-4858-8EF2-49B4C4C4DDB4} {5C8B61C0-BC3D-4316-B8A7-419D55BB5796} = {D9D97BB6-002F-4858-8EF2-49B4C4C4DDB4} diff --git a/WindowsMediaLib/AssemblyInfo.cs b/WindowsMediaLib/AssemblyInfo.cs new file mode 100644 index 0000000..07ef287 --- /dev/null +++ b/WindowsMediaLib/AssemblyInfo.cs @@ -0,0 +1,50 @@ +#region license + +/* +WindowsMediaLib - Provide access to Windows Media interfaces via .NET +Copyright (C) 2008 +http://sourceforge.net/projects/windowsmedianet/ + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#endregion + +using System; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Security.Permissions; + +[assembly: AssemblyTitle("Windows Media .NET library")] +[assembly: AssemblyDescription(".NET Interfaces for calling Windows Media. See http://windowsmedianet.sourceforge.net/")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: Guid("FA40A71D-13EA-4890-B916-FD76A57D4BAE")] +[assembly: AssemblyVersion("1.1.0.*")] +#if DEBUG +[assembly: AssemblyProduct("Debug Version")] +#else +[assembly : AssemblyProduct("Release Version")] +#endif +[assembly: AssemblyCopyright("Lesser General Public License Version 2.1")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[assembly: AssemblyDelaySign(false)] +[assembly: AssemblyKeyFile("")] +[assembly: AssemblyKeyName("")] + +[assembly: ComVisible(false)] +[assembly: CLSCompliant(true)] +[assembly: SecurityPermission(SecurityAction.RequestMinimum, UnmanagedCode = true)] diff --git a/WindowsMediaLib/MMIO.cs b/WindowsMediaLib/MMIO.cs new file mode 100644 index 0000000..b6c9495 --- /dev/null +++ b/WindowsMediaLib/MMIO.cs @@ -0,0 +1,1512 @@ +#region license + +/* +WindowsMediaLib - Provide access to Windows Media interfaces via .NET +Copyright (C) 2008 +http://sourceforge.net/projects/windowsmedianet + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#endregion + +using System; +using System.Text; +using System.Runtime.InteropServices; +using System.Security; + +using WindowsMediaLib; +using WindowsMediaLib.Defs; + +namespace MultiMedia +{ + #region Enums + + [Flags] + public enum WaveOpenFlags + { + None = 0, + FormatQuery = 0x0001, + AllowSync = 0x0002, + Mapped = 0x0004, + FormatDirect = 0x0008, + Null = 0x00000000, /* no callback */ + Window = 0x00010000, /* dwCallback is a HWND */ + Thread = 0x00020000, /* dwCallback is a THREAD */ + Function = 0x00030000, /* dwCallback is a FARPROC */ + Event = 0x00050000 /* dwCallback is an EVENT Handle */ + } + + [Flags] + public enum SupportedFormats + { + InvalidFormat = 0x00000000, /* invalid format */ + F1M08 = 0x00000001, /* 11.025 kHz, Mono, 8-bit */ + F1S08 = 0x00000002, /* 11.025 kHz, Stereo, 8-bit */ + F1M16 = 0x00000004, /* 11.025 kHz, Mono, 16-bit */ + F1S16 = 0x00000008, /* 11.025 kHz, Stereo, 16-bit */ + F2M08 = 0x00000010, /* 22.05 kHz, Mono, 8-bit */ + F2S08 = 0x00000020, /* 22.05 kHz, Stereo, 8-bit */ + F2M16 = 0x00000040, /* 22.05 kHz, Mono, 16-bit */ + F2S16 = 0x00000080, /* 22.05 kHz, Stereo, 16-bit */ + + F44M08 = 0x00000100, /* 44.1 kHz, Mono, 8-bit */ + F44S08 = 0x00000200, /* 44.1 kHz, Stereo, 8-bit */ + F44M16 = 0x00000400, /* 44.1 kHz, Mono, 16-bit */ + F44S16 = 0x00000800, /* 44.1 kHz, Stereo, 16-bit */ + F48M08 = 0x00001000, /* 48 kHz, Mono, 8-bit */ + F48S08 = 0x00002000, /* 48 kHz, Stereo, 8-bit */ + F48M16 = 0x00004000, /* 48 kHz, Mono, 16-bit */ + F48S16 = 0x00008000, /* 48 kHz, Stereo, 16-bit */ + F96M08 = 0x00010000, /* 96 kHz, Mono, 8-bit */ + F96S08 = 0x00020000, /* 96 kHz, Stereo, 8-bit */ + F96M16 = 0x00040000, /* 96 kHz, Mono, 16-bit */ + F96S16 = 0x00080000, /* 96 kHz, Stereo, 16-bit */ + } + + public enum MOWM + { + WOM_OPEN = 0x3BB, + WOM_CLOSE = 0x3BC, + WOM_DONE = 0x3BD, + } + + public enum MIWM + { + WIM_OPEN = 0x3BE, /* waveform input */ + WIM_CLOSE = 0x3BF, + WIM_DATA = 0x3C0 + } + + [Flags] + public enum WaveCapsFlags + { + None = 0, + Pitch = 0x0001, /* supports pitch control */ + PlaybackRate = 0x0002, /* supports playback rate control */ + Volume = 0x0004, /* supports volume control */ + LRVolume = 0x0008, /* separate left-right volume control */ + Sync = 0x0010, + SampleAccurate = 0x0020 + } + + [Flags] + public enum RiffChunkFlags + { + None = 0, + FindChunk = 0x0010, /* mmioDescend: find a chunk by ID */ + FindRiff = 0x0020, /* mmioDescend: find a LIST chunk */ + FindList = 0x0040, /* mmioDescend: find a RIFF chunk */ + CreateRiff = 0x0020, /* mmioCreateChunk: make a LIST chunk */ + CreateList = 0x0040 /* mmioCreateChunk: make a RIFF chunk */ + } + + [Flags] + public enum MMIOCloseFlags + { + None = 0, + FHOPEN = 0x0010 /* mmioClose: keep file handle open */ + } + + [Flags] + public enum MMIOFlushFlags + { + None = 0, + EmptyBuf = 0x0010 /* mmioFlush: empty the I/O buffer */ + } + + public enum MMIOSeekFlags + { + Set = 0, + Cur = 1, + End = 2 + } + + public enum RWMode + { + Read = 0x00000000, /* open file for reading only */ + Write = 0x00000001, /* open file for writing only */ + ReadWrite = 0x00000002 /* open file for reading and writing */ + } + + public enum MMIOError + { + NoError = 0, + FileNotFound = 257, /* file not found */ + OutOfMemory = 258, /* out of memory */ + CannotOpen = 259, /* cannot open */ + CannotClose = 260, /* cannot close */ + CannotRead = 261, /* cannot read */ + CannotWrite = 262, /* cannot write */ + CannotSeek = 263, /* cannot seek */ + CannotExpand = 264, /* cannot expand file */ + ChunkNotFound = 265, /* chunk not found */ + Unbuffered = 266, /* */ + PathNotFound = 267, /* path incorrect */ + AccessDenied = 268, /* file was protected */ + SharingViolation = 269, /* file in use */ + NetworkError = 270, /* network not responding */ + TooManyOpenFiles = 271, /* no more file handles */ + InvalidFile = 272 /* default error file error */ + } + + [Flags] + public enum MMIOFlags + { + /* constants for dwFlags field of MMIOINFO */ + Create = 0x00001000, /* create new file (or truncate file) */ + Parse = 0x00000100, /* parse new file returning path */ + Delete = 0x00000200, /* create new file (or truncate file) */ + Exist = 0x00004000, /* checks for existence of file */ + AllocBuf = 0x00010000, /* mmioOpen() should allocate a buffer */ + GetTemp = 0x00020000, /* mmioOpen() should retrieve temp name */ + + Dirty = 0x10000000, /* I/O buffer is dirty */ + + /* read/write mode numbers (bit field MMIO_RWMODE) */ + Read = 0x00000000, /* open file for reading only */ + Write = 0x00000001, /* open file for writing only */ + ReadWrite = 0x00000002, /* open file for reading and writing */ + + /* share mode numbers (bit field MMIO_SHAREMODE) */ + Compat = 0x00000000, /* compatibility mode */ + Exclusive = 0x00000010, /* exclusive-access mode */ + DenyWrite = 0x00000020, /* deny writing to other processes */ + DenyRead = 0x00000030, /* deny reading to other processes */ + DenyNone = 0x00000040, /* deny nothing to other processes */ + } + + // From MIXER_GETLINEINFOF_* defines and MIXER_OBJECTF_* defines + [Flags] + public enum MIXER_GETLINEINFOF + { + Destination = 0x00000000, + Source = 0x00000001, + LineID = 0x00000002, + ComponentType = 0x00000003, + TargetType = 0x00000004, + + Mixer = 0x00000000, + WaveOut = 0x10000000, + WaveIn = 0x20000000, + MidiOut = 0x30000000, + MidiIn = 0x40000000, + Aux = 0x50000000, + Handle = unchecked((int)0x80000000), + HMidiIn = (Handle | MidiIn), + HMidiOut = (Handle | MidiOut), + HMixer = (Handle | Mixer), + HWaveIn = (Handle | WaveIn), + HWaveOut = (Handle | WaveOut) + } + + // From MIXER_SETCONTROLDETAILSF_* defines and MIXER_OBJECTF_* defines + [Flags] + public enum MIXER_SETCONTROLDETAILSF + { + Value = 0x00000000, + Custom = 0x00000001, + + QueryMask = 0x0000000F, + + Mixer = 0x00000000, + WaveOut = 0x10000000, + WaveIn = 0x20000000, + MidiOut = 0x30000000, + MidiIn = 0x40000000, + Aux = 0x50000000, + Handle = unchecked((int)0x80000000), + HMidiIn = (Handle | MidiIn), + HMidiOut = (Handle | MidiOut), + HMixer = (Handle | Mixer), + HWaveIn = (Handle | WaveIn), + HWaveOut = (Handle | WaveOut) + } + + // From MIXER_GETLINECONTROLSF_* defines combined with MIXER_OBJECTF_* defines + [Flags] + public enum MIXER_GETLINECONTROLSF + { + All = 0x00000000, + OneByID = 0x00000001, + OneByType = 0x00000002, + QueryMask = 0x0000000F, + + Mixer = 0x00000000, + WaveOut = 0x10000000, + WaveIn = 0x20000000, + MidiOut = 0x30000000, + MidiIn = 0x40000000, + Aux = 0x50000000, + Handle = unchecked((int)0x80000000), + HMidiIn = (Handle | MidiIn), + HMidiOut = (Handle | MidiOut), + HMixer = (Handle | Mixer), + HWaveIn = (Handle | WaveIn), + HWaveOut = (Handle | WaveOut) + } + + // From MIXER_OBJECTF_* defines + [Flags] + public enum MIXER_OBJECTF + { + GetControlDetailsF_Value = 0x0, + GetControlDetailsF_ListText = 0x00000001, + + CallBack_Window = 0x00010000, /* dwCallback is an HWND */ + + Mixer = 0x00000000, + WaveOut = 0x10000000, + WaveIn = 0x20000000, + MidiOut = 0x30000000, + MidiIn = 0x40000000, + Aux = 0x50000000, + Handle = unchecked((int)0x80000000), + HMidiIn = (Handle | MidiIn), + HMidiOut = (Handle | MidiOut), + HMixer = (Handle | Mixer), + HWaveIn = (Handle | WaveIn), + HWaveOut = (Handle | WaveOut) + } + + // From MIXERCONTROL_CONTROLF_* defines + [Flags] + public enum MIXERCONTROL_CONTROLF + { + None = 0, + Uniform = 0x00000001, + Multiple = 0x00000002, + Disabled = unchecked((int)0x80000000) + } + + // From MIXERCONTROL_CONTROLTYPE defines + [Flags] + public enum MIXERCONTROL_CONTROLTYPE + { + ClassFader = 0x50000000, + ClassList = 0x70000000, + SCListSingle = 0x00000000, + UnitsBoolean = 0x00010000, + UnitsUnsigned = 0x30000, + SCListMultiple = 0x01000000, + + Fader = (ClassFader | UnitsUnsigned), + MultipleSelect = (ClassList | SCListMultiple | UnitsBoolean), + SingleSelect = (ClassList | SCListSingle | UnitsBoolean), + Mixer = (MultipleSelect + 1), + Mux = (SingleSelect + 1), + Volume = (Fader + 1) + } + + // From MIXERCONTROL_CT_* defines combined with MIXERCONTROL_CONTROLTYPE_* defines + [Flags] + public enum ControlType + { + Class_Mask = unchecked((int)0xF0000000), + Class_Custom = 0x00000000, + Class_Meter = 0x10000000, + Class_Switch = 0x20000000, + Class_Number = 0x30000000, + Class_Slider = 0x40000000, + Class_Fader = 0x50000000, + Class_Time = 0x60000000, + Class_List = 0x70000000, + + SubClassMask = 0x0F000000, + + SC_SwitchBoolean = 0x00000000, + SC_SwitchButton = 0x01000000, + + SC_MeterPolled = 0x00000000, + + SC_TimeMicroSecs = 0x00000000, + SC_TimeMilliSecs = 0x01000000, + + SC_ListSingle = 0x00000000, + SC_ListMultiple = 0x01000000, + + Units_Mask = 0x00FF0000, + Units_Custom = 0x00000000, + Units_Boolean = 0x00010000, + Units_Signed = 0x00020000, + Units_Unsigned = 0x00030000, + Units_Decibels = 0x00040000, /* in 10ths */ + Units_Percent = 0x00050000, /* in 10ths */ + + Custom = (Class_Custom | Units_Custom), + BooleanMeter = (Class_Meter | SC_MeterPolled | Units_Boolean), + SignedMeter = (Class_Meter | SC_MeterPolled | Units_Signed), + PeakMeter = (SignedMeter + 1), + UnsignedMeter = (Class_Meter | SC_MeterPolled | Units_Unsigned), + Boolean = (Class_Switch | SC_SwitchBoolean | Units_Boolean), + OnOff = (Boolean + 1), + Mute = (Boolean + 2), + Mono = (Boolean + 3), + Loudness = (Boolean + 4), + StereoEnh = (Boolean + 5), + BassBoost = (Boolean + 0x00002277), + Button = (Class_Switch | SC_SwitchButton | Units_Boolean), + Decibels = (Class_Number | Units_Decibels), + Signed = (Class_Number | Units_Signed), + Unsigned = (Class_Number | Units_Unsigned), + Percent = (Class_Number | Units_Percent), + Slider = (Class_Slider | Units_Signed), + Pan = (Slider + 1), + QSoundPan = (Slider + 2), + Fader = (Class_Fader | Units_Unsigned), + Volume = (Fader + 1), + Bass = (Fader + 2), + Treble = (Fader + 3), + Equalizer = (Fader + 4), + SingleSelect = (Class_List | SC_ListSingle | Units_Boolean), + Mux = (SingleSelect + 1), + MultipleSelect = (Class_List | SC_ListMultiple | Units_Boolean), + Mixer = (MultipleSelect + 1), + MicroTime = (Class_Time | SC_TimeMicroSecs | Units_Unsigned), + MilliTime = (Class_Time | SC_TimeMilliSecs | Units_Unsigned) + } + + // From MIXERLINE_TARGETTYPE_* defines + public enum MIXERLINE_TARGETTYPE + { + Undefined = 0, + WaveOut, + WaveIn, + MidiOut, + MidiIn, + Aux + } + + // From MIXERLINE_COMPONENTTYPE_* defines + public enum MIXERLINE_COMPONENTTYPE + { + DST_First = 0x00000000, + DST_Undefined = (DST_First + 0), + DST_Digital = (DST_First + 1), + DST_Line = (DST_First + 2), + DST_Monitor = (DST_First + 3), + DST_Speakers = (DST_First + 4), + DST_Headphones = (DST_First + 5), + DST_Telephone = (DST_First + 6), + DST_WaveIn = (DST_First + 7), + DST_VoiceIn = (DST_First + 8), + DST_Last = (DST_First + 8), + + SRC_First = 0x00001000, + SRC_Undefined = (SRC_First + 0), + SRC_Digital = (SRC_First + 1), + SRC_Line = (SRC_First + 2), + SRC_Microphone = (SRC_First + 3), + SRC_Synthesizer = (SRC_First + 4), + SRC_CompactDisc = (SRC_First + 5), + SRC_Telephone = (SRC_First + 6), + SRC_PCSpeaker = (SRC_First + 7), + SRC_WaveOut = (SRC_First + 8), + SRC_Auxillary = (SRC_First + 9), + SRC_Analog = (SRC_First + 10), + SRC_Last = (SRC_First + 10), + + Invalid = -1 + } + + // From MIXERLINE_LINEF_* defines + [Flags] + public enum MIXERLINE_LINEF + { + None = 0, + Active = 0x00000001, + Disconnected = 0x00008000, + Source = unchecked((int)0x80000000) + } + + // From MMSYSERR_* defines + public enum MMSYSERR + { + NoError = 0, /* no error */ + Error, /* unspecified error */ + BadDeviceID, /* device ID out of range */ + NotEnabled, /* driver failed enable */ + Allocated, /* device already allocated */ + InvalHandle, /* device handle is invalid */ + NoDriver, /* no device driver present */ + NoMem, /* memory allocation error */ + NotSupported, /* function isn't supported */ + BadErrNum, /* error value out of range */ + InvalFlag, /* invalid flag passed */ + InvalParam, /* invalid parameter passed */ + HandleBusy, /* handle being used simultaneously on another thread (eg callback) */ + InvalidAlias, /* specified alias not found */ + BadDB, /* bad registry database */ + KeyNotFound, /* registry key not found */ + ReadError, /* registry read error */ + WriteError, /* registry write error */ + DeleteError, /* registry delete error */ + ValNotFound, /* registry value not found */ + NoDriverCB, /* driver does not call DriverCallback */ + MoreData, /* more data to be returned */ + + InvalLine = (1024 + 0), + InvalControl, + InvalValue + } + + #endregion + + #region Structs + + [StructLayout(LayoutKind.Sequential, Pack = 4, CharSet = CharSet.Unicode), + UnmanagedName("WAVEOUTCAPSW")] + public class WaveOutCaps + { + public short wMid; /* manufacturer ID */ + public short wPid; /* product ID */ + public int vDriverVersion; /* version of the driver */ + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)] + public string szPname; /* product name (NULL terminated string) */ + public SupportedFormats dwFormats; /* formats supported */ + public short wChannels; /* number of sources supported */ + public short wReserved1; /* packing */ + public WaveCapsFlags dwSupport; /* functionality supported by driver */ + } + + [StructLayout(LayoutKind.Sequential, Pack = 4, CharSet = CharSet.Unicode), + UnmanagedName("WAVEINCAPSW")] + public class WaveInCaps + { + public short wMid; + public short wPid; + public int vDriverVersion; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)] + public string szPname; + public SupportedFormats dwFormats; + public short wChannels; + public short wReserved1; + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("MMTIME")] + public class MMTIME + { + [Flags] + public enum MMTimeFlags + { + MS = 0x0001, /* time in milliseconds */ + Samples = 0x0002, /* number of wave samples */ + Bytes = 0x0004, /* current byte offset */ + SMPTE = 0x0008, /* SMPTE time */ + Midi = 0x0010, /* MIDI time */ + Ticks = 0x0020 /* Ticks within MIDI stream */ + } + + public MMTimeFlags wType; + public int u; + public int x; + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("WAVEHDR")] + public class WAVEHDR : IDisposable + { + [Flags] + public enum WHDR + { + None = 0x0, + Done = 0x00000001, /* done bit */ + Prepared = 0x00000002, /* set if this header has been prepared */ + BeginLoop = 0x00000004, /* loop start block */ + EndLoop = 0x00000008, /* loop end block */ + InQueue = 0x00000010 /* reserved for driver */ + } + + public IntPtr lpData; + public int dwBufferLength; + public int dwBytesRecorded; + public IntPtr dwUser; + public WHDR dwFlags; + public int dwLoops; + public IntPtr lpNext; + public IntPtr Reserved; + + public WAVEHDR() + { + } + + public WAVEHDR(int iMaxSize) + { + lpData = Marshal.AllocCoTaskMem(iMaxSize); + dwBufferLength = iMaxSize; + dwUser = IntPtr.Zero; + dwFlags = WHDR.None; + dwLoops = 0; + lpNext = IntPtr.Zero; + Reserved = IntPtr.Zero; + } + + #region IDisposable Members + + public void Dispose() + { + if (lpData != IntPtr.Zero) + { + Marshal.FreeCoTaskMem(lpData); + lpData = IntPtr.Zero; + } + } + + #endregion + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("MMCKINFO")] + public class MMCKINFO + { + public FourCC ckid; + public int ckSize; + public FourCC fccType; + public int dwDataOffset; + public MMIOFlags dwFlags; + } + + [StructLayout(LayoutKind.Sequential, Pack=1), UnmanagedName("MMIOINFO")] + public class MMIOINFO + { + public MMIOFlags dwFlags; + public FourCC fccIOProc; + public IntPtr pIOProc; + public MMIOError wErrorRet; + public IntPtr htask; + public int cchBuffer; + public IntPtr pchBuffer; + public IntPtr pchNext; + public IntPtr pchEndRead; + public IntPtr pchEndWrite; + public int lBufOffset; + public int lDiskOffset; + public int adwInfo1; + public int adwInfo2; + public int adwInfo3; + public int dwReserved1; + public int dwReserved2; + public IntPtr hmmio; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), UnmanagedName("MIXERCAPS")] + public class MixerCaps + { + public const int MAXPNAMELEN = 32; + + public short wMid; + public short wPid; + public int vDriverVersion; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAXPNAMELEN)] + public string szPname; + public int fdwSupport; // Zero + public int cDestinations; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1), UnmanagedName("MIXERCONTROLDETAILS")] + public class MixerControlDetails + { + public int cbStruct; // size in Bytes of MIXERCONTROLDETAILS + public int dwControlID; // control id to get/set details on + public int cChannels; // number of channels in paDetails array + public MCDUnion item; // hwndOwner or cMultipleItems + public int cbDetails; // size of _one_ details_XX struct + public IntPtr paDetails; // pointer to array of details_XX structs + + public MixerControlDetails() + { + item = new MCDUnion(); + } + } + + [StructLayout(LayoutKind.Explicit, Pack = 1)] + public class MCDUnion + { + [FieldOffset(0)] + public IntPtr hwndOwner; + [FieldOffset(0)] + public int cMultipleItems; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1), UnmanagedName("MIXERLINECONTROLS")] + public class MixerLineControls + { + public int cbStruct; // size in Byte of MIXERLINECONTROLS + public int dwLineID; // line id (from MIXERLINE.dwLineID) + public int dwControl; // MIXER_GETLINECONTROLSF_ONEBYID or MIXER_GETLINECONTROLSF_ONEBYTYPE + public int cControls; // count of controls pmxctrl points to + public int cbmxctrl; // size in Byte of _one_ MIXERCONTROL + public MixerControl[] pamxctrl; // pointer to first MIXERCONTROL array + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("MIXERCONTROLDETAILS_UNSIGNED")] + public class MixerControlDetailsUnsigned + { + public int dwValue; // value of the control + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("MIXERCONTROLDETAILS_SIGNED")] + public struct MixerControlDetailsSigned + { + public int dwValue; // value of the control + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("MIXERCONTROLDETAILS_BOOLEAN")] + public struct MixerControlDetailsBoolean + { + [MarshalAs(UnmanagedType.Bool)] + public bool fValue; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), UnmanagedName("MIXERCONTROLDETAILS_LISTTEXT")] + public struct MixerControlDetailsListText + { + public const int MIXER_LONG_NAME_CHARS = 64; + + public int dwParam1; + public int dwParam2; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MIXER_LONG_NAME_CHARS)] + public string szName; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), UnmanagedName("MIXERLINE")] + public class MixerLine + { + public const int MIXER_SHORT_NAME_CHARS = 16; + public const int MIXER_LONG_NAME_CHARS = 64; + public const int MAXPNAMELEN = 32; + + public int cbStruct; // size of MIXERLINE structure + public int dwDestination; // zero based destination index + public int dwSource; // zero based source index (if source) + public int dwLineID; // unique line id for mixer device + public MIXERLINE_LINEF fdwLine; // state/information about line + public IntPtr dwUser; // driver specific information + public MIXERLINE_COMPONENTTYPE dwComponentType; // component type line connects to + public int cChannels; // number of channels line supports + public int cConnections; // number of connections (possible) + public int cControls; // number of controls at this line + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MIXER_SHORT_NAME_CHARS)] + public string szShortName; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MIXER_LONG_NAME_CHARS)] + public string szName; + public MIXERLINE_TARGETTYPE dwType; + public int dwDeviceID; + public short wMid; + public short wPid; + public int vDriverVersion; + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MAXPNAMELEN)] + public string szPname; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1, CharSet = CharSet.Unicode), UnmanagedName("MIXERCONTROL")] + public class MixerControl + { + public const int MIXER_SHORT_NAME_CHARS = 16; + public const int MIXER_LONG_NAME_CHARS = 64; + public const int RESERVED1 = 4; + public const int RESERVED2 = 5; + + public int cbStruct; // size in Byte of MIXERCONTROL + public int dwControlID; // unique control id for mixer device + public ControlType dwControlType; // MIXERCONTROL_CONTROLTYPE_xxx + public MIXERCONTROL_CONTROLF fdwControl; // MIXERCONTROL_CONTROLF_xxx + public int cMultipleItems; // if MIXERCONTROL_CONTROLF_MULTIPLE set + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MIXER_SHORT_NAME_CHARS)] + public string szShortName; // short name of control + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = MIXER_LONG_NAME_CHARS)] + public string szName; // int name of control + public int lMinimum; // Minimum value + public int lMaximum; // Maximum value + [MarshalAs(UnmanagedType.ByValArray, SizeConst = RESERVED1)] + public int[] reservedBytes1; // reserved structure space + public int cSteps; // # of steps between min & max + [MarshalAs(UnmanagedType.ByValArray, SizeConst = RESERVED2)] + public int[] reservedBytes2; // reserved structure space + } + + #endregion + + public static class MMIO + { + public delegate int MMIOProc( + [In] string lpmmioinfo, + int uMsg, + IntPtr lParam1, + IntPtr lParam2 + ); + + public static string Errorstring(MMIOError i) + { + string sRet; + + switch (i) + { + case MMIOError.NoError: + sRet = "No error"; + break; + case MMIOError.FileNotFound: + sRet = "File not found"; + break; + case MMIOError.OutOfMemory: + sRet = "Out of memory"; + break; + case MMIOError.CannotOpen: + sRet = "Cannot open"; + break; + case MMIOError.CannotClose: + sRet = "Cannot close"; + break; + case MMIOError.CannotRead: + sRet = "Cannot read"; + break; + case MMIOError.CannotWrite: + sRet = "Cannot write"; + break; + case MMIOError.CannotSeek: + sRet = "Cannot seek"; + break; + case MMIOError.CannotExpand: + sRet = "Cannot expand file"; + break; + case MMIOError.ChunkNotFound: + sRet = "Chunk not found"; + break; + case MMIOError.Unbuffered: + sRet = "Unbuffered"; + break; + case MMIOError.PathNotFound: + sRet = "Path incorrect"; + break; + case MMIOError.AccessDenied: + sRet = "File was protected (Access denied)"; + break; + case MMIOError.SharingViolation: + sRet = "file in use (Sharing violation)"; + break; + case MMIOError.NetworkError: + sRet = "Network not responding"; + break; + case MMIOError.TooManyOpenFiles: + sRet = "No more file handles"; + break; + case MMIOError.InvalidFile: + sRet = "Invalid File"; + break; + default: + sRet = "Unknown error number: " + i.ToString(); + break; + } + return sRet; + } + + public static void ThrowExceptionForError(MMIOError i) + { + if (i != MMIOError.NoError) + { + throw new Exception(Errorstring(i)); + } + } + + #region Externs + +#if false + // These methods are unnecessary or deprecated + + [DllImport("winmm.dll", + CharSet = CharSet.Unicode, + ExactSpelling=true, + EntryPoint="mmioStringToFOURCCW"), + SuppressUnmanagedCodeSecurity] + public static extern FourCC mmioStringToFOURCC( + [In] string sz, + int uFlags); + + //LPMMIOPROC WINAPI mmioInstallIOProc( FOURCC fccIOProc, LPMMIOPROC pIOProc, DWORD dwFlags); +#endif + + [DllImport("winmm.dll", ExactSpelling = true, CharSet = CharSet.Unicode, EntryPoint = "mmioRenameW"), + SuppressUnmanagedCodeSecurity] + public static extern MMIOError Rename( + [In] string pszFileName, + [In] string pszNewFileName, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] MMIOINFO pmmioinfo, + int fdwRename); + + [DllImport("winmm.dll", EntryPoint = "mmioGetInfo"), + SuppressUnmanagedCodeSecurity] + public static extern MMIOError GetInfo( + IntPtr hmmio, + [Out, MarshalAs(UnmanagedType.LPStruct)] MMIOINFO pmmioinfo, + int fuInfo); + + [DllImport("winmm.dll", EntryPoint = "mmioSetInfo"), + SuppressUnmanagedCodeSecurity] + public static extern MMIOError SetInfo( + IntPtr hmmio, + [In, MarshalAs(UnmanagedType.LPStruct)] MMIOINFO pmmioinfo, + int fuInfo); + + [DllImport("winmm.dll", EntryPoint = "mmioSetBuffer"), + SuppressUnmanagedCodeSecurity] + public static extern MMIOError SetBuffer( + IntPtr hmmio, + IntPtr pchBuffer, + int cchBuffer, + int fuBuffer); + + [DllImport("winmm.dll", EntryPoint = "mmioAdvance"), + SuppressUnmanagedCodeSecurity] + public static extern MMIOError Advance( + IntPtr hmmio, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] MMIOINFO pmmioinfo, + RWMode fuAdvance); + + [DllImport("winmm.dll", EntryPoint = "mmioSendMessage"), + SuppressUnmanagedCodeSecurity] + public static extern MMIOError SendMessage( + IntPtr hmmio, + int uMsg, + IntPtr lParam1, + IntPtr lParam2); + + [DllImport("winmm.dll", EntryPoint = "mmioClose"), + SuppressUnmanagedCodeSecurity] + public static extern MMIOError Close( + IntPtr hmmio, + MMIOCloseFlags uFlags); + + [DllImport("winmm.dll", EntryPoint = "mmioFlush"), + SuppressUnmanagedCodeSecurity] + public static extern MMIOError Flush( + IntPtr hmmio, + MMIOFlushFlags uFlags); + + [DllImport("winmm.dll", EntryPoint = "mmioDescend"), + SuppressUnmanagedCodeSecurity] + public static extern MMIOError Descend( + IntPtr hmmio, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] MMCKINFO lpck, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] MMCKINFO lpckParent, + RiffChunkFlags uFlags); + + [DllImport("winmm.dll", EntryPoint = "mmioCreateChunk"), + SuppressUnmanagedCodeSecurity] + public static extern MMIOError CreateChunk( + IntPtr hmmio, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] MMCKINFO lpck, + RiffChunkFlags uFlags); + + [DllImport("winmm.dll", ExactSpelling = true, CharSet = CharSet.Unicode, EntryPoint = "mmioOpenW"), + SuppressUnmanagedCodeSecurity] + public static extern IntPtr Open( + [In] string szFileName, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] MMIOINFO lpmmioinfo, + MMIOFlags dwOpenFlags); + + [DllImport("winmm.dll", EntryPoint = "mmioRead"), + SuppressUnmanagedCodeSecurity] + public static extern MMIOError Read( + IntPtr hmmio, + IntPtr pch, + int cch); + + [DllImport("winmm.dll", EntryPoint = "mmioWrite"), + SuppressUnmanagedCodeSecurity] + public static extern int Write( + IntPtr hmmio, + IntPtr h, + int cch); + + [DllImport("winmm.dll", EntryPoint = "mmioSeek"), + SuppressUnmanagedCodeSecurity] + public static extern int Seek( + IntPtr hmmio, + int lOffset, + MMIOSeekFlags iOrigin); + + [DllImport("winmm.dll", EntryPoint = "mmioAscend"), + SuppressUnmanagedCodeSecurity] + public static extern MMIOError Ascend( + IntPtr hmmio, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] MMCKINFO lpck, + int uFlags); // must be zero + + #endregion + + } + + public static class waveIn + { + private const short MAXERRORLENGTH = 256; + + public delegate void WaveInDelegate( + IntPtr hwo, + MIWM uMsg, + IntPtr dwInstance, + IntPtr dwParam1, + IntPtr dwParam2); + + public static void ThrowExceptionForError(int rc) + { + if (rc != 0) + { + StringBuilder foo = new StringBuilder(MAXERRORLENGTH); + GetErrorText(rc, foo, MAXERRORLENGTH); + + throw new Exception(foo.ToString()); + } + } + + #region Externs + + // These methods are unnecessary or deprecated + + [DllImport("winmm.dll", EntryPoint="waveInGetID"), + SuppressUnmanagedCodeSecurity] + public static extern int GetID( + IntPtr hwi, + out int puDeviceID); + + [DllImport("winmm.dll", EntryPoint = "waveInGetPosition"), + SuppressUnmanagedCodeSecurity] + public static extern int GetPosition( + IntPtr hwi, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] MMTIME pmmt, + int cbmmt); + + [DllImport("winmm.dll", EntryPoint = "waveInMessage"), + SuppressUnmanagedCodeSecurity] + public static extern int Message( + IntPtr hwi, + int uMsg, + IntPtr dw1, + IntPtr dw2); + + [DllImport("winmm.dll", ExactSpelling = true, CharSet = CharSet.Unicode, EntryPoint = "waveInGetDevCapsW"), + SuppressUnmanagedCodeSecurity] + public static extern int GetDevCaps( + int uDeviceID, + [Out, MarshalAs(UnmanagedType.LPStruct)] WaveInCaps pwic, + int cbwic); + + [DllImport("winmm.dll", EntryPoint = "waveInGetNumDevs"), + SuppressUnmanagedCodeSecurity] + public static extern int GetNumDevs(); + + [DllImport("winmm.dll", EntryPoint = "waveInStop"), + SuppressUnmanagedCodeSecurity] + public static extern int Stop( + IntPtr hwi); + + [DllImport("winmm.dll", ExactSpelling = true, CharSet = CharSet.Unicode, EntryPoint = "waveInGetErrorTextW"), + SuppressUnmanagedCodeSecurity] + public static extern int GetErrorText( + int errvalue, + [Out] StringBuilder lpText, + int uSize); + + [DllImport("winmm.dll", EntryPoint = "waveInOpen"), + SuppressUnmanagedCodeSecurity] + public static extern int Open( + out IntPtr hwi, + int uDeviceID, + [In, MarshalAs(UnmanagedType.LPStruct)] WaveFormatEx b, + WaveInDelegate dwCallback, + IntPtr dwCallbackInstance, + WaveOpenFlags dwFlags); + + [DllImport("winmm.dll", EntryPoint = "waveInPrepareHeader"), + SuppressUnmanagedCodeSecurity] + public static extern int PrepareHeader( + IntPtr hwi, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] WAVEHDR lpWaveInHdr, + int uSize); + + [DllImport("winmm.dll", EntryPoint = "waveInUnprepareHeader"), + SuppressUnmanagedCodeSecurity] + public static extern int UnprepareHeader( + IntPtr hwi, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] WAVEHDR lpWaveInHdr, + int uSize); + + [DllImport("winmm.dll", EntryPoint = "waveInStart"), + SuppressUnmanagedCodeSecurity] + public static extern int Start( + IntPtr hwi); + + [DllImport("winmm.dll", EntryPoint = "waveInAddBuffer"), + SuppressUnmanagedCodeSecurity] + public static extern int AddBuffer( + IntPtr hwi, + IntPtr lpWaveInHdr, + int uSize); + + [DllImport("winmm.dll", EntryPoint = "waveInClose"), + SuppressUnmanagedCodeSecurity] + public static extern int Close( + IntPtr hwi); + + [DllImport("winmm.dll", EntryPoint = "waveInReset"), + SuppressUnmanagedCodeSecurity] + public static extern int Reset( + IntPtr hwi); + + #endregion + + } + + public static class waveOut + { + private const short MAXERRORLENGTH = 256; + + public delegate void WaveOutDelegate( + IntPtr hwo, + MOWM uMsg, + IntPtr dwInstance, + IntPtr dwParam1, + IntPtr dwParam2); + + public static void ThrowExceptionForError(int rc) + { + if (rc != 0) + { + StringBuilder foo = new StringBuilder(MAXERRORLENGTH); + GetErrorText(rc, foo, MAXERRORLENGTH); + + throw new Exception(foo.ToString()); + } + } + + #region Externs + + [DllImport("winmm.dll", EntryPoint = "waveOutGetID"), + SuppressUnmanagedCodeSecurity] + public static extern int GetID( + IntPtr hwo, + out int puDeviceID); + + [DllImport("winmm.dll", EntryPoint = "waveOutGetNumDevs"), + SuppressUnmanagedCodeSecurity] + public static extern int GetNumDevs(); + + [DllImport("winmm.dll", ExactSpelling = true, CharSet = CharSet.Unicode, EntryPoint = "waveOutGetDevCapsW"), + SuppressUnmanagedCodeSecurity] + public static extern int GetDevCaps( + int uDeviceID, + [Out, MarshalAs(UnmanagedType.LPStruct)] WaveOutCaps pwoc, + int cbwoc); + + [DllImport("winmm.dll", EntryPoint = "waveOutGetPitch"), + SuppressUnmanagedCodeSecurity] + public static extern int GetPitch( + IntPtr hwo, + out int pdwPitch); + + [DllImport("winmm.dll", EntryPoint = "waveOutSetPitch"), + SuppressUnmanagedCodeSecurity] + public static extern int SetPitch( + IntPtr hwo, + int dwPitch); + + [DllImport("winmm.dll", EntryPoint = "waveOutGetPlaybackRate"), + SuppressUnmanagedCodeSecurity] + public static extern int GetPlaybackRate( + IntPtr hwo, + out int pdwRate); + + [DllImport("winmm.dll", EntryPoint = "waveOutSetPlaybackRate"), + SuppressUnmanagedCodeSecurity] + public static extern int SetPlaybackRate( + IntPtr hwo, + int dwRate); + + [DllImport("winmm.dll", EntryPoint = "waveOutMessage"), + SuppressUnmanagedCodeSecurity] + public static extern int Message( + IntPtr hwo, + int uMsg, + IntPtr dw1, + IntPtr dw2); + + [DllImport("winmm.dll", EntryPoint = "waveOutBreakLoop"), + SuppressUnmanagedCodeSecurity] + public static extern int BreakLoop( + IntPtr hwo); + + [DllImport("winmm.dll", EntryPoint = "waveOutGetPosition"), + SuppressUnmanagedCodeSecurity] + public static extern int GetPosition( + IntPtr hWaveOut, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] MMTIME lpInfo, + int uSize); + + [DllImport("winmm.dll", ExactSpelling = true, CharSet = CharSet.Unicode, EntryPoint = "waveOutGetErrorTextW"), + SuppressUnmanagedCodeSecurity] + public static extern int GetErrorText( + int errvalue, + [Out] StringBuilder lpText, + int uSize); + + [DllImport("winmm.dll", EntryPoint = "waveOutOpen"), + SuppressUnmanagedCodeSecurity] + public static extern int Open( + out IntPtr hWaveOut, + int uDeviceID, + [In, MarshalAs(UnmanagedType.LPStruct)] WaveFormatEx b, + WaveOutDelegate dwCallback, // If using Function callback + IntPtr dwCallbackInstance, + WaveOpenFlags dwFlags); + + [DllImport("winmm.dll", EntryPoint = "waveOutOpen"), + SuppressUnmanagedCodeSecurity] + public static extern int Open( + out IntPtr hWaveOut, + int uDeviceID, + [In, MarshalAs(UnmanagedType.LPStruct)] WaveFormatEx b, + IntPtr dwCallback, // If using Event + IntPtr dwCallbackInstance, + WaveOpenFlags dwFlags); + + [DllImport("winmm.dll", EntryPoint = "waveOutPrepareHeader"), + SuppressUnmanagedCodeSecurity] + public static extern int PrepareHeader( + IntPtr hWaveOut, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] WAVEHDR lpWaveOutHdr, + int uSize); + + [DllImport("winmm.dll", EntryPoint = "waveOutReset"), + SuppressUnmanagedCodeSecurity] + public static extern int Reset( + IntPtr hWaveOut); + + [DllImport("winmm.dll", EntryPoint = "waveOutUnprepareHeader"), + SuppressUnmanagedCodeSecurity] + public static extern int UnprepareHeader( + IntPtr hWaveOut, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] WAVEHDR lpWaveOutHdr, + int uSize); + + [DllImport("winmm.dll", EntryPoint = "waveOutClose"), + SuppressUnmanagedCodeSecurity] + public static extern int Close( + IntPtr hWaveOut); + + [DllImport("winmm.dll", EntryPoint = "waveOutWrite"), + SuppressUnmanagedCodeSecurity] + public static extern int Write( + IntPtr hWaveOut, + IntPtr lpWaveOutHdr, + int uSize); + + [DllImport("winmm.dll", EntryPoint = "waveOutPause"), + SuppressUnmanagedCodeSecurity] + public static extern int Pause( + IntPtr hWaveOut); + + [DllImport("winmm.dll", EntryPoint = "waveOutRestart"), + SuppressUnmanagedCodeSecurity] + public static extern int Restart( + IntPtr hWaveOut); + + [DllImport("winmm.dll", EntryPoint = "waveOutSetVolume"), + SuppressUnmanagedCodeSecurity] + public static extern int SetVolume( + IntPtr uDeviceID, + int dwVolume); + + [DllImport("winmm.dll", EntryPoint = "waveOutGetVolume"), + SuppressUnmanagedCodeSecurity] + public static extern int GetVolume( + IntPtr uDeviceID, + out int lpdwVolume); + + #endregion + + } + + public static class Mixer + { + public const int LINE_CHANGE = 0x3D0; /* mixer line change notify */ + public const int CONTROL_CHANGE = 0x3D1; /* mixer control change notify */ + + #region Externals + + [DllImport("winmm.dll", EntryPoint = "mixerSetControlDetails"), + SuppressUnmanagedCodeSecurity] + public static extern MMSYSERR SetControlDetails( + IntPtr hmxobj, + [In, MarshalAs(UnmanagedType.LPStruct)] MixerControlDetails pmxcd, + MIXER_SETCONTROLDETAILSF fdwDetails); + + [DllImport("winmm.dll", CharSet = CharSet.Unicode, ExactSpelling = true, EntryPoint = "mixerGetControlDetailsW"), + SuppressUnmanagedCodeSecurity] + public static extern MMSYSERR GetControlDetails( + IntPtr hmxobj, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] MixerControlDetails pmxcd, + MIXER_OBJECTF fdwDetails); + + [DllImport("winmm.dll", EntryPoint = "mixerOpen"), + SuppressUnmanagedCodeSecurity] + public static extern MMSYSERR Open( + out IntPtr phmx, + int uMxId, + IntPtr dwCallback, + IntPtr dwInstance, + MIXER_OBJECTF fdwOpen); + + [DllImport("winmm.dll", EntryPoint = "mixerClose"), + SuppressUnmanagedCodeSecurity] + public static extern MMSYSERR Close( + IntPtr phmx); + + [DllImport("winmm.dll", CharSet = CharSet.Unicode, ExactSpelling = true, EntryPoint = "mixerGetLineInfoW"), + SuppressUnmanagedCodeSecurity] + public static extern MMSYSERR GetLineInfo( + IntPtr hmxobj, + [In, Out, MarshalAs(UnmanagedType.LPStruct)] MixerLine pmxl, + MIXER_GETLINEINFOF fdwInfo); + + [DllImport("winmm.dll", CharSet = CharSet.Unicode, ExactSpelling = true, EntryPoint = "mixerGetLineControlsW"), + SuppressUnmanagedCodeSecurity] + public static extern MMSYSERR GetLineControls( + IntPtr hmxobj, + [In, Out, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(MLCMarshaler))] MixerLineControls pmxlc, + MIXER_GETLINECONTROLSF fdwControls); + + [DllImport("winmm.dll", CharSet = CharSet.Unicode, ExactSpelling = true, EntryPoint = "mixerGetDevCapsW"), + SuppressUnmanagedCodeSecurity] + public static extern MMSYSERR GetDevCaps( + IntPtr uMxId, + [Out, MarshalAs(UnmanagedType.LPStruct)] MixerCaps pmxcaps, + int cbmxcaps); + + [DllImport("winmm.dll", EntryPoint = "mixerGetNumDevs"), + SuppressUnmanagedCodeSecurity] + public static extern int GetNumDevs(); + + [DllImport("winmm.dll", EntryPoint = "mixerGetID"), + SuppressUnmanagedCodeSecurity] + public static extern MMSYSERR GetID( + IntPtr hmxobj, + out int puMxId, + MIXER_OBJECTF fdwId); + + [DllImport("winmm.dll", EntryPoint = "mixerMessage"), + SuppressUnmanagedCodeSecurity] + public static extern int Message( + IntPtr driverID, + int uMsg, + IntPtr dwParam1, + IntPtr dwParam2); + + #endregion + + #region Public functions + + public static string Errorstring(MMSYSERR iError) + { + string sRet; + + switch (iError) + { + case MMSYSERR.NoError: + sRet = "The specified command was carried out."; + break; + case MMSYSERR.Error: + sRet = "Undefined external error."; + break; + case MMSYSERR.BadDeviceID: + sRet = "A device ID has been used that is out of range for your system."; + break; + case MMSYSERR.NotEnabled: + sRet = "The driver was not enabled."; + break; + case MMSYSERR.Allocated: + sRet = "The specified device is already in use. Wait until it is free, and then try again."; + break; + case MMSYSERR.InvalHandle: + sRet = "The specified device handle is invalid."; + break; + case MMSYSERR.NoDriver: + sRet = "There is no driver installed on your system."; + break; + case MMSYSERR.NoMem: + sRet = "There is not enough memory available for this task. Quit one or more applications to increase avai"; + break; + case MMSYSERR.NotSupported: + sRet = "This function is not supported. Use the Capabilities function to determine which functions and mes"; + break; + case MMSYSERR.BadErrNum: + sRet = "An error number was specified that is not defined in the system."; + break; + case MMSYSERR.InvalFlag: + sRet = "An invalid flag was passed to a system function."; + break; + case MMSYSERR.InvalParam: + sRet = "An invalid parameter was passed to a system function."; + break; + case MMSYSERR.HandleBusy: + sRet = "Handle being used simultaneously on another thread (eg callback)."; + break; + case MMSYSERR.InvalidAlias: + sRet = "Specified alias not found in WIN.INI."; + break; + case MMSYSERR.BadDB: + sRet = "The registry database is corrupt."; + break; + case MMSYSERR.KeyNotFound: + sRet = "The specified registry key was not found."; + break; + case MMSYSERR.ReadError: + sRet = "The registry could not be opened or could not be read."; + break; + case MMSYSERR.WriteError: + sRet = "The registry could not be written to."; + break; + case MMSYSERR.DeleteError: + sRet = "The specified registry key could not be deleted."; + break; + case MMSYSERR.ValNotFound: + sRet = "The specified registry key value could not be found."; + break; + case MMSYSERR.NoDriverCB: + sRet = "The driver did not generate a valid OPEN callback."; + break; + case MMSYSERR.MoreData: + sRet = "More data to be returned"; + break; + + case MMSYSERR.InvalLine: + sRet = "The line reference is invalid."; + break; + case MMSYSERR.InvalControl: + sRet = "The control reference is invalid."; + break; + case MMSYSERR.InvalValue: + sRet = "The value is invalid."; + break; + default: + sRet = "Unknown error code"; + break; + } + + return sRet; + } + + public static void ThrowExceptionForError(MMSYSERR i) + { + if (i != MMSYSERR.NoError) + { + throw new Exception(Errorstring(i)); + } + } + + #endregion + + } + + #region Internal code + + // Custom marshaler for Mixer.GetLineControls + internal class MLCMarshaler : ICustomMarshaler + { + // The managed object passed in to MarshalManagedToNative + protected MixerLineControls m_Control; + + protected int iMixContSize = Marshal.SizeOf(typeof(MixerControl)); + protected int iMixLineContSize = Marshal.SizeOf(typeof(MixerLineControls)); + + public IntPtr MarshalManagedToNative(object managedObj) + { + IntPtr p; + + // Cast the object back to a PropVariant + m_Control = managedObj as MixerLineControls; + + if (m_Control != null) + { + // Create an appropriately sized buffer, blank it, and send it to + // the marshaler to make the COM call with. + int iSize2 = m_Control.cControls * iMixContSize; + + p = Marshal.AllocCoTaskMem(iMixLineContSize + iSize2); +#if DEBUG + for (int x = 0; x < iMixLineContSize + iSize2; x++) + { + Marshal.WriteByte(p, x, 0xcc); + } +#endif + Marshal.StructureToPtr(m_Control, p, false); + Marshal.WriteIntPtr(p, iMixLineContSize - IntPtr.Size, new IntPtr(p.ToInt64() + iMixLineContSize)); + } + else + { + p = IntPtr.Zero; + } + + return p; + } + + // Called just after invoking the COM method. The IntPtr is the same one that just got returned + // from MarshalManagedToNative. The return value is unused. + public object MarshalNativeToManaged(IntPtr pNativeData) + { + m_Control.cbStruct = Marshal.ReadInt32(pNativeData); + m_Control.dwLineID = Marshal.ReadInt32(pNativeData, 4); + m_Control.dwControl = Marshal.ReadInt32(pNativeData, 8); + m_Control.cControls = Marshal.ReadInt32(pNativeData, 12); + m_Control.cbmxctrl = Marshal.ReadInt32(pNativeData, 16); + m_Control.pamxctrl = new MixerControl[m_Control.cControls]; + + IntPtr pData = new IntPtr(pNativeData.ToInt64() + iMixLineContSize); + + for (int x = 0; x < m_Control.cControls; x++) + { + m_Control.pamxctrl[x] = new MixerControl(); + IntPtr ip = new IntPtr(pData.ToInt64() + (x * iMixContSize)); + Marshal.PtrToStructure(ip, m_Control.pamxctrl[x]); + } + + m_Control = null; + + return m_Control; + } + + // It appears this routine is never called + public void CleanUpManagedData(object ManagedObj) + { + m_Control = null; + } + + public void CleanUpNativeData(IntPtr pNativeData) + { + Marshal.FreeCoTaskMem(pNativeData); + } + + // The number of bytes to marshal out + public int GetNativeDataSize() + { + return 0; + } + + // This method is called by interop to create the custom marshaler. The (optional) + // cookie is the value specified in MarshalCookie="asdf", or "" is none is specified. + public static ICustomMarshaler GetInstance(string cookie) + { + return new MLCMarshaler(); + } + } + + #endregion +} diff --git a/WindowsMediaLib/WMCore.cs b/WindowsMediaLib/WMCore.cs new file mode 100644 index 0000000..ecfbdbc --- /dev/null +++ b/WindowsMediaLib/WMCore.cs @@ -0,0 +1,6428 @@ +#region license + +/* +WindowsMediaLib - Provide access to Windows Media interfaces via .NET +Copyright (C) 2008 +http://sourceforge.net/projects/windowsmedianet + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#endregion + +using System; +using System.Text; +using System.Runtime.InteropServices; +using System.Runtime.InteropServices.ComTypes; +using System.Security; + +using WindowsMediaLib.Defs; + +namespace WindowsMediaLib +{ + /// + /// CLSID_ClientNetManager + /// + [ComImport, Guid("CD12A3CE-9C42-11D2-BEED-0060082F2054")] + public class ClientNetManager + { + } + + #region Declarations + +#if ALLOW_UNTESTED_INTERFACES + + [UnmanagedName("WMT_WATERMARK_ENTRY_TYPE")] + public enum WaterMarkEntryType + { + // Fields + Audio = 1, + Video = 2 + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("WMDRM_IMPORT_INIT_STRUCT")] + public class ImportInitStruct + { + public int dwVersion; + public int cbEncryptedSessionKeyMessage; + public IntPtr pbEncryptedSessionKeyMessage; + public int cbEncryptedKeyMessage; + public IntPtr pbEncryptedKeyMessage; + } + + [StructLayout(LayoutKind.Sequential, Pack = 4), UnmanagedName("DRM_MINIMUM_OUTPUT_PROTECTION_LEVELS")] + public struct MinimumOutputProtectionLevels + { + short wCompressedDigitalVideo; + short wUncompressedDigitalVideo; + short wAnalogVideo; + short wCompressedDigitalAudio; + short wUncompressedDigitalAudio; + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("DRM_OPL_OUTPUT_IDS")] + public struct OPLOutputIds + { + short cIds; + Guid [] rgIds; + } + + [StructLayout(LayoutKind.Sequential, Pack = 4), UnmanagedName("DRM_OUTPUT_PROTECTION")] + public struct VideoOutputProtection + { + Guid guidId; + byte bConfigData; + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("DRM_COPY_OPL")] + public struct CopyOPL + { + short wMinimumCopyLevel; + OPLOutputIds oplIdIncludes; + OPLOutputIds oplIdExcludes; + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("DRM_VIDEO_OUTPUT_PROTECTION_IDS")] + public struct VideoOutputProtectionIDs + { + short cEntries; + VideoOutputProtection [] rgVop; + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("DRM_PLAY_OPL")] + public struct PlayOpl + { + MinimumOutputProtectionLevels minOPL; + OPLOutputIds oplIdReserved; + VideoOutputProtectionIDs vopi; + } + + [StructLayout(LayoutKind.Sequential, Pack = 1), UnmanagedName("DRM_VAL16")] + public struct Val16 + { + [MarshalAs(UnmanagedType.ByValArray, SizeConst=16)] byte [] val; + } + + [StructLayout(LayoutKind.Sequential, Pack = 4), UnmanagedName("WMT_WATERMARK_ENTRY")] + public struct WaterMarkEntry + { + public WaterMarkEntryType wmetType; + public Guid clsid; + public int cbDisplayName; + [MarshalAs(UnmanagedType.LPWStr)] + public string pwszDisplayName; + } + +#endif + + [Flags] + public enum LicenseStateDataFlags + { + None = 0, + Vague = 1, + OPLPresent = 2, + SAPPresent = 4 + } + + [UnmanagedName("DRM_LICENSE_STATE_CATEGORY")] + public enum LicenseStateCategory + { + NoRight = 0, + UnLimited, + Count, + From, + Until, + FromUntil, + CountFrom, + CountUntil, + CountFromUntil, + ExpirationAfterFristUse + } + + [UnmanagedName("WMT_INDEX_TYPE")] + public enum IndexType + { + None = 0, + NearestDataUnit = 1, + NearestObject = 2, + NearestCleanPoint = 3 + } + + [UnmanagedName("WM_AETYPE")] + public enum AEType + { + Exclude = 0x65, + Include = 0x69 + } + + [UnmanagedName("WMT_ATTR_DATATYPE")] + public enum AttrDataType + { + DWORD = 0, + STRING = 1, + BINARY = 2, + BOOL = 3, + QWORD = 4, + WORD = 5, + GUID = 6 + } + + [Flags, UnmanagedName("From defines")] + public enum BackupRestoreFlags + { + None = 0, + OverWrite = 0x00000001, + Individualize = 0x00000002 + } + + [UnmanagedName("WMT_CODEC_INFO_TYPE")] + public enum CodecInfoType + { + Audio = 0, + Video = 1, + Unknown = 0xffffff + } + + [Flags] + public enum CredentialFlag + { + None = 0, + AutoSavePW = 1 + } + + [Flags, UnmanagedName("WMT_CREDENTIAL_FLAGS")] + public enum CredentialFlags + { + Save = 0x1, + DontCache = 0x2, + ClearText = 0x4, + Proxy = 0x8, + Encrypt = 0x10 + } + + [Flags, UnmanagedName("WMT_FILESINK_MODE")] + public enum FileSinkMode + { + None = 0, + SingleBuffers = 0x1, + FileSinkDataUnits = 0x2, + FileSinkUnbuffered = 0x4 + } + + [UnmanagedName("WMT_INDEXER_TYPE")] + public enum IndexerType + { + // Fields + FrameNumbers = 1, + PresentationTime = 0, + TimeCode = 2 + } + + [Flags] + public enum MetaDataAccess + { + None = 0, + Write = 0x40000000, + Read = unchecked((int)0x80000000) + } + + [Flags] + public enum MetaDataShare + { + None = 0, + Read = 0x00000001, + Delete = 0x00000004 + } + + [UnmanagedName("WMT_NET_PROTOCOL")] + public enum NetProtocol + { + HTTP = 0 + } + + [UnmanagedName("NETSOURCE_URLCREDPOLICY_SETTINGS")] + public enum NetSourceURLCredPolicySettings + { + AnonymousOnly = 2, + MustPromptUser = 1, + SilentLogonOk = 0 + } + + [UnmanagedName("WMT_OFFSET_FORMAT")] + public enum OffsetFormat + { + // Fields + HundredNS = 0, + FrameNumbers = 1, + PlaylistOffset = 2, + Timecode = 3 + } + + [UnmanagedName("WMT_PLAY_MODE")] + public enum PlayMode + { + // Fields + AutoSelect = 0, + Download = 2, + Local = 1, + Streaming = 3 + } + + [UnmanagedName("WMT_PROXY_SETTINGS")] + public enum ProxySettings + { + // Fields + Auto = 2, + Browser = 3, + Manual = 1, + Max = 4, + None = 0 + } + + [Flags, UnmanagedName("WMT_RIGHTS")] + public enum Rights + { + None = 0, + Playback = 0x00000001, + CopyToNonSDMIDevice = 0x00000002, + CopyToCD = 0x00000008, + CopyToSDMIDevice = 0x00000010, + OneTime = 0x00000020, + SaveStreamProtected = 0x00000040, + Copy = 0x00000080, + CollaborativePlay = 0x00000100, + SDMITrigger = 0x00010000, + SDMINoMoreCopies = 0x00020000 + } + + [Flags, UnmanagedName("From unnamed enum")] + public enum SampleFlag + { + None = 0, + CleanPoint = 0x1, + Discontinuity = 0x2, + Dataloss = 0x4 + } + + [Flags] + public enum SampleFlagEx + { + None = 0, + NotASyncPoint = 0x2, + Dataloss = 0x4 + } + + [UnmanagedName("WMT_STATUS")] + public enum Status + { + Error = 0, + Opened = 1, + BufferingStart = 2, + BufferingStop = 3, + EOF = 4, + EndOfFile = 4, + EndOfSegment = 5, + EndOfStreaming = 6, + Locating = 7, + Connecting = 8, + NoRights = 9, + MissingCodec = 10, + Started = 11, + Stopped = 12, + Closed = 13, + Striding = 14, + Timer = 15, + IndexProgress = 16, + SaveasStart = 17, + SaveasStop = 18, + NewSourceflags = 19, + NewMetadata = 20, + BackuprestoreBegin = 21, + SourceSwitch = 22, + AcquireLicense = 23, + Individualize = 24, + NeedsIndividualization = 25, + NoRightsEx = 26, + BackuprestoreEnd = 27, + BackuprestoreConnecting = 28, + BackuprestoreDisconnecting = 29, + ErrorWithurl = 30, + RestrictedLicense = 31, + ClientConnect = 32, + ClientDisconnect = 33, + NativeOutputPropsChanged = 34, + ReconnectStart = 35, + ReconnectEnd = 36, + ClientConnectEx = 37, + ClientDisconnectEx = 38, + SetFECSpan = 39, + PrerollReady = 40, + PrerollComplete = 41, + ClientProperties = 42, + LicenseURLSignatureState = 43, + InitPlaylistBurn = 44, + TranscryptorInit = 45, + TranscryptorSeeked = 46, + TranscryptorRead = 47, + TranscryptorClosed = 48, + ProximityResult = 49, + ProximityCompleted = 50, + ContentEnabler = 51 + } + + [UnmanagedName("WMT_STORAGE_FORMAT")] + public enum StorageFormat + { + // Fields + MP3 = 0, + V1 = 1 + } + + [UnmanagedName("WMT_STREAM_SELECTION")] + public enum StreamSelection + { + CleanPointOnly = 1, + Off = 0, + On = 2 + } + + [UnmanagedName("WMT_TRANSPORT_TYPE")] + public enum TransportType + { + // Fields + Reliable = 1, + Unreliable = 0 + } + + [UnmanagedName("WMT_VERSION")] + public enum WMVersion + { + V4_0 = 0x00040000, + V7_0 = 0x00070000, + V8_0 = 0x00080000, + V9_0 = 0x00090000 + } + + [StructLayout(LayoutKind.Sequential, Pack = 4), UnmanagedName("WMT_BUFFER_SEGMENT")] + public struct BufferSegment + { + public INSSBuffer pBuffer; + public int cbOffset; + public int cbLength; + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("WMT_FILESINK_DATA_UNIT")] + public class FileSinkDataUnit + { + public BufferSegment packetHeaderBuffer; + public int cPayloads; + public IntPtr pPayloadHeaderBuffers; + public int cPayloadDataFragments; + public IntPtr pPayloadDataFragments; + } + + [StructLayout(LayoutKind.Explicit, Pack = 1)] + public class RA3Union + { + [FieldOffset(0)] + public long lOffsetStart; + [FieldOffset(0)] + public int iOffsetStart; + + [FieldOffset(0)] + public short wRange; + [FieldOffset(2)] + public int Timecode; + [FieldOffset(6)] + public int dwUserbits; + [FieldOffset(10)] + public int dwAmFlags; + + public RA3Union() + { + } + + public RA3Union(long l) + { + lOffsetStart = l; + } + + public RA3Union(int i) + { + iOffsetStart = i; + } + + public RA3Union(TimeCodeExtensionData w) + { + wRange = w.wRange; + Timecode = w.dwTimecode; + dwUserbits = w.dwUserbits; + dwAmFlags = w.dwAmFlags; + } + + } + + [StructLayout(LayoutKind.Sequential, Pack = 2), UnmanagedName("WMT_TIMECODE_EXTENSION_DATA")] + public class TimeCodeExtensionData + { + public short wRange; + public int dwTimecode; + public int dwUserbits; + public int dwAmFlags; + } + + [StructLayout(LayoutKind.Sequential, Pack = 4), UnmanagedName("WM_ADDRESS_ACCESSENTRY")] + public struct WMAddressAccessEntry + { + public int dwIPAddress; + public int dwMask; + } + + [StructLayout(LayoutKind.Sequential, Pack = 4), UnmanagedName("WM_CLIENT_PROPERTIES")] + public struct WMClientProperties + { + public int dwIPAddress; + public int dwPort; + } + + [StructLayout(LayoutKind.Sequential, Pack = 2), UnmanagedName("WM_PORT_NUMBER_RANGE")] + public struct WMPortNumberRange + { + public short wPortBegin; + public short wPortEnd; + } + + [StructLayout(LayoutKind.Sequential, Pack = 8), UnmanagedName("WM_READER_CLIENTINFO")] + public class WMReaderClientInfo + { + public int cbSize; + public string wszLang; + public string wszBrowserUserAgent; + public string wszBrowserWebPage; + public long qwReserved; + public IntPtr pReserved; + public string wszHostExe; + public long qwHostVersion; + public string wszPlayerUserAgent; + } + + [StructLayout(LayoutKind.Sequential, Pack = 4), UnmanagedName("WM_READER_STATISTICS")] + public class WMReaderStatistics + { + public int cbSize; + public int dwBandwidth; + public int cPacketsReceived; + public int cPacketsRecovered; + public int cPacketsLost; + public short wQuality; + } + + [StructLayout(LayoutKind.Sequential, Pack = 2), UnmanagedName("WM_STREAM_PRIORITY_RECORD")] + public struct WMStreamPrioritizationRecord + { + public short wStreamNumber; + public bool fMandatory; + } + + [StructLayout(LayoutKind.Sequential, Pack = 4), UnmanagedName("WM_WRITER_STATISTICS_EX")] + public struct WMWriterStatisticsEx + { + public int dwBitratePlusOverhead; + public int dwCurrentSampleDropRateInQueue; + public int dwCurrentSampleDropRateInCodec; + public int dwCurrentSampleDropRateInMultiplexer; + public int dwTotalSampleDropsInQueue; + public int dwTotalSampleDropsInCodec; + public int dwTotalSampleDropsInMultiplexer; + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("WM_WRITER_STATISTICS")] + public struct WriterStatistics + { + public long qwSampleCount; + public long qwByteCount; + public long qwDroppedSampleCount; + public long qwDroppedByteCount; + public int dwCurrentBitrate; + public int dwAverageBitrate; + public int dwExpectedBitrate; + public int dwCurrentSampleRate; + public int dwAverageSampleRate; + public int dwExpectedSampleRate; + } + + [StructLayout(LayoutKind.Sequential), UnmanagedName("WM_LICENSE_STATE_DATA")] + public struct LicenseStateData + { + public LicenseStateData(byte[] b) + { + int LICENSESTATEDATASIZE = Marshal.SizeOf(typeof(DRMLicenseStateData)); + dwSize = BitConverter.ToInt32(b, 0); + dwNumStates = BitConverter.ToInt32(b, 4); + + stateData = new DRMLicenseStateData[dwNumStates]; + + for (int x = 0; x < dwNumStates; x++) + { + stateData[x] = new DRMLicenseStateData(b, (x * LICENSESTATEDATASIZE) + 8); + } + } + + public int dwSize; + public int dwNumStates; + public DRMLicenseStateData[] stateData; + } + + [StructLayout(LayoutKind.Sequential, Pack = 4), UnmanagedName("DRM_LICENSE_STATE_DATA")] + public struct DRMLicenseStateData + { + public DRMLicenseStateData(byte[] b, int iOffset) + { + dwStreamId = BitConverter.ToInt32(b, 0 + iOffset); + dwCategory = (LicenseStateCategory)BitConverter.ToInt32(b, 4 + iOffset); + dwNumCounts = BitConverter.ToInt32(b, 8 + iOffset); + + dwCount = new int[4]; + dwCount[0] = BitConverter.ToInt32(b, 12 + iOffset); + dwCount[1] = BitConverter.ToInt32(b, 16 + iOffset); + dwCount[2] = BitConverter.ToInt32(b, 20 + iOffset); + dwCount[3] = BitConverter.ToInt32(b, 24 + iOffset); + dwNumDates = BitConverter.ToInt32(b, 28 + iOffset); + + datetime = new long[4]; + datetime[0] = BitConverter.ToInt64(b, 32 + iOffset); + datetime[1] = BitConverter.ToInt64(b, 40 + iOffset); + datetime[2] = BitConverter.ToInt64(b, 48 + iOffset); + datetime[3] = BitConverter.ToInt64(b, 56 + iOffset); + + dwVague = (LicenseStateDataFlags)BitConverter.ToInt32(b, 64 + iOffset); + } + + public int dwStreamId; + public LicenseStateCategory dwCategory; + public int dwNumCounts; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public int[] dwCount; + public int dwNumDates; + [MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] + public long[] datetime; + public LicenseStateDataFlags dwVague; + } + + public static class MutexType + { + /// CLSID_WMMUTEX_Language + public static readonly Guid Language = new Guid(0xD6E22A00, 0x35DA, 0x11D1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE); + + /// CLSID_WMMUTEX_Bitrate + public static readonly Guid Bitrate = new Guid(0xD6E22A01, 0x35DA, 0x11D1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE); + + /// CLSID_WMMUTEX_Presentation + public static readonly Guid Presentation = new Guid(0xD6E22A02, 0x35DA, 0x11D1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE); + + /// CLSID_WMMUTEX_Unknown + public static readonly Guid Unknown = new Guid(0xD6E22A03, 0x35DA, 0x11D1, 0x90, 0x34, 0x00, 0xA0, 0xC9, 0x03, 0x49, 0xBE); + } + + public static class BandwidthSharingType + { + /// CLSID_WMBandwidthSharing_Exclusive + public static readonly Guid Exclusive = new Guid(0xaf6060aa, 0x5197, 0x11d2, 0xb6, 0xaf, 0x00, 0xc0, 0x4f, 0xd9, 0x08, 0xe9); + + /// CLSID_WMBandwidthSharing_Partial + public static readonly Guid Partial = new Guid(0xaf6060ab, 0x5197, 0x11d2, 0xb6, 0xaf, 0x00, 0xc0, 0x4f, 0xd9, 0x08, 0xe9); + } + + [UnmanagedName("WM_SampleExtensionGUID_*")] + public sealed class WM_SampleExtensionGUID + { + public static readonly Guid OutputCleanPoint = new Guid(0xf72a3c6f, 0x6eb4, 0x4ebc, 0xb1, 0x92, 0x9, 0xad, 0x97, 0x59, 0xe8, 0x28); + public static readonly Guid Timecode = new Guid(0x399595ec, 0x8667, 0x4e2d, 0x8f, 0xdb, 0x98, 0x81, 0x4c, 0xe7, 0x6c, 0x1e); + public static readonly Guid ChromaLocation = new Guid(0x4c5acca0, 0x9276, 0x4b2c, 0x9e, 0x4c, 0xa0, 0xed, 0xef, 0xdd, 0x21, 0x7e); + public static readonly Guid ColorSpaceInfo = new Guid(0xf79ada56, 0x30eb, 0x4f2b, 0x9f, 0x7a, 0xf2, 0x4b, 0x13, 0x9a, 0x11, 0x57); + public static readonly Guid UserDataInfo = new Guid(0x732bb4fa, 0x78be, 0x4549, 0x99, 0xbd, 0x2, 0xdb, 0x1a, 0x55, 0xb7, 0xa8); + public static readonly Guid FileName = new Guid(0xe165ec0e, 0x19ed, 0x45d7, 0xb4, 0xa7, 0x25, 0xcb, 0xd1, 0xe2, 0x8e, 0x9b); + public static readonly Guid ContentType = new Guid(0xd590dc20, 0x07bc, 0x436c, 0x9c, 0xf7, 0xf3, 0xbb, 0xfb, 0xf1, 0xa4, 0xdc); + public static readonly Guid PixelAspectRatio = new Guid(0x1b1ee554, 0xf9ea, 0x4bc8, 0x82, 0x1a, 0x37, 0x6b, 0x74, 0xe4, 0xc4, 0xb8); + public static readonly Guid SampleDuration = new Guid(0xc6bd9450, 0x867f, 0x4907, 0x83, 0xa3, 0xc7, 0x79, 0x21, 0xb7, 0x33, 0xad); + public static readonly Guid SampleProtectionSalt = new Guid(0x5403deee, 0xb9ee, 0x438f, 0xaa, 0x83, 0x38, 0x4, 0x99, 0x7e, 0x56, 0x9d); + } + + #endregion + + #region Interfaces + +#if ALLOW_UNTESTED_INTERFACES + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("F369E2F0-E081-4FE6-8450-B810B2F410D1"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderTimecode + { + void GetTimecodeRangeCount( + [In] short wStreamNum, + out short pwRangeCount + ); + + void GetTimecodeRangeBounds( + [In] short wStreamNum, + [In] short wRangeNum, + out int pStartTimecode, + out int pEndTimecode + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("f6211f03-8d21-4e94-93e6-8510805f2d99"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMDeviceRegistration + { + void RegisterDevice( + [In] int dwRegisterType, + [In] IntPtr pbCertificate, + int cbCertificate, + Val16 SerialNumber, + out IWMRegisteredDevice ppDevice); + + void UnregisterDevice( + [In] int dwRegisterType, + IntPtr pbCertificate, + [In] int cbCertificate, + Val16 SerialNumber); + + void GetRegistrationStats( + [In] int dwRegisterType, + out int pcRegisteredDevices); + + void GetFirstRegisteredDevice( + [In] int dwRegisterType, + out IWMRegisteredDevice ppDevice); + + void GetNextRegisteredDevice( + out IWMRegisteredDevice ppDevice); + + void GetRegisteredDeviceByID( + int dwRegisterType, + IntPtr pbCertificate, + int cbCertificate, + Val16 SerialNumber, + out IWMRegisteredDevice ppDevice); + + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("A73A0072-25A0-4c99-B4A5-EDE8101A6C39"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMDRMMessageParser + { + void ParseRegistrationReqMsg( + IntPtr pbRegistrationReqMsg, + int cbRegistrationReqMsg, + out INSSBuffer ppDeviceCert, + out Val16 pDeviceSerialNumber); + + void ParseLicenseRequestMsg( + IntPtr pbLicenseRequestMsg, + int cbLicenseRequestMsg, + out INSSBuffer ppDeviceCert, + out Val16 pDeviceSerialNumber, + [MarshalAs(UnmanagedType.BStr)] out string pbstrAction); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("D2827540-3EE7-432C-B14C-DC17F085D3B3"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMDRMReader + { + void AcquireLicense( + [In] int dwFlags + ); + + void CancelLicenseAcquisition(); + + void Individualize( + [In] int dwFlags + ); + + void CancelIndividualization(); + + void MonitorLicenseAcquisition(); + + void CancelMonitorLicenseAcquisition(); + + void SetDRMProperty( + [In] string pwstrName, + [In] AttrDataType dwType, + [In] byte[] pValue, + [In] short cbLength + ); + + void GetDRMProperty( + [In] string pwstrName, + out AttrDataType pdwType, + [Out] byte[] pValue, + ref short pcbLength + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("befe7a75-9f1d-4075-b9d9-a3c37bda49a0"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMDRMReader2 : IWMDRMReader + { + #region IWMDRMReader Methods + + new void AcquireLicense( + [In] int dwFlags + ); + + new void CancelLicenseAcquisition(); + + new void Individualize( + [In] int dwFlags + ); + + new void CancelIndividualization(); + + new void MonitorLicenseAcquisition(); + + new void CancelMonitorLicenseAcquisition(); + + new void SetDRMProperty( + [In] string pwstrName, + [In] AttrDataType dwType, + [In] byte[] pValue, + [In] short cbLength + ); + + new void GetDRMProperty( + [In] string pwstrName, + out AttrDataType pdwType, + [Out] byte[] pValue, + ref short pcbLength + ); + + #endregion + + void SetEvaluateOutputLevelLicenses( + [MarshalAs(UnmanagedType.Bool)] bool fEvaluate); + + void GetPlayOutputLevels( + out PlayOpl pPlayOPL, + out int pcbLength, + out int pdwMinAppComplianceLevel); + + void GetCopyOutputLevels( + out CopyOPL pCopyOPL, + ref int pcbLength, + out int pdwMinAppComplianceLevel); + + void TryNextLicense(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("e08672de-f1e7-4ff4-a0a3-fc4b08e4caf8"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMDRMReader3 : IWMDRMReader2 + { + #region IWMDRMReader Methods + + new void AcquireLicense( + [In] int dwFlags + ); + + new void CancelLicenseAcquisition(); + + new void Individualize( + [In] int dwFlags + ); + + new void CancelIndividualization(); + + new void MonitorLicenseAcquisition(); + + new void CancelMonitorLicenseAcquisition(); + + new void SetDRMProperty( + [In] string pwstrName, + [In] AttrDataType dwType, + [In] byte[] pValue, + [In] short cbLength + ); + + new void GetDRMProperty( + [In] string pwstrName, + out AttrDataType pdwType, + [Out] byte[] pValue, + ref short pcbLength + ); + + #endregion + + #region IWMDRMReader2 Methods + + new void SetEvaluateOutputLevelLicenses( + [MarshalAs(UnmanagedType.Bool)] bool fEvaluate); + + new void GetPlayOutputLevels( + out PlayOpl pPlayOPL, + out int pcbLength, + out int pdwMinAppComplianceLevel); + + new void GetCopyOutputLevels( + out CopyOPL pCopyOPL, + ref int pcbLength, + out int pdwMinAppComplianceLevel); + + new void TryNextLicense(); + + #endregion + + void GetInclusionList( + [MarshalAs(UnmanagedType.LPStruct)] out Guid ppGuids, + out int pcGuids); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("b1a887b2-a4f0-407a-b02e-efbd23bbecdf"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMDRMTranscryptionManager + { + void CreateTranscryptor( + out IWMDRMTranscryptor ppTranscryptor); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("69059850-6E6F-4bb2-806F-71863DDFC471"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMDRMTranscryptor + { + void Initialize( + [MarshalAs(UnmanagedType.BStr)] string bstrFileName, + [MarshalAs(UnmanagedType.BStr)] string pbLicenseRequestMsg, + int cbLicenseRequestMsg, + out INSSBuffer ppLicenseResponseMsg, + IWMStatusCallback pCallback, + IntPtr pvContext); + + void Seek( + long hnsTime); + + void Read( + IntPtr pbData, + ref int pcbData); + + void Close(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("e0da439f-d331-496a-bece-18e5bac5dd23"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMDRMTranscryptor2 : IWMDRMTranscryptor + { + #region IWMDRMTranscryptor Methods + + new void Initialize( + [MarshalAs(UnmanagedType.BStr)] string bstrFileName, + [MarshalAs(UnmanagedType.BStr)] string pbLicenseRequestMsg, + int cbLicenseRequestMsg, + out INSSBuffer ppLicenseResponseMsg, + IWMStatusCallback pCallback, + IntPtr pvContext); + + new void Seek( + long hnsTime); + + new void Read( + IntPtr pbData, + ref int pcbData); + + new void Close(); + + #endregion + + void SeekEx( + long cnsStartTime, + long cnsDuration, + float flRate, + [MarshalAs(UnmanagedType.Bool)] bool fIncludeFileHeader); + + void ZeroAdjustTimestamps( + [MarshalAs(UnmanagedType.Bool)] bool fEnable); + + void GetSeekStartTime( + out long pcnsTime); + + void GetDuration( + out long pcnsDuration); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("D6EA5DD0-12A0-43F4-90AB-A3FD451E6A07"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMDRMWriter + { + void GenerateKeySeed( + [Out] StringBuilder pwszKeySeed, + ref int pcwchLength + ); + + void GenerateKeyID( + [Out] StringBuilder pwszKeyID, + ref int pcwchLength + ); + + void GenerateSigningKeyPair( + [Out] StringBuilder pwszPrivKey, + ref int pcwchPrivKeyLength, + [Out] StringBuilder pwszPubKey, + ref int pcwchPubKeyLength + ); + + void SetDRMAttribute( + [In] short wStreamNum, + [In] string pszName, + [In] AttrDataType Type, + [In] byte[] pValue, + [In] short cbLength + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("38ee7a94-40e2-4e10-aa3f-33fd3210ed5b"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMDRMWriter2 : IWMDRMWriter + { + #region IWMDRMWriter Methods + + new void GenerateKeySeed( + [Out] StringBuilder pwszKeySeed, + ref int pcwchLength + ); + + new void GenerateKeyID( + [Out] StringBuilder pwszKeyID, + ref int pcwchLength + ); + + new void GenerateSigningKeyPair( + [Out] StringBuilder pwszPrivKey, + ref int pcwchPrivKeyLength, + [Out] StringBuilder pwszPubKey, + ref int pcwchPubKeyLength + ); + + new void SetDRMAttribute( + [In] short wStreamNum, + [In] string pszName, + [In] AttrDataType Type, + [In] byte[] pValue, + [In] short cbLength + ); + + #endregion + + void SetWMDRMNetEncryption( + [MarshalAs(UnmanagedType.Bool)] bool fSamplesEncrypted, + IntPtr pbKeyID, + int cbKeyID); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("a7184082-a4aa-4dde-ac9c-e75dbd1117ce"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMDRMWriter3 : IWMDRMWriter2 + { + #region IWMDRMWriter Methods + + new void GenerateKeySeed( + [Out] StringBuilder pwszKeySeed, + ref int pcwchLength + ); + + new void GenerateKeyID( + [Out] StringBuilder pwszKeyID, + ref int pcwchLength + ); + + new void GenerateSigningKeyPair( + [Out] StringBuilder pwszPrivKey, + ref int pcwchPrivKeyLength, + [Out] StringBuilder pwszPubKey, + ref int pcwchPubKeyLength + ); + + new void SetDRMAttribute( + [In] short wStreamNum, + [In] string pszName, + [In] AttrDataType Type, + [In] byte[] pValue, + [In] short cbLength + ); + + #endregion + + #region IWMDRMWriter2 Methods + + new void SetWMDRMNetEncryption( + [MarshalAs(UnmanagedType.Bool)] bool fSamplesEncrypted, + IntPtr pbKeyID, + int cbKeyID); + + #endregion + + void SetProtectStreamSamples( + [In, MarshalAs(UnmanagedType.LPStruct)] ImportInitStruct pImportInitStruct); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("6967F2C9-4E26-4b57-8894-799880F7AC7B"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMLicenseRevocationAgent + { + void GetLRBChallenge( + IntPtr pMachineID, + int dwMachineIDLength, + IntPtr pChallenge, + int dwChallengeLength, + IntPtr pChallengeOutput, + out int pdwChallengeOutputLength); + + void ProcessLRB( + IntPtr pSignedLRB, + int dwSignedLRBLength, + IntPtr pSignedACK, + out int pdwSignedACKLength); + }; + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("6A9FD8EE-B651-4bf0-B849-7D4ECE79A2B1"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMProximityDetection + { + void StartDetection( + IntPtr pbRegistrationMsg, + int cbRegistrationMsg, + IntPtr pbLocalAddress, + int cbLocalAddress, + int dwExtraPortsAllowed, + out INSSBuffer ppRegistrationResponseMsg, + IWMStatusCallback pCallback, + IntPtr pvContext); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("18A2E7F8-428F-4acd-8A00-E64639BC93DE"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderAdvanced6 : IWMReaderAdvanced5 + { + #region IWMReaderAdvanced Methods + + new void SetUserProvidedClock( + [In, MarshalAs(UnmanagedType.Bool)] bool fUserClock + ); + + new void GetUserProvidedClock( + [MarshalAs(UnmanagedType.Bool)] out bool pfUserClock + ); + + new void DeliverTime( + [In] long cnsTime + ); + + new void SetManualStreamSelection( + [In, MarshalAs(UnmanagedType.Bool)] bool fSelection + ); + + new void GetManualStreamSelection( + [MarshalAs(UnmanagedType.Bool)] out bool pfSelection + ); + + new void SetStreamsSelected( + [In] short cStreamCount, + [In] short[] pwStreamNumbers, + [In] StreamSelection[] pSelections + ); + + new void GetStreamSelected( + [In] short wStreamNum, + out StreamSelection pSelection + ); + + new void SetReceiveSelectionCallbacks( + [In, MarshalAs(UnmanagedType.Bool)] bool fGetCallbacks + ); + + new void GetReceiveSelectionCallbacks( + [MarshalAs(UnmanagedType.Bool)] out bool pfGetCallbacks + ); + + new void SetReceiveStreamSamples( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fReceiveStreamSamples + ); + + new void GetReceiveStreamSamples( + [In] short wStreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfReceiveStreamSamples + ); + + new void SetAllocateForOutput( + [In] int dwOutputNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + new void GetAllocateForOutput( + [In] int dwOutputNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + + new void SetAllocateForStream( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + new void GetAllocateForStream( + [In] short dwSreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + + new void GetStatistics( + [In, Out, MarshalAs(UnmanagedType.LPStruct)] WMReaderStatistics pStatistics + ); + + new void SetClientInfo( + [In, MarshalAs(UnmanagedType.LPStruct)] WMReaderClientInfo pClientInfo + ); + + new void GetMaxOutputSampleSize( + [In] int dwOutput, + out int pcbMax + ); + + new void GetMaxStreamSampleSize( + [In] short wStream, + out int pcbMax + ); + + new void NotifyLateDelivery( + long cnsLateness + ); + + #endregion + + #region IWMReaderAdvanced2 Methods + + new void SetPlayMode( + [In] PlayMode Mode + ); + + new void GetPlayMode( + out PlayMode pMode + ); + + new void GetBufferProgress( + out int pdwPercent, + out long pcnsBuffering + ); + + new void GetDownloadProgress( + out int pdwPercent, + out long pqwBytesDownloaded, + out long pcnsDownload + ); + + new void GetSaveAsProgress( + out int pdwPercent + ); + + new void SaveFileAs( + [In] string pwszFilename + ); + + new void GetProtocolName( + [Out] StringBuilder pwszProtocol, + ref int pcchProtocol + ); + + new void StartAtMarker( + [In] short wMarkerIndex, + [In] long cnsDuration, + [In] float fRate, + [In] IntPtr pvContext + ); + + new void GetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + new void SetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + [In] AttrDataType Type, + [In] byte[] pValue, + [In] short cbLength + ); + + new void Preroll( + [In] long cnsStart, + [In] long cnsDuration, + [In] float fRate + ); + + new void SetLogClientID( + [In, MarshalAs(UnmanagedType.Bool)] bool fLogClientID + ); + + new void GetLogClientID( + [MarshalAs(UnmanagedType.Bool)] out bool pfLogClientID + ); + + new void StopBuffering(); + + new void OpenStream( + [In] IStream pStream, + [In] IWMReaderCallback pCallback, + [In] IntPtr pvContext + ); + + #endregion + + #region IWMReaderAdvanced3 Methods + + new void StopNetStreaming(); + + new void StartAtPosition( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.LPStruct)] RA3Union pvOffsetStart, + [In, MarshalAs(UnmanagedType.LPStruct)] RA3Union pvDuration, + [In] OffsetFormat dwOffsetFormat, + [In] float fRate, + [In] IntPtr pvContext + ); + + #endregion + + #region IWMReaderAdvanced4 Methods + + new void GetLanguageCount( + [In] int dwOutputNum, + out short pwLanguageCount + ); + + new void GetLanguage( + [In] int dwOutputNum, + [In] short wLanguage, + [Out] StringBuilder pwszLanguageString, + ref short pcchLanguageStringLength + ); + + new void GetMaxSpeedFactor( + out double pdblFactor + ); + + new void IsUsingFastCache( + [MarshalAs(UnmanagedType.Bool)] out bool pfUsingFastCache + ); + + new void AddLogParam( + [In] string wszNameSpace, + [In] string wszName, + [In] string wszValue + ); + + new void SendLogParams(); + + new void CanSaveFileAs( + [MarshalAs(UnmanagedType.Bool)] out bool pfCanSave + ); + + new void CancelSaveFileAs(); + + new void GetURL( + [Out] StringBuilder pwszURL, + ref int pcchURL + ); + + #endregion + + #region IWMReaderAdvanced5 Methods + + new void SetPlayerHook( + int dwOutputNum, + IWMPlayerHook pHook); + + #endregion + + void SetProtectStreamSamples( + IntPtr pbCertificate, + int cbCertificate, + int dwCertificateType, + int dwFlags, + IntPtr pbInitializationVector, + out int pcbInitializationVector); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("a4503bec-5508-4148-97ac-bfa75760a70d"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMRegisteredDevice + { + void GetDeviceSerialNumber( + out Val16 pSerialNumber); + + void GetDeviceCertificate( + out INSSBuffer ppCertificate); + + void GetDeviceType( + out int pdwType); + + void GetAttributeCount( + out int pcAttributes); + + void GetAttributeByIndex( + int dwIndex, + [MarshalAs(UnmanagedType.BStr)] out string pbstrName, + [MarshalAs(UnmanagedType.BStr)] out string pbstrValue); + + void GetAttributeByName( + [MarshalAs(UnmanagedType.BStr)] string bstrName, + [MarshalAs(UnmanagedType.BStr)] out string pbstrValue); + + void SetAttributeByName( + [MarshalAs(UnmanagedType.BStr)] string bstrName, + [MarshalAs(UnmanagedType.BStr)] string bstrValue); + + void Approve( + [MarshalAs(UnmanagedType.Bool)] bool fApprove); + + void IsValid( + [MarshalAs(UnmanagedType.Bool)] out bool pfValid); + + void IsApproved( + [MarshalAs(UnmanagedType.Bool)] out bool pfApproved); + + void IsWmdrmCompliant( + [MarshalAs(UnmanagedType.Bool)] out bool pfCompliant); + + void IsOpened( + [MarshalAs(UnmanagedType.Bool)] out bool pfOpened); + + void Open(); + + void Close(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("990641B0-739F-4E94-A808-9888DA8F75AF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMCodecVideoAccelerator + { + void NegotiateConnection( + [In, MarshalAs(UnmanagedType.Interface)] object pIAMVA, + [In, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pMediaType + ); + + void SetPlayerNotify( + [In] IWMPlayerTimestampHook pHook + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("9F0AA3B6-7267-4D89-88F2-BA915AA5C4C6"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMImageInfo + { + void GetImageCount( + out int pcImages + ); + + void GetImage( + [In] int wIndex, + ref short pcchMIMEType, + [Out] StringBuilder pwszMIMEType, + ref short pcchDescription, + [Out] StringBuilder pwszDescription, + out short pImageType, + ref int pcbImageData, + out byte[] pbImageData + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("6F497062-F2E2-4624-8EA7-9DD40D81FC8D"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWatermarkInfo + { + void GetWatermarkEntryCount( + [In] WaterMarkEntryType wmetType, + out int pdwCount + ); + + void GetWatermarkEntry( + [In] WaterMarkEntryType wmetType, + [In] int dwEntryNum, + out WaterMarkEntry pEntry + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("61103CA4-2033-11D2-9EF1-006097D2D7CF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMSBufferAllocator + { + void AllocateBuffer( + [In] int dwMaxBufferSize, + out INSSBuffer ppBuffer + ); + + void AllocatePageSizeBuffer( + [In] int dwMaxBufferSize, + out INSSBuffer ppBuffer + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("D98EE251-34E0-4A2D-9312-9B4C788D9FA1"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMCodecAMVideoAccelerator + { + void SetAcceleratorInterface( + [In, MarshalAs(UnmanagedType.Interface)] object pIAMVA + ); + + void NegotiateConnection( + [In, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pMediaType + ); + + void SetPlayerNotify( + [In] IWMPlayerTimestampHook pHook + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("28580DDA-D98E-48D0-B7AE-69E473A02825"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMPlayerTimestampHook + { + void MapTimestamp( + [In] long rtIn, out long prtOut + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("BDDC4D08-944D-4D52-A612-46C3FDA07DD4"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderAccelerator + { + void GetCodecInterface( + [In] int dwOutputNum, + [In, MarshalAs(UnmanagedType.LPStruct)] Guid riid, + out IntPtr ppvCodecInterface + ); + + void Notify( + [In] int dwOutputNum, + [In, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pSubtype + ); + } + +#endif + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("45086030-F7E4-486a-B504-826BB5792A3B"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IConfigAsfWriter + { + void ConfigureFilterUsingProfileId( + [In] int dwProfileId); + + void GetCurrentProfileId( + [Out] out int pdwProfileId); + + void ConfigureFilterUsingProfileGuid( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidProfile); + + void GetCurrentProfileGuid( + [Out] out Guid pProfileGuid); + + void ConfigureFilterUsingProfile( + [In] IWMProfile pProfile); + + void GetCurrentProfileGuid( + [Out] out IWMProfile ppProfile); + + void SetIndexMode( + [In, MarshalAs(UnmanagedType.Bool)] bool bIndexFile); + + void GetIndexMode( + [Out, MarshalAs(UnmanagedType.Bool)] out bool pbIndexFile); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("E1CD3524-03D7-11D2-9EED-006097D2D7CF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface INSSBuffer + { + void GetLength( + out int pdwLength + ); + + void SetLength( + [In] int dwLength + ); + + void GetMaxLength( + out int pdwLength + ); + + void GetBuffer( + out IntPtr ppdwBuffer + ); + + void GetBufferAndLength( + out IntPtr ppdwBuffer, + out int pdwLength + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("BB3C6389-1633-4E92-AF14-9F3173BA39D0"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMAddressAccess + { + void GetAccessEntryCount( + [In] AEType aeType, + out int pcEntries + ); + + void GetAccessEntry( + [In] AEType aeType, + [In] int dwEntryNum, + out WMAddressAccessEntry pAddrAccessEntry + ); + + void AddAccessEntry( + [In] AEType aeType, + [In] ref WMAddressAccessEntry pAddrAccessEntry + ); + + void RemoveAccessEntry( + [In] AEType aeType, + [In] int dwEntryNum + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("65A83FC2-3E98-4D4D-81B5-2A742886B33D"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMAddressAccess2 : IWMAddressAccess + { + #region IWMAddressAccess Methods + + new void GetAccessEntryCount( + [In] AEType aeType, + out int pcEntries + ); + + new void GetAccessEntry( + [In] AEType aeType, + [In] int dwEntryNum, + out WMAddressAccessEntry pAddrAccessEntry + ); + + new void AddAccessEntry( + [In] AEType aeType, + [In] ref WMAddressAccessEntry pAddrAccessEntry + ); + + new void RemoveAccessEntry( + [In] AEType aeType, + [In] int dwEntryNum + ); + + #endregion + + void GetAccessEntryEx( + [In] AEType aeType, + [In] int dwEntryNum, + [MarshalAs(UnmanagedType.BStr)] out string pbstrAddress, + [MarshalAs(UnmanagedType.BStr)] out string pbstrMask + ); + + void AddAccessEntryEx( + [In] AEType aeType, + [In, MarshalAs(UnmanagedType.BStr)] string bstrAddress, + [In, MarshalAs(UnmanagedType.BStr)] string bstrMask + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("3C8E0DA6-996F-4FF3-A1AF-4838F9377E2E"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMBackupRestoreProps + { + void GetPropCount( + out short pcProps + ); + + void GetPropByIndex( + [In] short wIndex, + [Out] string pwszName, + ref short pcchNameLen, + out AttrDataType pType, + out byte[] pValue, + ref short pcbLength + ); + + void GetPropByName( + [In] string pszName, + out AttrDataType pType, + out byte[] pValue, + ref short pcbLength + ); + + void SetProp( + [In] string pszName, + [In] AttrDataType Type, + [In, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + [In] short cbLength + ); + + void RemoveProp( + [In] string pcwszName + ); + + void RemoveAllProps(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("AD694AF1-F8D9-42F8-BC47-70311B0C4F9E"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMBandwidthSharing : IWMStreamList + { + #region IWMStreamList Methods + + new void GetStreams( + [Out, MarshalAs(UnmanagedType.LPArray)] short[] pwStreamNumArray, + ref short pcStreams + ); + + new void AddStream( + [In] short wStreamNum + ); + + new void RemoveStream( + [In] short wStreamNum + ); + + #endregion + + void GetType( + out Guid pguidType + ); + + void SetType( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType + ); + + void GetBandwidth( + out int pdwBitrate, + out int pmsBufferWindow + ); + + void SetBandwidth( + [In] int dwBitrate, + [In] int msBufferWindow + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("73C66010-A299-41DF-B1F0-CCF03B09C1C6"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMClientConnections + { + void GetClientCount( + out int pcClients + ); + + void GetClientProperties( + [In] int dwClientNum, + out WMClientProperties pClientProperties + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("4091571E-4701-4593-BB3D-D5F5F0C74246"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMClientConnections2 : IWMClientConnections + { + #region IWMClientConnections Methods + + new void GetClientCount( + out int pcClients + ); + + new void GetClientProperties( + [In] int dwClientNum, + out WMClientProperties pClientProperties + ); + + #endregion + + void GetClientInfo( + [In] int dwClientNum, + [Out] StringBuilder pwszNetworkAddress, + ref int pcchNetworkAddress, + [Out] StringBuilder pwszPort, + ref int pcchPort, + [Out] StringBuilder pwszDNSName, + ref int pcchDNSName + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("A970F41E-34DE-4A98-B3BA-E4B3CA7528F0"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMCodecInfo + { + void GetCodecInfoCount( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + out int pcCodecs + ); + + void GetCodecFormatCount( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + out int pcFormat + ); + + void GetCodecFormat( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + [In] int dwFormatIndex, + out IWMStreamConfig ppIStreamConfig + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("AA65E273-B686-4056-91EC-DD768D4DF710"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMCodecInfo2 : IWMCodecInfo + { + #region IWMCodecInfo Methods + + new void GetCodecInfoCount( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + out int pcCodecs + ); + + new void GetCodecFormatCount( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + out int pcFormat + ); + + new void GetCodecFormat( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + [In] int dwFormatIndex, + out IWMStreamConfig ppIStreamConfig + ); + + #endregion + + void GetCodecName( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + [Out] StringBuilder wszName, + ref int pcchName + ); + + void GetCodecFormatDesc( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + [In] int dwFormatIndex, + out IWMStreamConfig ppIStreamConfig, + [Out] StringBuilder wszDesc, + ref int pcchDesc + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("7E51F487-4D93-4F98-8AB4-27D0565ADC51"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMCodecInfo3 : IWMCodecInfo2 + { + #region IWMCodecInfo Methods + + new void GetCodecInfoCount( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + out int pcCodecs + ); + + new void GetCodecFormatCount( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + out int pcFormat + ); + + new void GetCodecFormat( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + [In] int dwFormatIndex, + out IWMStreamConfig ppIStreamConfig + ); + + #endregion + + #region IWMCodecInfo2 Methods + + new void GetCodecName( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + [Out] StringBuilder wszName, + ref int pcchName + ); + + new void GetCodecFormatDesc( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + [In] int dwFormatIndex, + out IWMStreamConfig ppIStreamConfig, + [Out] StringBuilder wszDesc, + ref int pcchDesc + ); + + #endregion + + void GetCodecFormatProp( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + [In] int dwFormatIndex, + [In, MarshalAs(UnmanagedType.LPWStr)] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref int pdwSize + ); + + void GetCodecProp( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + [In, MarshalAs(UnmanagedType.LPWStr)] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref int pdwSize + ); + + void SetCodecEnumerationSetting( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + [In, MarshalAs(UnmanagedType.LPWStr)] string pszName, + [In] AttrDataType Type, + [In, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + [In] int dwSize + ); + + void GetCodecEnumerationSetting( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType, + [In] int dwCodecIndex, + [In, MarshalAs(UnmanagedType.LPWStr)] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref int pdwSize + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("342E0EB7-E651-450C-975B-2ACE2C90C48E"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMCredentialCallback + { + void AcquireCredentials( + [In, MarshalAs(UnmanagedType.LPWStr)] string pwszRealm, + [In, MarshalAs(UnmanagedType.LPWStr)] string pwszSite, + [In, Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=3)] char[] pwszUser, + [In] int cchUser, + [In, Out, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=5)] char[] pwszPassword, + [In] int cchPassword, + [In] int hrStatus, + ref CredentialFlags pdwFlags + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("FF130EBC-A6C3-42A6-B401-C3382C3E08B3"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMDRMEditor + { + void GetDRMProperty( + [In] string pwstrName, + out AttrDataType pdwType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BDA-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMHeaderInfo + { + void GetAttributeCount( + [In] short wStreamNum, + out short pcAttributes + ); + + void GetAttributeByIndex( + [In] short wIndex, + [In] ref short pwStreamNum, + [Out] StringBuilder pwszName, + ref short pcchNameLen, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + void GetAttributeByName( + [In] ref short pwStreamNum, + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + void SetAttribute( + [In] short wStreamNum, + [In] string pszName, + [In] AttrDataType Type, + [In, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + [In] short cbLength + ); + + void GetMarkerCount( + out short pcMarkers + ); + + void GetMarker( + [In] short wIndex, + [Out] StringBuilder pwszMarkerName, + ref short pcchMarkerNameLen, + out long pcnsMarkerTime + ); + + void AddMarker( + [In] string pwszMarkerName, + [In] long cnsMarkerTime + ); + + void RemoveMarker( + [In] short wIndex + ); + + void GetScriptCount( + out short pcScripts + ); + + void GetScript( + [In] short wIndex, + [Out] StringBuilder pwszType, + ref short pcchTypeLen, + [Out] StringBuilder pwszCommand, + ref short pcchCommandLen, + out long pcnsScriptTime + ); + + void AddScript( + [In] string pwszType, + [In] string pwszCommand, + [In] long cnsScriptTime + ); + + void RemoveScript( + [In] short wIndex + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("15CF9781-454E-482E-B393-85FAE487A810"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMHeaderInfo2 : IWMHeaderInfo + { + #region IWMHeaderInfo Methods + + new void GetAttributeCount( + [In] short wStreamNum, + out short pcAttributes + ); + + new void GetAttributeByIndex( + [In] short wIndex, + ref short pwStreamNum, + [Out] StringBuilder pwszName, + ref short pcchNameLen, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + new void GetAttributeByName( + ref short pwStreamNum, + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + new void SetAttribute( + [In] short wStreamNum, + [In] string pszName, + [In] AttrDataType Type, + [In, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + [In] short cbLength + ); + + new void GetMarkerCount( + out short pcMarkers + ); + + new void GetMarker( + [In] short wIndex, + [Out] StringBuilder pwszMarkerName, + ref short pcchMarkerNameLen, + out long pcnsMarkerTime + ); + + new void AddMarker( + [In] string pwszMarkerName, + [In] long cnsMarkerTime + ); + + new void RemoveMarker( + [In] short wIndex + ); + + new void GetScriptCount( + out short pcScripts + ); + + new void GetScript( + [In] short wIndex, + [Out] StringBuilder pwszType, + ref short pcchTypeLen, + [Out] StringBuilder pwszCommand, + ref short pcchCommandLen, + out long pcnsScriptTime + ); + + new void AddScript( + [In] string pwszType, + [In] string pwszCommand, + [In] long cnsScriptTime + ); + + new void RemoveScript( + [In] short wIndex + ); + + #endregion + + void GetCodecInfoCount( + out int pcCodecInfos + ); + + void GetCodecInfo( + [In] int wIndex, + ref short pcchName, + [Out] StringBuilder pwszName, + ref short pcchDescription, + [Out] StringBuilder pwszDescription, + out CodecInfoType pCodecType, + ref short pcbCodecInfo, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pbCodecInfo + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("15CC68E3-27CC-4ECD-B222-3F5D02D80BD5"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMHeaderInfo3 : IWMHeaderInfo2 + { + #region IWMHeaderInfo Methods + + new void GetAttributeCount( + [In] short wStreamNum, + out short pcAttributes + ); + + new void GetAttributeByIndex( + [In] short wIndex, + ref short pwStreamNum, + [Out] StringBuilder pwszName, + ref short pcchNameLen, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + new void GetAttributeByName( + ref short pwStreamNum, + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + new void SetAttribute( + [In] short wStreamNum, + [In] string pszName, + [In] AttrDataType Type, + [In, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + [In] short cbLength + ); + + new void GetMarkerCount( + out short pcMarkers + ); + + new void GetMarker( + [In] short wIndex, + [Out] StringBuilder pwszMarkerName, + ref short pcchMarkerNameLen, + out long pcnsMarkerTime + ); + + new void AddMarker( + [In] string pwszMarkerName, + [In] long cnsMarkerTime + ); + + new void RemoveMarker( + [In] short wIndex + ); + + new void GetScriptCount( + out short pcScripts + ); + + new void GetScript( + [In] short wIndex, + [Out] StringBuilder pwszType, + ref short pcchTypeLen, + [Out] StringBuilder pwszCommand, + ref short pcchCommandLen, + out long pcnsScriptTime + ); + + new void AddScript( + [In] string pwszType, + [In] string pwszCommand, + [In] long cnsScriptTime + ); + + new void RemoveScript( + [In] short wIndex + ); + + #endregion + + #region IWMHeaderInfo2 Methods + + new void GetCodecInfoCount( + out int pcCodecInfos + ); + + new void GetCodecInfo( + [In] int wIndex, + ref short pcchName, + [Out] StringBuilder pwszName, + ref short pcchDescription, + [Out] StringBuilder pwszDescription, + out CodecInfoType pCodecType, + ref short pcbCodecInfo, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pbCodecInfo + ); + + #endregion + + void GetAttributeCountEx( + [In] short wStreamNum, + out short pcAttributes + ); + + void GetAttributeIndices( + [In] short wStreamNum, + [In] string pwszName, + [In] WmShort pwLangIndex, + [Out, MarshalAs(UnmanagedType.LPArray)] short[] pwIndices, + ref short pwCount + ); + + void GetAttributeByIndexEx( + [In] short wStreamNum, + [In] short wIndex, + [Out] StringBuilder pwszName, + ref short pwNameLen, + out AttrDataType pType, + out short pwLangIndex, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref int pdwDataLength + ); + + void ModifyAttribute( + [In] short wStreamNum, + [In] short wIndex, + [In] AttrDataType Type, + [In] short wLangIndex, + [In, MarshalAs(UnmanagedType.LPArray)] byte [] pValue, + [In] int dwLength + ); + + void AddAttribute( + [In] short wStreamNum, + [In] string pszName, + out short pwIndex, + [In] AttrDataType Type, + [In] short wLangIndex, + [In, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + [In] int dwLength + ); + + void DeleteAttribute( + [In] short wStreamNum, + [In] short wIndex + ); + + void AddCodecInfo( + [In] string pwszName, + [In] string pwszDescription, + [In] CodecInfoType codecType, + [In] short cbCodecInfo, + [In, MarshalAs(UnmanagedType.LPArray)] byte[] pbCodecInfo + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("6D7CDC71-9888-11D3-8EDC-00C04F6109CF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMIndexer + { + void StartIndexing( + [In] string pwszURL, + [In] IWMStatusCallback pCallback, + [In] IntPtr pvContext + ); + + void Cancel(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("B70F1E42-6255-4DF0-A6B9-02B212D9E2BB"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMIndexer2 : IWMIndexer + { + #region IWMIndexer Methods + + new void StartIndexing( + [In] string pwszURL, + [In] IWMStatusCallback pCallback, + [In] IntPtr pvContext + ); + + new void Cancel(); + + #endregion + + void Configure( + [In] short wStreamNum, + [In] IndexerType nIndexerType, + [In] WmInt pvInterval, + [In] WmShort pvIndexType + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BD5-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMInputMediaProps : IWMMediaProps + { + #region IWMMediaProps Methods + + new void GetType( + out Guid pguidType + ); + + new void GetMediaType( + [In, Out, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(MTMarshaler))] AMMediaType pType, + ref int pcbType + ); + + new void SetMediaType( + [In, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pType + ); + + #endregion + + void GetConnectionName( + [Out] StringBuilder pwszName, + ref short pcchName + ); + + void GetGroupName( + [Out] StringBuilder pwszName, + ref short pcchName + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("6816DAD3-2B4B-4C8E-8149-874C3483A753"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMIStreamProps + { + void GetProperty( + [In] StringBuilder pszName, + out AttrDataType pType, + IntPtr pValue, + ref int pdwSize + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("DF683F00-2D49-4D8E-92B7-FB19F6A0DC57"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMLanguageList + { + void GetLanguageCount( + out short pwCount + ); + + void GetLanguageDetails( + [In] short wIndex, + [Out] StringBuilder pwszLanguageString, + ref short pcchLanguageStringLength + ); + + void AddLanguageByRFC1766String( + [In] string pwszLanguageString, + out short pwIndex + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("05E5AC9F-3FB6-4508-BB43-A4067BA1EBE8"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMLicenseBackup + { + void BackupLicenses( + [In] BackupRestoreFlags dwFlags, + [In] IWMStatusCallback pCallback + ); + + void CancelLicenseBackup(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("C70B6334-A22E-4EFB-A245-15E65A004A13"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMLicenseRestore + { + void RestoreLicenses( + [In] BackupRestoreFlags dwFlags, + [In] IWMStatusCallback pCallback + ); + + void CancelLicenseRestore(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BCE-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMMediaProps + { + void GetType( + out Guid pguidType + ); + + void GetMediaType( + [In, Out, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(MTMarshaler))] AMMediaType pType, + ref int pcbType + ); + + void SetMediaType( + [In, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pType + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BD9-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMMetadataEditor + { + void Open( + [In] string pwszFilename + ); + + void Close(); + + void Flush(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("203CFFE3-2E18-4FDF-B59D-6E71530534CF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMMetadataEditor2 : IWMMetadataEditor + { + #region IWMMetadataEditor Methods + + new void Open( + [In] string pwszFilename + ); + + new void Close(); + + new void Flush(); + + #endregion + + void OpenEx( + [In] string pwszFilename, + [In] MetaDataAccess dwDesiredAccess, + [In] MetaDataShare dwShareMode + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BDE-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMMutualExclusion : IWMStreamList + { + #region IWMStreamList Methods + + new void GetStreams( + [Out, MarshalAs(UnmanagedType.LPArray)] short[] pwStreamNumArray, + ref short pcStreams + ); + + new void AddStream( + [In] short wStreamNum + ); + + new void RemoveStream( + [In] short wStreamNum + ); + + #endregion + + void GetType( + out Guid pguidType + ); + + void SetType( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("0302B57D-89D1-4BA2-85C9-166F2C53EB91"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMMutualExclusion2 : IWMMutualExclusion + { + #region IWMStreamList Methods + + new void GetStreams( + [Out, MarshalAs(UnmanagedType.LPArray)] short[] pwStreamNumArray, + ref short pcStreams + ); + + new void AddStream( + [In] short wStreamNum + ); + + new void RemoveStream( + [In] short wStreamNum + ); + + #endregion + + #region IWMMutualExclusion Methods + + new void GetType( + out Guid pguidType + ); + + new void SetType( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidType + ); + + #endregion + + void GetName( + [Out] StringBuilder pwszName, + ref short pcchName + ); + + void SetName( + [In] string pwszName + ); + + void GetRecordCount( + out short pwRecordCount + ); + + void AddRecord(); + + void RemoveRecord( + [In] short wRecordNumber + ); + + void GetRecordName( + [In] short wRecordNumber, + [Out] StringBuilder pwszRecordName, + ref short pcchRecordName + ); + + void SetRecordName( + [In] short wRecordNumber, + [In] string pwszRecordName + ); + + void GetStreamsForRecord( + [In] short wRecordNumber, + [Out, MarshalAs(UnmanagedType.LPArray)] short[] pwStreamNumArray, + ref short pcStreams + ); + + void AddStreamForRecord( + [In] short wRecordNumber, + [In] short wStreamNumber + ); + + void RemoveStreamForRecord( + [In] short wRecordNumber, + [In] short wStreamNumber + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BD7-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMOutputMediaProps : IWMMediaProps + { + #region IWMMediaProps Methods + + new void GetType( + out Guid pguidType + ); + + new void GetMediaType( + [In, Out, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(MTMarshaler))] AMMediaType pType, + ref int pcbType + ); + + new void SetMediaType( + [In, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pType + ); + + #endregion + + void GetStreamGroupName( + [Out] StringBuilder pwszName, + ref short pcchName + ); + + void GetConnectionName( + [Out] StringBuilder pwszName, + ref short pcchName + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("CDFB97AB-188F-40B3-B643-5B7903975C59"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMPacketSize + { + void GetMaxPacketSize( + out int pdwMaxPacketSize + ); + + void SetMaxPacketSize( + [In] int dwMaxPacketSize + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("8BFC2B9E-B646-4233-A877-1C6A079669DC"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMPacketSize2 : IWMPacketSize + { + #region IWMPacketSize Methods + + new void GetMaxPacketSize( + out int pdwMaxPacketSize + ); + + new void SetMaxPacketSize( + [In] int dwMaxPacketSize + ); + + #endregion + + void GetMinPacketSize( + out int pdwMinPacketSize + ); + + void SetMinPacketSize( + [In] int dwMinPacketSize + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BDB-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMProfile + { + void GetVersion( + out WMVersion pdwVersion + ); + + void GetName( + [Out] StringBuilder pwszName, + ref int pcchName + ); + + void SetName( + [In] string pwszName + ); + + void GetDescription( + [Out] StringBuilder pwszDescription, + ref int pcchDescription + ); + + void SetDescription( + [In] string pwszDescription + ); + + void GetStreamCount( + out int pcStreams + ); + + void GetStream( + [In] int dwStreamIndex, + out IWMStreamConfig ppConfig + ); + + void GetStreamByNumber( + [In] short wStreamNum, + out IWMStreamConfig ppConfig + ); + + void RemoveStream( + [In] IWMStreamConfig pConfig + ); + + void RemoveStreamByNumber( + [In] short wStreamNum + ); + + void AddStream( + [In] IWMStreamConfig pConfig + ); + + void ReconfigStream( + [In] IWMStreamConfig pConfig + ); + + void CreateNewStream( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidStreamType, + out IWMStreamConfig ppConfig + ); + + void GetMutualExclusionCount( + out int pcME + ); + + void GetMutualExclusion( + [In] int dwMEIndex, + out IWMMutualExclusion ppME + ); + + void RemoveMutualExclusion( + [In] IWMMutualExclusion pME + ); + + void AddMutualExclusion( + [In] IWMMutualExclusion pME + ); + + void CreateNewMutualExclusion( + out IWMMutualExclusion ppME + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("07E72D33-D94E-4BE7-8843-60AE5FF7E5F5"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMProfile2 : IWMProfile + { + #region IWMProfile Methods + + new void GetVersion( + out WMVersion pdwVersion + ); + + new void GetName( + [Out] StringBuilder pwszName, + ref int pcchName + ); + + new void SetName( + [In] string pwszName + ); + + new void GetDescription( + [Out] StringBuilder pwszDescription, + ref int pcchDescription + ); + + new void SetDescription( + [In] string pwszDescription + ); + + new void GetStreamCount( + out int pcStreams + ); + + new void GetStream( + [In] int dwStreamIndex, + out IWMStreamConfig ppConfig + ); + + new void GetStreamByNumber( + [In] short wStreamNum, + out IWMStreamConfig ppConfig + ); + + new void RemoveStream( + [In] IWMStreamConfig pConfig + ); + + new void RemoveStreamByNumber( + [In] short wStreamNum + ); + + new void AddStream( + [In] IWMStreamConfig pConfig + ); + + new void ReconfigStream( + [In] IWMStreamConfig pConfig + ); + + new void CreateNewStream( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidStreamType, + out IWMStreamConfig ppConfig + ); + + new void GetMutualExclusionCount( + out int pcME + ); + + new void GetMutualExclusion( + [In] int dwMEIndex, + out IWMMutualExclusion ppME + ); + + new void RemoveMutualExclusion( + [In] IWMMutualExclusion pME + ); + + new void AddMutualExclusion( + [In] IWMMutualExclusion pME + ); + + new void CreateNewMutualExclusion( + out IWMMutualExclusion ppME + ); + + #endregion + + void GetProfileID( + out Guid pguidID + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("00EF96CC-A461-4546-8BCD-C9A28F0E06F5"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMProfile3 : IWMProfile2 + { + #region IWMProfile Methods + + new void GetVersion( + out WMVersion pdwVersion + ); + + new void GetName( + [Out] StringBuilder pwszName, + ref int pcchName + ); + + new void SetName( + [In] string pwszName + ); + + new void GetDescription( + [Out] StringBuilder pwszDescription, + ref int pcchDescription + ); + + new void SetDescription( + [In] string pwszDescription + ); + + new void GetStreamCount( + out int pcStreams + ); + + new void GetStream( + [In] int dwStreamIndex, + out IWMStreamConfig ppConfig + ); + + new void GetStreamByNumber( + [In] short wStreamNum, + out IWMStreamConfig ppConfig + ); + + new void RemoveStream( + [In] IWMStreamConfig pConfig + ); + + new void RemoveStreamByNumber( + [In] short wStreamNum + ); + + new void AddStream( + [In] IWMStreamConfig pConfig + ); + + new void ReconfigStream( + [In] IWMStreamConfig pConfig + ); + + new void CreateNewStream( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidStreamType, + out IWMStreamConfig ppConfig + ); + + new void GetMutualExclusionCount( + out int pcME + ); + + new void GetMutualExclusion( + [In] int dwMEIndex, + out IWMMutualExclusion ppME + ); + + new void RemoveMutualExclusion( + [In] IWMMutualExclusion pME + ); + + new void AddMutualExclusion( + [In] IWMMutualExclusion pME + ); + + new void CreateNewMutualExclusion( + out IWMMutualExclusion ppME + ); + + #endregion + + #region IWMProfile2 Methods + + new void GetProfileID( + out Guid pguidID + ); + + #endregion + + void GetStorageFormat( + out StorageFormat pnStorageFormat + ); + + void SetStorageFormat( + [In] StorageFormat nStorageFormat + ); + + void GetBandwidthSharingCount( + out int pcBS + ); + + void GetBandwidthSharing( + [In] int dwBSIndex, + out IWMBandwidthSharing ppBS + ); + + void RemoveBandwidthSharing( + [In] IWMBandwidthSharing pBS + ); + + void AddBandwidthSharing( + [In] IWMBandwidthSharing pBS + ); + + void CreateNewBandwidthSharing( + out IWMBandwidthSharing ppBS + ); + + void GetStreamPrioritization( + out IWMStreamPrioritization ppSP + ); + + void SetStreamPrioritization( + [In] IWMStreamPrioritization pSP + ); + + void RemoveStreamPrioritization(); + + void CreateNewStreamPrioritization( + out IWMStreamPrioritization ppSP + ); + + void GetExpectedPacketCount( + [In] long msDuration, + out long pcPackets + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("D16679F2-6CA0-472D-8D31-2F5D55AEE155"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMProfileManager + { + void CreateEmptyProfile( + [In] WMVersion dwVersion, + out IWMProfile ppProfile + ); + + void LoadProfileByID( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidProfile, + out IWMProfile ppProfile + ); + + void LoadProfileByData( + [In] string pwszProfile, + out IWMProfile ppProfile + ); + + void SaveProfile( + [In] IWMProfile pIWMProfile, + [Out] StringBuilder pwszProfile, + ref int pdwLength + ); + + void GetSystemProfileCount( + out int pcProfiles + ); + + void LoadSystemProfile( + [In] int dwProfileIndex, + out IWMProfile ppProfile + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("7A924E51-73C1-494D-8019-23D37ED9B89A"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMProfileManager2 : IWMProfileManager + { + #region IWMProfileManager Methods + + new void CreateEmptyProfile( + [In] WMVersion dwVersion, + out IWMProfile ppProfile + ); + + new void LoadProfileByID( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidProfile, + out IWMProfile ppProfile + ); + + new void LoadProfileByData( + [In] string pwszProfile, + out IWMProfile ppProfile + ); + + new void SaveProfile( + [In] IWMProfile pIWMProfile, + [In] StringBuilder pwszProfile, + ref int pdwLength + ); + + new void GetSystemProfileCount( + out int pcProfiles + ); + + new void LoadSystemProfile( + [In] int dwProfileIndex, + out IWMProfile ppProfile + ); + + #endregion + + void GetSystemProfileVersion( + out WMVersion pdwVersion + ); + + void SetSystemProfileVersion( + WMVersion dwVersion + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("BA4DCC78-7EE0-4AB8-B27A-DBCE8BC51454"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMProfileManagerLanguage + { + void GetUserLanguageID( + out short wLangID + ); + + void SetUserLanguageID( + short wLangID + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("72995A79-5090-42A4-9C8C-D9D0B6D34BE5"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMPropertyVault + { + void GetPropertyCount( + out int pdwCount + ); + + void GetPropertyByName( + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref int pdwSize + ); + + void SetProperty( + [In] string pszName, + [In] AttrDataType pType, + [In, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + [In] int dwSize + ); + + void GetPropertyByIndex( + [In] int dwIndex, + [Out] StringBuilder pszName, + ref int pdwNameLen, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref int pdwSize + ); + + void CopyPropertiesFrom( + [In] IWMPropertyVault pIWMPropertyVault + ); + + void Clear(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BD6-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReader + { + void Open( + [In] string pwszURL, + [In] IWMReaderCallback pCallback, + [In] IntPtr pvContext + ); + + void Close(); + + void GetOutputCount( + out int pcOutputs + ); + + void GetOutputProps( + [In] int dwOutputNum, + out IWMOutputMediaProps ppOutput + ); + + void SetOutputProps( + [In] int dwOutputNum, + [In] IWMOutputMediaProps pOutput + ); + + void GetOutputFormatCount( + [In] int dwOutputNumber, + out int pcFormats + ); + + void GetOutputFormat( + [In] int dwOutputNumber, + [In] int dwFormatNumber, + out IWMOutputMediaProps ppProps + ); + + void Start( + [In] long cnsStart, + [In] long cnsDuration, + [In] float fRate, + [In] IntPtr pvContext + ); + + void Stop(); + + void Pause(); + + void Resume(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BEA-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderAdvanced + { + void SetUserProvidedClock( + [In, MarshalAs(UnmanagedType.Bool)] bool fUserClock + ); + + void GetUserProvidedClock( + [MarshalAs(UnmanagedType.Bool)] out bool pfUserClock + ); + + void DeliverTime( + [In] long cnsTime + ); + + void SetManualStreamSelection( + [In, MarshalAs(UnmanagedType.Bool)] bool fSelection + ); + + void GetManualStreamSelection( + [MarshalAs(UnmanagedType.Bool)] out bool pfSelection + ); + + void SetStreamsSelected( + [In] short cStreamCount, + [In, MarshalAs(UnmanagedType.LPArray)] short[] pwStreamNumbers, + [In, MarshalAs(UnmanagedType.LPArray)] StreamSelection[] pSelections + ); + + void GetStreamSelected( + [In] short wStreamNum, + out StreamSelection pSelection + ); + + void SetReceiveSelectionCallbacks( + [In, MarshalAs(UnmanagedType.Bool)] bool fGetCallbacks + ); + + void GetReceiveSelectionCallbacks( + [MarshalAs(UnmanagedType.Bool)] out bool pfGetCallbacks + ); + + void SetReceiveStreamSamples( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fReceiveStreamSamples + ); + + void GetReceiveStreamSamples( + [In] short wStreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfReceiveStreamSamples + ); + + void SetAllocateForOutput( + [In] int dwOutputNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + void GetAllocateForOutput( + [In] int dwOutputNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + + void SetAllocateForStream( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + void GetAllocateForStream( + [In] short dwSreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + + void GetStatistics( + [In, Out, MarshalAs(UnmanagedType.LPStruct)] WMReaderStatistics pStatistics + ); + + void SetClientInfo( + [In, MarshalAs(UnmanagedType.LPStruct)] WMReaderClientInfo pClientInfo + ); + + void GetMaxOutputSampleSize( + [In] int dwOutput, + out int pcbMax + ); + + void GetMaxStreamSampleSize( + [In] short wStream, + out int pcbMax + ); + + void NotifyLateDelivery( + long cnsLateness + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("AE14A945-B90C-4D0D-9127-80D665F7D73E"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderAdvanced2 : IWMReaderAdvanced + { + #region IWMReaderAdvanced Methods + + new void SetUserProvidedClock( + [In, MarshalAs(UnmanagedType.Bool)] bool fUserClock + ); + + new void GetUserProvidedClock( + [MarshalAs(UnmanagedType.Bool)] out bool pfUserClock + ); + + new void DeliverTime( + [In] long cnsTime + ); + + new void SetManualStreamSelection( + [In, MarshalAs(UnmanagedType.Bool)] bool fSelection + ); + + new void GetManualStreamSelection( + [MarshalAs(UnmanagedType.Bool)] out bool pfSelection + ); + + new void SetStreamsSelected( + [In] short cStreamCount, + [In] short[] pwStreamNumbers, + [In] StreamSelection[] pSelections + ); + + new void GetStreamSelected( + [In] short wStreamNum, + out StreamSelection pSelection + ); + + new void SetReceiveSelectionCallbacks( + [In, MarshalAs(UnmanagedType.Bool)] bool fGetCallbacks + ); + + new void GetReceiveSelectionCallbacks( + [MarshalAs(UnmanagedType.Bool)] out bool pfGetCallbacks + ); + + new void SetReceiveStreamSamples( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fReceiveStreamSamples + ); + + new void GetReceiveStreamSamples( + [In] short wStreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfReceiveStreamSamples + ); + + new void SetAllocateForOutput( + [In] int dwOutputNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + new void GetAllocateForOutput( + [In] int dwOutputNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + + new void SetAllocateForStream( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + new void GetAllocateForStream( + [In] short dwSreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + + new void GetStatistics( + [In, Out, MarshalAs(UnmanagedType.LPStruct)] WMReaderStatistics pStatistics + ); + + new void SetClientInfo( + [In, MarshalAs(UnmanagedType.LPStruct)] WMReaderClientInfo pClientInfo + ); + + new void GetMaxOutputSampleSize( + [In] int dwOutput, + out int pcbMax + ); + + new void GetMaxStreamSampleSize( + [In] short wStream, + out int pcbMax + ); + + new void NotifyLateDelivery( + long cnsLateness + ); + + #endregion + + void SetPlayMode( + [In] PlayMode Mode + ); + + void GetPlayMode( + out PlayMode pMode + ); + + void GetBufferProgress( + out int pdwPercent, + out long pcnsBuffering + ); + + void GetDownloadProgress( + out int pdwPercent, + out long pqwBytesDownloaded, + out long pcnsDownload + ); + + void GetSaveAsProgress( + out int pdwPercent + ); + + void SaveFileAs( + [In] string pwszFilename + ); + + void GetProtocolName( + [Out] StringBuilder pwszProtocol, + ref int pcchProtocol + ); + + void StartAtMarker( + [In] short wMarkerIndex, + [In] long cnsDuration, + [In] float fRate, + [In] IntPtr pvContext + ); + + void GetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + void SetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + [In] AttrDataType Type, + [In, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + [In] short cbLength + ); + + void Preroll( + [In] long cnsStart, + [In] long cnsDuration, + [In] float fRate + ); + + void SetLogClientID( + [In, MarshalAs(UnmanagedType.Bool)] bool fLogClientID + ); + + void GetLogClientID( + [MarshalAs(UnmanagedType.Bool)] out bool pfLogClientID + ); + + void StopBuffering(); + + void OpenStream( + [In] IStream pStream, + [In] IWMReaderCallback pCallback, + [In] IntPtr pvContext + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("5DC0674B-F04B-4A4E-9F2A-B1AFDE2C8100"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderAdvanced3 : IWMReaderAdvanced2 + { + #region IWMReaderAdvanced Methods + + new void SetUserProvidedClock( + [In, MarshalAs(UnmanagedType.Bool)] bool fUserClock + ); + + new void GetUserProvidedClock( + [MarshalAs(UnmanagedType.Bool)] out bool pfUserClock + ); + + new void DeliverTime( + [In] long cnsTime + ); + + new void SetManualStreamSelection( + [In, MarshalAs(UnmanagedType.Bool)] bool fSelection + ); + + new void GetManualStreamSelection( + [MarshalAs(UnmanagedType.Bool)] out bool pfSelection + ); + + new void SetStreamsSelected( + [In] short cStreamCount, + [In] short[] pwStreamNumbers, + [In] StreamSelection[] pSelections + ); + + new void GetStreamSelected( + [In] short wStreamNum, + out StreamSelection pSelection + ); + + new void SetReceiveSelectionCallbacks( + [In, MarshalAs(UnmanagedType.Bool)] bool fGetCallbacks + ); + + new void GetReceiveSelectionCallbacks( + [MarshalAs(UnmanagedType.Bool)] out bool pfGetCallbacks + ); + + new void SetReceiveStreamSamples( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fReceiveStreamSamples + ); + + new void GetReceiveStreamSamples( + [In] short wStreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfReceiveStreamSamples + ); + + new void SetAllocateForOutput( + [In] int dwOutputNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + new void GetAllocateForOutput( + [In] int dwOutputNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + + new void SetAllocateForStream( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + new void GetAllocateForStream( + [In] short dwSreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + + new void GetStatistics( + [In, Out, MarshalAs(UnmanagedType.LPStruct)] WMReaderStatistics pStatistics + ); + + new void SetClientInfo( + [In, MarshalAs(UnmanagedType.LPStruct)] WMReaderClientInfo pClientInfo + ); + + new void GetMaxOutputSampleSize( + [In] int dwOutput, + out int pcbMax + ); + + new void GetMaxStreamSampleSize( + [In] short wStream, + out int pcbMax + ); + + new void NotifyLateDelivery( + long cnsLateness + ); + + #endregion + + #region IWMReaderAdvanced2 Methods + + new void SetPlayMode( + [In] PlayMode Mode + ); + + new void GetPlayMode( + out PlayMode pMode + ); + + new void GetBufferProgress( + out int pdwPercent, + out long pcnsBuffering + ); + + new void GetDownloadProgress( + out int pdwPercent, + out long pqwBytesDownloaded, + out long pcnsDownload + ); + + new void GetSaveAsProgress( + out int pdwPercent + ); + + new void SaveFileAs( + [In] string pwszFilename + ); + + new void GetProtocolName( + [Out] StringBuilder pwszProtocol, + ref int pcchProtocol + ); + + new void StartAtMarker( + [In] short wMarkerIndex, + [In] long cnsDuration, + [In] float fRate, + [In] IntPtr pvContext + ); + + new void GetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + new void SetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + [In] AttrDataType Type, + [In] byte[] pValue, + [In] short cbLength + ); + + new void Preroll( + [In] long cnsStart, + [In] long cnsDuration, + [In] float fRate + ); + + new void SetLogClientID( + [In, MarshalAs(UnmanagedType.Bool)] bool fLogClientID + ); + + new void GetLogClientID( + [MarshalAs(UnmanagedType.Bool)] out bool pfLogClientID + ); + + new void StopBuffering(); + + new void OpenStream( + [In] IStream pStream, + [In] IWMReaderCallback pCallback, + [In] IntPtr pvContext + ); + + #endregion + + void StopNetStreaming(); + + void StartAtPosition( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.LPStruct)] RA3Union pvOffsetStart, + [In, MarshalAs(UnmanagedType.LPStruct)] RA3Union pvDuration, + [In] OffsetFormat dwOffsetFormat, + [In] float fRate, + [In] IntPtr pvContext + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("945A76A2-12AE-4D48-BD3C-CD1D90399B85"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderAdvanced4 : IWMReaderAdvanced3 + { + #region IWMReaderAdvanced Methods + + new void SetUserProvidedClock( + [In, MarshalAs(UnmanagedType.Bool)] bool fUserClock + ); + + new void GetUserProvidedClock( + [MarshalAs(UnmanagedType.Bool)] out bool pfUserClock + ); + + new void DeliverTime( + [In] long cnsTime + ); + + new void SetManualStreamSelection( + [In, MarshalAs(UnmanagedType.Bool)] bool fSelection + ); + + new void GetManualStreamSelection( + [MarshalAs(UnmanagedType.Bool)] out bool pfSelection + ); + + new void SetStreamsSelected( + [In] short cStreamCount, + [In] short[] pwStreamNumbers, + [In] StreamSelection[] pSelections + ); + + new void GetStreamSelected( + [In] short wStreamNum, + out StreamSelection pSelection + ); + + new void SetReceiveSelectionCallbacks( + [In, MarshalAs(UnmanagedType.Bool)] bool fGetCallbacks + ); + + new void GetReceiveSelectionCallbacks( + [MarshalAs(UnmanagedType.Bool)] out bool pfGetCallbacks + ); + + new void SetReceiveStreamSamples( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fReceiveStreamSamples + ); + + new void GetReceiveStreamSamples( + [In] short wStreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfReceiveStreamSamples + ); + + new void SetAllocateForOutput( + [In] int dwOutputNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + new void GetAllocateForOutput( + [In] int dwOutputNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + + new void SetAllocateForStream( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + new void GetAllocateForStream( + [In] short dwSreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + + new void GetStatistics( + [In, Out, MarshalAs(UnmanagedType.LPStruct)] WMReaderStatistics pStatistics + ); + + new void SetClientInfo( + [In, MarshalAs(UnmanagedType.LPStruct)] WMReaderClientInfo pClientInfo + ); + + new void GetMaxOutputSampleSize( + [In] int dwOutput, + out int pcbMax + ); + + new void GetMaxStreamSampleSize( + [In] short wStream, + out int pcbMax + ); + + new void NotifyLateDelivery( + long cnsLateness + ); + + #endregion + + #region IWMReaderAdvanced2 Methods + + new void SetPlayMode( + [In] PlayMode Mode + ); + + new void GetPlayMode( + out PlayMode pMode + ); + + new void GetBufferProgress( + out int pdwPercent, + out long pcnsBuffering + ); + + new void GetDownloadProgress( + out int pdwPercent, + out long pqwBytesDownloaded, + out long pcnsDownload + ); + + new void GetSaveAsProgress( + out int pdwPercent + ); + + new void SaveFileAs( + [In] string pwszFilename + ); + + new void GetProtocolName( + [Out] StringBuilder pwszProtocol, + ref int pcchProtocol + ); + + new void StartAtMarker( + [In] short wMarkerIndex, + [In] long cnsDuration, + [In] float fRate, + [In] IntPtr pvContext + ); + + new void GetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + new void SetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + [In] AttrDataType Type, + [In] byte[] pValue, + [In] short cbLength + ); + + new void Preroll( + [In] long cnsStart, + [In] long cnsDuration, + [In] float fRate + ); + + new void SetLogClientID( + [In, MarshalAs(UnmanagedType.Bool)] bool fLogClientID + ); + + new void GetLogClientID( + [MarshalAs(UnmanagedType.Bool)] out bool pfLogClientID + ); + + new void StopBuffering(); + + new void OpenStream( + [In] IStream pStream, + [In] IWMReaderCallback pCallback, + [In] IntPtr pvContext + ); + + #endregion + + #region IWMReaderAdvanced3 Methods + + new void StopNetStreaming(); + + new void StartAtPosition( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.LPStruct)] RA3Union pvOffsetStart, + [In, MarshalAs(UnmanagedType.LPStruct)] RA3Union pvDuration, + [In] OffsetFormat dwOffsetFormat, + [In] float fRate, + [In] IntPtr pvContext + ); + + #endregion + + void GetLanguageCount( + [In] int dwOutputNum, + out short pwLanguageCount + ); + + void GetLanguage( + [In] int dwOutputNum, + [In] short wLanguage, + [Out] StringBuilder pwszLanguageString, + ref short pcchLanguageStringLength + ); + + void GetMaxSpeedFactor( + out double pdblFactor + ); + + void IsUsingFastCache( + [MarshalAs(UnmanagedType.Bool)] out bool pfUsingFastCache + ); + + void AddLogParam( + [In] string wszNameSpace, + [In] string wszName, + [In] string wszValue + ); + + void SendLogParams(); + + void CanSaveFileAs( + [MarshalAs(UnmanagedType.Bool)] out bool pfCanSave + ); + + void CancelSaveFileAs(); + + void GetURL( + [Out] StringBuilder pwszURL, + ref int pcchURL + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("9F762FA7-A22E-428D-93C9-AC82F3AAFE5A"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderAllocatorEx + { + void AllocateForStreamEx( + [In] short wStreamNum, + [In] int cbBuffer, + out INSSBuffer ppBuffer, + [In] SampleFlagEx dwFlags, + [In] long cnsSampleTime, + [In] long cnsSampleDuration, + [In] IntPtr pvContext + ); + + void AllocateForOutputEx( + [In] int dwOutputNum, + [In] int cbBuffer, + out INSSBuffer ppBuffer, + [In] SampleFlagEx dwFlags, + [In] long cnsSampleTime, + [In] long cnsSampleDuration, + [In] IntPtr pvContext + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BD8-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderCallback : IWMStatusCallback + { + #region IWMStatusCallback Methods + + new void OnStatus( + [In] Status iStatus, + [In] int hr, + [In] AttrDataType dwType, + [In] IntPtr pValue, + [In] IntPtr pvContext + ); + + #endregion + + void OnSample( + [In] int dwOutputNum, + [In] long cnsSampleTime, + [In] long cnsSampleDuration, + [In] SampleFlag dwFlags, + [In] INSSBuffer pSample, + [In] IntPtr pvContext + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BEB-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderCallbackAdvanced + { + void OnStreamSample( + [In] short wStreamNum, + [In] long cnsSampleTime, + [In] long cnsSampleDuration, + [In] SampleFlag dwFlags, + [In] INSSBuffer pSample, + [In] IntPtr pvContext + ); + + void OnTime( + [In] long cnsCurrentTime, + [In] IntPtr pvContext + ); + + void OnStreamSelection( + [In] short wStreamCount, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=0)] short[] pStreamNumbers, + [In, MarshalAs(UnmanagedType.LPArray, SizeParamIndex=0)] StreamSelection[] pSelections, + [In] IntPtr pvContext + ); + + void OnOutputPropsChanged( + [In] int dwOutputNum, + [In, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pMediaType, + [In] IntPtr pvContext + ); + + void AllocateForStream( + [In] short wStreamNum, + [In] int cbBuffer, + out INSSBuffer ppBuffer, + [In] IntPtr pvContext + ); + + void AllocateForOutput( + [In] int dwOutputNum, + [In] int cbBuffer, + out INSSBuffer ppBuffer, + [In] IntPtr pvContext + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BEC-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderNetworkConfig + { + void GetBufferingTime( + out long pcnsBufferingTime + ); + + void SetBufferingTime( + [In] long cnsBufferingTime + ); + + void GetUDPPortRanges( + [Out, MarshalAs(UnmanagedType.LPArray)] WMPortNumberRange[] pRangeArray, + ref int pcRanges + ); + + void SetUDPPortRanges( + [In, MarshalAs(UnmanagedType.LPArray)] WMPortNumberRange[] pRangeArray, + [In] int cRanges + ); + + void GetProxySettings( + [In] string pwszProtocol, + out ProxySettings pProxySetting + ); + + void SetProxySettings( + [In] string pwszProtocol, + [In] ProxySettings ProxySetting + ); + + void GetProxyHostName( + [In] string pwszProtocol, + [Out] StringBuilder pwszHostName, + ref int pcchHostName + ); + + void SetProxyHostName( + [In] string pwszProtocol, + [In] string pwszHostName + ); + + void GetProxyPort( + [In] string pwszProtocol, + out int pdwPort + ); + + void SetProxyPort( + [In] string pwszProtocol, + [In] int dwPort + ); + + void GetProxyExceptionList( + [In] string pwszProtocol, + [Out] StringBuilder pwszExceptionList, + ref int pcchExceptionList + ); + + void SetProxyExceptionList( + [In] string pwszProtocol, + [In] string pwszExceptionList + ); + + void GetProxyBypassForLocal( + [In] string pwszProtocol, + [MarshalAs(UnmanagedType.Bool)] out bool pfBypassForLocal + ); + + void SetProxyBypassForLocal( + [In] string pwszProtocol, + [In, MarshalAs(UnmanagedType.Bool)] bool fBypassForLocal + ); + + void GetForceRerunAutoProxyDetection( + [MarshalAs(UnmanagedType.Bool)] out bool pfForceRerunDetection + ); + + void SetForceRerunAutoProxyDetection( + [In, MarshalAs(UnmanagedType.Bool)] bool fForceRerunDetection + ); + + void GetEnableMulticast( + [MarshalAs(UnmanagedType.Bool)] out bool pfEnableMulticast + ); + + void SetEnableMulticast( + [In, MarshalAs(UnmanagedType.Bool)] bool fEnableMulticast + ); + + void GetEnableHTTP( + [MarshalAs(UnmanagedType.Bool)] out bool pfEnableHTTP + ); + + void SetEnableHTTP( + [In, MarshalAs(UnmanagedType.Bool)] bool fEnableHTTP + ); + + void GetEnableUDP( + [MarshalAs(UnmanagedType.Bool)] out bool pfEnableUDP + ); + + void SetEnableUDP( + [In, MarshalAs(UnmanagedType.Bool)] bool fEnableUDP + ); + + void GetEnableTCP( + [MarshalAs(UnmanagedType.Bool)] out bool pfEnableTCP + ); + + void SetEnableTCP( + [In, MarshalAs(UnmanagedType.Bool)] bool fEnableTCP + ); + + void ResetProtocolRollover(); + + void GetConnectionBandwidth( + out int pdwConnectionBandwidth + ); + + void SetConnectionBandwidth( + [In] int dwConnectionBandwidth + ); + + void GetNumProtocolsSupported( + out int pcProtocols + ); + + void GetSupportedProtocolName( + [In] int dwProtocolNum, + [Out] StringBuilder pwszProtocolName, + ref int pcchProtocolName + ); + + void AddLoggingUrl( + [In] string pwszURL + ); + + void GetLoggingUrl( + [In] int dwIndex, + [Out] StringBuilder pwszURL, + ref int pcchURL + ); + + void GetLoggingUrlCount( + out int pdwUrlCount + ); + + void ResetLoggingUrlList(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("D979A853-042B-4050-8387-C939DB22013F"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderNetworkConfig2 : IWMReaderNetworkConfig + { + #region IWMReaderNetworkConfig Methods + + new void GetBufferingTime( + out long pcnsBufferingTime + ); + + new void SetBufferingTime( + [In] long cnsBufferingTime + ); + + new void GetUDPPortRanges( + [Out, MarshalAs(UnmanagedType.LPArray)] WMPortNumberRange[] pRangeArray, + ref int pcRanges + ); + + new void SetUDPPortRanges( + [In, MarshalAs(UnmanagedType.LPArray)] WMPortNumberRange[] pRangeArray, + [In] int cRanges + ); + + new void GetProxySettings( + [In] string pwszProtocol, + out ProxySettings pProxySetting + ); + + new void SetProxySettings( + [In] string pwszProtocol, + [In] ProxySettings ProxySetting + ); + + new void GetProxyHostName( + [In] string pwszProtocol, + [Out] StringBuilder pwszHostName, + ref int pcchHostName + ); + + new void SetProxyHostName( + [In] string pwszProtocol, + [In] string pwszHostName + ); + + new void GetProxyPort( + [In] string pwszProtocol, + out int pdwPort + ); + + new void SetProxyPort( + [In] string pwszProtocol, + [In] int dwPort + ); + + new void GetProxyExceptionList( + [In] string pwszProtocol, + [Out] StringBuilder pwszExceptionList, + ref int pcchExceptionList + ); + + new void SetProxyExceptionList( + [In] string pwszProtocol, + [In] string pwszExceptionList + ); + + new void GetProxyBypassForLocal( + [In] string pwszProtocol, + [MarshalAs(UnmanagedType.Bool)] out bool pfBypassForLocal + ); + + new void SetProxyBypassForLocal( + [In] string pwszProtocol, + [In, MarshalAs(UnmanagedType.Bool)] bool fBypassForLocal + ); + + new void GetForceRerunAutoProxyDetection( + [MarshalAs(UnmanagedType.Bool)] out bool pfForceRerunDetection + ); + + new void SetForceRerunAutoProxyDetection( + [In, MarshalAs(UnmanagedType.Bool)] bool fForceRerunDetection + ); + + new void GetEnableMulticast( + [MarshalAs(UnmanagedType.Bool)] out bool pfEnableMulticast + ); + + new void SetEnableMulticast( + [In, MarshalAs(UnmanagedType.Bool)] bool fEnableMulticast + ); + + new void GetEnableHTTP( + [MarshalAs(UnmanagedType.Bool)] out bool pfEnableHTTP + ); + + new void SetEnableHTTP( + [In, MarshalAs(UnmanagedType.Bool)] bool fEnableHTTP + ); + + new void GetEnableUDP( + [MarshalAs(UnmanagedType.Bool)] out bool pfEnableUDP + ); + + new void SetEnableUDP( + [In, MarshalAs(UnmanagedType.Bool)] bool fEnableUDP + ); + + new void GetEnableTCP( + [MarshalAs(UnmanagedType.Bool)] out bool pfEnableTCP + ); + + new void SetEnableTCP( + [In, MarshalAs(UnmanagedType.Bool)] bool fEnableTCP + ); + + new void ResetProtocolRollover(); + + new void GetConnectionBandwidth( + out int pdwConnectionBandwidth + ); + + new void SetConnectionBandwidth( + [In] int dwConnectionBandwidth + ); + + new void GetNumProtocolsSupported( + out int pcProtocols + ); + + new void GetSupportedProtocolName( + [In] int dwProtocolNum, + [Out] StringBuilder pwszProtocolName, + ref int pcchProtocolName + ); + + new void AddLoggingUrl( + [In] string pwszURL + ); + + new void GetLoggingUrl( + [In] int dwIndex, + [Out] StringBuilder pwszURL, + ref int pcchURL + ); + + new void GetLoggingUrlCount( + out int pdwUrlCount + ); + + new void ResetLoggingUrlList(); + + #endregion + + void GetEnableContentCaching( + [MarshalAs(UnmanagedType.Bool)] out bool pfEnableContentCaching + ); + + void SetEnableContentCaching( + [In, MarshalAs(UnmanagedType.Bool)] bool fEnableContentCaching + ); + + void GetEnableFastCache( + [MarshalAs(UnmanagedType.Bool)] out bool pfEnableFastCache + ); + + void SetEnableFastCache( + [In, MarshalAs(UnmanagedType.Bool)] bool fEnableFastCache + ); + + void GetAcceleratedStreamingDuration( + out long pcnsAccelDuration + ); + + void SetAcceleratedStreamingDuration( + [In] long cnsAccelDuration + ); + + void GetAutoReconnectLimit( + out int pdwAutoReconnectLimit + ); + + void SetAutoReconnectLimit( + [In] int dwAutoReconnectLimit + ); + + void GetEnableResends( + [MarshalAs(UnmanagedType.Bool)] out bool pfEnableResends + ); + + void SetEnableResends( + [In, MarshalAs(UnmanagedType.Bool)] bool fEnableResends + ); + + void GetEnableThinning( + [MarshalAs(UnmanagedType.Bool)] out bool pfEnableThinning + ); + + void SetEnableThinning( + [In, MarshalAs(UnmanagedType.Bool)] bool fEnableThinning + ); + + void GetMaxNetPacketSize( + out int pdwMaxNetPacketSize + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BED-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderStreamClock + { + void GetTime( + out long pcnsNow + ); + + void SetTimer( + [In] long cnsWhen, + [In] IntPtr pvParam, + out int pdwTimerId + ); + + void KillTimer( + [In] int dwTimerId + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("FDBE5592-81A1-41EA-93BD-735CAD1ADC05"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderTypeNegotiation + { + void TryOutputProps( + [In] int dwOutputNum, + [In] IWMOutputMediaProps pOutput + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("CF4B1F99-4DE2-4E49-A363-252740D99BC1"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMRegisterCallback + { + void Advise( + [In] IWMStatusCallback pCallback, + [In] IntPtr pvContext + ); + + void Unadvise( + [In] IWMStatusCallback pCallback, + [In] IntPtr pvContext + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("6D7CDC70-9888-11D3-8EDC-00C04F6109CF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMStatusCallback + { + void OnStatus( + [In] Status iStatus, + [In] int hr, + [In] AttrDataType dwType, + [In] IntPtr pValue, + [In] IntPtr pvContext + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BDC-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMStreamConfig + { + void GetStreamType( + out Guid pguidStreamType + ); + + void GetStreamNumber( + out short pwStreamNum + ); + + void SetStreamNumber( + [In] short wStreamNum + ); + + void GetStreamName( + [Out] StringBuilder pwszStreamName, + ref short pcchStreamName + ); + + void SetStreamName( + [In] string pwszStreamName + ); + + void GetConnectionName( + [Out] StringBuilder pwszInputName, + ref short pcchInputName + ); + + void SetConnectionName( + [In] string pwszInputName + ); + + void GetBitrate( + out int pdwBitrate + ); + + void SetBitrate( + [In] int pdwBitrate + ); + + void GetBufferWindow( + out int pmsBufferWindow + ); + + void SetBufferWindow( + [In] int msBufferWindow + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("7688D8CB-FC0D-43BD-9459-5A8DEC200CFA"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMStreamConfig2 : IWMStreamConfig + { + #region IWMStreamConfig Methods + + new void GetStreamType( + out Guid pguidStreamType + ); + + new void GetStreamNumber( + out short pwStreamNum + ); + + new void SetStreamNumber( + [In] short wStreamNum + ); + + new void GetStreamName( + [Out] StringBuilder pwszStreamName, + ref short pcchStreamName + ); + + new void SetStreamName( + [In] string pwszStreamName + ); + + new void GetConnectionName( + [Out] StringBuilder pwszInputName, + ref short pcchInputName + ); + + new void SetConnectionName( + [In] string pwszInputName + ); + + new void GetBitrate( + out int pdwBitrate + ); + + new void SetBitrate( + [In] int pdwBitrate + ); + + new void GetBufferWindow( + out int pmsBufferWindow + ); + + new void SetBufferWindow( + [In] int msBufferWindow + ); + + #endregion + + void GetTransportType( + out TransportType pnTransportType + ); + + void SetTransportType( + [In] TransportType nTransportType + ); + + void AddDataUnitExtension( + [In] Guid guidExtensionSystemID, + [In] short cbExtensionDataSize, + [In, MarshalAs(UnmanagedType.LPArray)] byte[] pbExtensionSystemInfo, + [In] int cbExtensionSystemInfo + ); + + void GetDataUnitExtensionCount( + out short pcDataUnitExtensions + ); + + void GetDataUnitExtension( + [In] short wDataUnitExtensionNumber, + out Guid pguidExtensionSystemID, + out short pcbExtensionDataSize, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pbExtensionSystemInfo, + ref int pcbExtensionSystemInfo + ); + + void RemoveAllDataUnitExtensions(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("CB164104-3AA9-45A7-9AC9-4DAEE131D6E1"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMStreamConfig3 : IWMStreamConfig2 + { + #region IWMStreamConfig Methods + + new void GetStreamType( + out Guid pguidStreamType + ); + + new void GetStreamNumber( + out short pwStreamNum + ); + + new void SetStreamNumber( + [In] short wStreamNum + ); + + new void GetStreamName( + [Out] StringBuilder pwszStreamName, + ref short pcchStreamName + ); + + new void SetStreamName( + [In] string pwszStreamName + ); + + new void GetConnectionName( + [Out] StringBuilder pwszInputName, + ref short pcchInputName + ); + + new void SetConnectionName( + [In] string pwszInputName + ); + + new void GetBitrate( + out int pdwBitrate + ); + + new void SetBitrate( + [In] int pdwBitrate + ); + + new void GetBufferWindow( + out int pmsBufferWindow + ); + + new void SetBufferWindow( + [In] int msBufferWindow + ); + + #endregion + + #region IWMStreamConfig2 Methods + + new void GetTransportType( + out TransportType pnTransportType + ); + + new void SetTransportType( + [In] TransportType nTransportType + ); + + new void AddDataUnitExtension( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidExtensionSystemID, + [In] short cbExtensionDataSize, + [In] byte[] pbExtensionSystemInfo, + [In] int cbExtensionSystemInfo + ); + + new void GetDataUnitExtensionCount( + out short pcDataUnitExtensions + ); + + new void GetDataUnitExtension( + [In] short wDataUnitExtensionNumber, + out Guid pguidExtensionSystemID, + out short pcbExtensionDataSize, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pbExtensionSystemInfo, + ref int pcbExtensionSystemInfo + ); + + new void RemoveAllDataUnitExtensions(); + + #endregion + + void GetLanguage( + [Out] StringBuilder pwszLanguageString, + ref short pcchLanguageStringLength + ); + + void SetLanguage( + [In] string pwszLanguageString + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BDD-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMStreamList + { + void GetStreams( + [Out, MarshalAs(UnmanagedType.LPArray)] short[] pwStreamNumArray, + ref short pcStreams + ); + + void AddStream( + [In] short wStreamNum + ); + + void RemoveStream( + [In] short wStreamNum + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("8C1C6090-F9A8-4748-8EC3-DD1108BA1E77"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMStreamPrioritization + { + void GetPriorityRecords( + [Out, MarshalAs(UnmanagedType.LPArray)] WMStreamPrioritizationRecord [] pRecordArray, + ref short pcRecords + ); + + void SetPriorityRecords( + [In, MarshalAs(UnmanagedType.LPArray)] WMStreamPrioritizationRecord [] pRecordArray, + [In] short cRecords + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("9397F121-7705-4DC9-B049-98B698188414"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMSyncReader + { + void Open( + [In] string pwszFilename + ); + + void Close(); + + void SetRange( + [In] long cnsStartTime, + [In] long cnsDuration + ); + + void SetRangeByFrame( + [In] short wStreamNum, + [In] long qwFrameNumber, + [In] long cFramesToRead + ); + + void GetNextSample( + [In] short wStreamNum, + out INSSBuffer ppSample, + out long pcnsSampleTime, + out long pcnsDuration, + out SampleFlag pdwFlags, + out int pdwOutputNum, + out short pwStreamNum + ); + + void SetStreamsSelected( + [In] short cStreamCount, + [In, MarshalAs(UnmanagedType.LPArray)] short[] pwStreamNumbers, + [In, MarshalAs(UnmanagedType.LPArray)] StreamSelection[] pSelections + ); + + void GetStreamSelected( + [In] short wStreamNum, + out StreamSelection pSelection + ); + + void SetReadStreamSamples( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fCompressed + ); + + void GetReadStreamSamples( + [In] short wStreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfCompressed + ); + + void GetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + void SetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + [In] AttrDataType Type, + [In, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + [In] short cbLength + ); + + void GetOutputCount( + out int pcOutputs + ); + + void GetOutputProps( + [In] int dwOutputNum, + out IWMOutputMediaProps ppOutput + ); + + void SetOutputProps( + [In] int dwOutputNum, + [In] IWMOutputMediaProps pOutput + ); + + void GetOutputFormatCount( + [In] int dwOutputNum, + out int pcFormats + ); + + void GetOutputFormat( + [In] int dwOutputNum, + [In] int dwFormatNum, + out IWMOutputMediaProps ppProps + ); + + void GetOutputNumberForStream( + [In] short wStreamNum, + out int pdwOutputNum + ); + + void GetStreamNumberForOutput( + [In] int dwOutputNum, + out short pwStreamNum + ); + + void GetMaxOutputSampleSize( + [In] int dwOutput, + out int pcbMax + ); + + void GetMaxStreamSampleSize( + [In] short wStream, + out int pcbMax + ); + + void OpenStream( + [In] IStream pStream + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("FAED3D21-1B6B-4AF7-8CB6-3E189BBC187B"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMSyncReader2 : IWMSyncReader + { + #region IWMSyncReader Methods + + new void Open( + [In] string pwszFilename + ); + + new void Close(); + + new void SetRange( + [In] long cnsStartTime, + [In] long cnsDuration + ); + + new void SetRangeByFrame( + [In] short wStreamNum, + [In] long qwFrameNumber, + [In] long cFramesToRead + ); + + new void GetNextSample( + [In] short wStreamNum, + out INSSBuffer ppSample, + out long pcnsSampleTime, + out long pcnsDuration, + out SampleFlag pdwFlags, + out int pdwOutputNum, + out short pwStreamNum + ); + + new void SetStreamsSelected( + [In] short cStreamCount, + [In] short[] pwStreamNumbers, + [In] StreamSelection[] pSelections + ); + + new void GetStreamSelected( + [In] short wStreamNum, + out StreamSelection pSelection + ); + + new void SetReadStreamSamples( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fCompressed + ); + + new void GetReadStreamSamples( + [In] short wStreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfCompressed + ); + + new void GetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + new void SetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + [In] AttrDataType Type, + [In] byte[] pValue, + [In] short cbLength + ); + + new void GetOutputCount( + out int pcOutputs + ); + + new void GetOutputProps( + [In] int dwOutputNum, + out IWMOutputMediaProps ppOutput + ); + + new void SetOutputProps( + [In] int dwOutputNum, + [In] IWMOutputMediaProps pOutput + ); + + new void GetOutputFormatCount( + [In] int dwOutputNum, + out int pcFormats + ); + + new void GetOutputFormat( + [In] int dwOutputNum, + [In] int dwFormatNum, + out IWMOutputMediaProps ppProps + ); + + new void GetOutputNumberForStream( + [In] short wStreamNum, + out int pdwOutputNum + ); + + new void GetStreamNumberForOutput( + [In] int dwOutputNum, + out short pwStreamNum + ); + + new void GetMaxOutputSampleSize( + [In] int dwOutput, + out int pcbMax + ); + + new void GetMaxStreamSampleSize( + [In] short wStream, + out int pcbMax + ); + + new void OpenStream( + [In] IStream pStream + ); + + #endregion + + void SetRangeByTimecode( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.LPStruct)] TimeCodeExtensionData pStart, + [In, MarshalAs(UnmanagedType.LPStruct)] TimeCodeExtensionData pEnd + ); + + void SetRangeByFrameEx( + [In] short wStreamNum, + [In] long qwFrameNumber, + [In] long cFramesToRead, + out long pcnsStartTime + ); + + void SetAllocateForOutput( + [In] int dwOutputNum, + [In] IWMReaderAllocatorEx pAllocator + ); + + void GetAllocateForOutput( + [In] int dwOutputNum, + out IWMReaderAllocatorEx ppAllocator + ); + + void SetAllocateForStream( + [In] short wStreamNum, + [In] IWMReaderAllocatorEx pAllocator + ); + + void GetAllocateForStream( + [In] short dwSreamNum, + out IWMReaderAllocatorEx ppAllocator + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BCF-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMVideoMediaProps : IWMMediaProps + { + #region IWMMediaProps Methods + + new void GetType( + out Guid pguidType + ); + + new void GetMediaType( + [In, Out, MarshalAs(UnmanagedType.CustomMarshaler, MarshalTypeRef = typeof(MTMarshaler))] AMMediaType pType, + ref int pcbType + ); + + new void SetMediaType( + [In, MarshalAs(UnmanagedType.LPStruct)] AMMediaType pType + ); + + #endregion + + void GetMaxKeyFrameSpacing( + out long pllTime + ); + + void SetMaxKeyFrameSpacing( + [In] long llTime + ); + + void GetQuality( + out int pdwQuality + ); + + void SetQuality( + [In] int dwQuality + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BD4-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriter + { + void SetProfileByID( + [In, MarshalAs(UnmanagedType.LPStruct)] Guid guidProfile + ); + + void SetProfile( + [In] IWMProfile pProfile + ); + + void SetOutputFilename( + [In] string pwszFilename + ); + + void GetInputCount( + out int pcInputs + ); + + void GetInputProps( + [In] int dwInputNum, + out IWMInputMediaProps ppInput + ); + + void SetInputProps( + [In] int dwInputNum, + [In] IWMInputMediaProps pInput + ); + + void GetInputFormatCount( + [In] int dwInputNumber, + out int pcFormats + ); + + void GetInputFormat( + [In] int dwInputNumber, + [In] int dwFormatNumber, + out IWMInputMediaProps pProps + ); + + void BeginWriting(); + + void EndWriting(); + + void AllocateSample( + [In] int dwSampleSize, + out INSSBuffer ppSample + ); + + void WriteSample( + [In] int dwInputNum, + [In] long cnsSampleTime, + [In] SampleFlag dwFlags, + [In] INSSBuffer pSample + ); + + void Flush(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BE3-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriterAdvanced + { + void GetSinkCount( + out int pcSinks + ); + + void GetSink( + [In] int dwSinkNum, + out IWMWriterSink ppSink + ); + + void AddSink( + [In] IWMWriterSink pSink + ); + + void RemoveSink( + [In] IWMWriterSink pSink + ); + + void WriteStreamSample( + [In] short wStreamNum, + [In] long cnsSampleTime, + [In] int msSampleSendTime, + [In] long cnsSampleDuration, + [In] SampleFlag dwFlags, + [In] INSSBuffer pSample + ); + + void SetLiveSource( + [In, MarshalAs(UnmanagedType.Bool)] bool fIsLiveSource + ); + + void IsRealTime( + [MarshalAs(UnmanagedType.Bool)] out bool pfRealTime + ); + + void GetWriterTime( + out long pcnsCurrentTime + ); + + void GetStatistics( + [In] short wStreamNum, + out WriterStatistics pStats + ); + + void SetSyncTolerance( + [In] int msWindow + ); + + void GetSyncTolerance( + out int pmsWindow + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("962DC1EC-C046-4DB8-9CC7-26CEAE500817"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriterAdvanced2 : IWMWriterAdvanced + { + #region IWMWriterAdvanced Methods + + new void GetSinkCount( + out int pcSinks + ); + + new void GetSink( + [In] int dwSinkNum, + out IWMWriterSink ppSink + ); + + new void AddSink( + [In] IWMWriterSink pSink + ); + + new void RemoveSink( + [In] IWMWriterSink pSink + ); + + new void WriteStreamSample( + [In] short wStreamNum, + [In] long cnsSampleTime, + [In] int msSampleSendTime, + [In] long cnsSampleDuration, + [In] SampleFlag dwFlags, + [In] INSSBuffer pSample + ); + + new void SetLiveSource( + [In, MarshalAs(UnmanagedType.Bool)] bool fIsLiveSource + ); + + new void IsRealTime( + [MarshalAs(UnmanagedType.Bool)] out bool pfRealTime + ); + + new void GetWriterTime( + out long pcnsCurrentTime + ); + + new void GetStatistics( + [In] short wStreamNum, + out WriterStatistics pStats + ); + + new void SetSyncTolerance( + [In] int msWindow + ); + + new void GetSyncTolerance( + out int pmsWindow + ); + + #endregion + + void GetInputSetting( + [In] int dwInputNum, + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + void SetInputSetting( + [In] int dwInputNum, + [In] string pszName, + [In] AttrDataType Type, + [In, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + [In] short cbLength + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("2CD6492D-7C37-4E76-9D3B-59261183A22E"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriterAdvanced3 : IWMWriterAdvanced2 + { + #region IWMWriterAdvanced Methods + + new void GetSinkCount( + out int pcSinks + ); + + new void GetSink( + [In] int dwSinkNum, + out IWMWriterSink ppSink + ); + + new void AddSink( + [In] IWMWriterSink pSink + ); + + new void RemoveSink( + [In] IWMWriterSink pSink + ); + + new void WriteStreamSample( + [In] short wStreamNum, + [In] long cnsSampleTime, + [In] int msSampleSendTime, + [In] long cnsSampleDuration, + [In] SampleFlag dwFlags, + [In] INSSBuffer pSample + ); + + new void SetLiveSource( + [In, MarshalAs(UnmanagedType.Bool)] bool fIsLiveSource + ); + + new void IsRealTime( + [MarshalAs(UnmanagedType.Bool)] out bool pfRealTime + ); + + new void GetWriterTime( + out long pcnsCurrentTime + ); + + new void GetStatistics( + [In] short wStreamNum, + out WriterStatistics pStats + ); + + new void SetSyncTolerance( + [In] int msWindow + ); + + new void GetSyncTolerance( + out int pmsWindow + ); + + new void GetInputSetting( + [In] int dwInputNum, + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + #endregion + + #region IWMWriterAdvanced2 Methods + + new void SetInputSetting( + [In] int dwInputNum, + [In] string pszName, + [In] AttrDataType Type, + [In] byte[] pValue, + [In] short cbLength + ); + + #endregion + + void GetStatisticsEx( + [In] short wStreamNum, + out WMWriterStatisticsEx pStats + ); + + void SetNonBlocking(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BE5-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriterFileSink : IWMWriterSink + { + #region IWMWriterSink Methods + + new void OnHeader( + [In] INSSBuffer pHeader + ); + + new void IsRealTime( + [MarshalAs(UnmanagedType.Bool)] out bool pfRealTime + ); + + new void AllocateDataUnit( + [In] int cbDataUnit, + out INSSBuffer ppDataUnit + ); + + new void OnDataUnit( + [In] INSSBuffer pDataUnit + ); + + new void OnEndWriting(); + + #endregion + + void Open( + [In] string pwszFilename + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("14282BA7-4AEF-4205-8CE5-C229035A05BC"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriterFileSink2 : IWMWriterFileSink + { + #region IWMWriterSink Methods + + new void OnHeader( + [In] INSSBuffer pHeader + ); + + new void IsRealTime( + [MarshalAs(UnmanagedType.Bool)] out bool pfRealTime + ); + + new void AllocateDataUnit( + [In] int cbDataUnit, + out INSSBuffer ppDataUnit + ); + + new void OnDataUnit( + [In] INSSBuffer pDataUnit + ); + + new void OnEndWriting(); + + #endregion + + #region IWMWriterFileSink Methods + + new void Open( + [In] string pwszFilename + ); + + #endregion + + void Start( + [In] long cnsStartTime + ); + + void Stop( + [In] long cnsStopTime + ); + + void IsStopped( + [MarshalAs(UnmanagedType.Bool)] out bool pfStopped + ); + + void GetFileDuration( + out long pcnsDuration + ); + + void GetFileSize( + out long pcbFile + ); + + void Close(); + + void IsClosed( + [MarshalAs(UnmanagedType.Bool)] out bool pfClosed + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("3FEA4FEB-2945-47A7-A1DD-C53A8FC4C45C"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriterFileSink3 : IWMWriterFileSink2 + { + #region IWMWriterSink Methods + + new void OnHeader( + [In] INSSBuffer pHeader + ); + + new void IsRealTime( + [MarshalAs(UnmanagedType.Bool)] out bool pfRealTime + ); + + new void AllocateDataUnit( + [In] int cbDataUnit, + out INSSBuffer ppDataUnit + ); + + new void OnDataUnit( + [In] INSSBuffer pDataUnit + ); + + new void OnEndWriting(); + + #endregion + + #region IWMWriterFileSink Methods + + new void Open( + [In] string pwszFilename + ); + + #endregion + + #region IWMWriterFileSink2 Methods + + new void Start( + [In] long cnsStartTime + ); + + new void Stop( + [In] long cnsStopTime + ); + + new void IsStopped( + [MarshalAs(UnmanagedType.Bool)] out bool pfStopped + ); + + new void GetFileDuration( + out long pcnsDuration + ); + + new void GetFileSize( + out long pcbFile + ); + + new void Close(); + + new void IsClosed( + [MarshalAs(UnmanagedType.Bool)] out bool pfClosed + ); + + #endregion + + void SetAutoIndexing( + [In, MarshalAs(UnmanagedType.Bool)] bool fDoAutoIndexing + ); + + void GetAutoIndexing( + [MarshalAs(UnmanagedType.Bool)] out bool pfAutoIndexing + ); + + void SetControlStream( + [In] short wStreamNumber, + [In, MarshalAs(UnmanagedType.Bool)] bool fShouldControlStartAndStop + ); + + void GetMode( + out FileSinkMode pdwFileSinkMode + ); + + void OnDataUnitEx( + [In, MarshalAs(UnmanagedType.LPStruct)] FileSinkDataUnit pFileSinkDataUnit + ); + + void SetUnbufferedIO( + [In, MarshalAs(UnmanagedType.Bool)] bool fUnbufferedIO, + [In, MarshalAs(UnmanagedType.Bool)] bool fRestrictMemUsage + ); + + void GetUnbufferedIO( + [MarshalAs(UnmanagedType.Bool)] out bool pfUnbufferedIO + ); + + void CompleteOperations(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BE7-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriterNetworkSink : IWMWriterSink + { + #region IWMWriterSink Methods + + new void OnHeader( + [In] INSSBuffer pHeader + ); + + new void IsRealTime( + [MarshalAs(UnmanagedType.Bool)] out bool pfRealTime + ); + + new void AllocateDataUnit( + [In] int cbDataUnit, + out INSSBuffer ppDataUnit + ); + + new void OnDataUnit( + [In] INSSBuffer pDataUnit + ); + + new void OnEndWriting(); + + #endregion + + void SetMaximumClients( + [In] int dwMaxClients + ); + + void GetMaximumClients( + out int pdwMaxClients + ); + + void SetNetworkProtocol( + [In] NetProtocol protocol + ); + + void GetNetworkProtocol( + out NetProtocol pProtocol + ); + + void GetHostURL( + [Out] StringBuilder pwszURL, + ref int pcchURL + ); + + void Open( + ref int pdwPortNum + ); + + void Disconnect(); + + void Close(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("81E20CE4-75EF-491A-8004-FC53C45BDC3E"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriterPostView + { + void SetPostViewCallback( + IWMWriterPostViewCallback pCallback, + IntPtr pvContext + ); + + void SetReceivePostViewSamples( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fReceivePostViewSamples + ); + + void GetReceivePostViewSamples( + [In] short wStreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfReceivePostViewSamples + ); + + void GetPostViewProps( + [In] short wStreamNumber, + out IWMMediaProps ppOutput + ); + + void SetPostViewProps( + [In] short wStreamNumber, + [In] IWMMediaProps pOutput + ); + + void GetPostViewFormatCount( + [In] short wStreamNumber, + out int pcFormats + ); + + void GetPostViewFormat( + [In] short wStreamNumber, + [In] int dwFormatNumber, + out IWMMediaProps ppProps + ); + + void SetAllocateForPostView( + [In] short wStreamNumber, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + void GetAllocateForPostView( + [In] short wStreamNumber, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("D9D6549D-A193-4F24-B308-03123D9B7F8D"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriterPostViewCallback : IWMStatusCallback + { + #region IWMStatusCallback Methods + + new void OnStatus( + [In] Status iStatus, + [In] int hr, + [In] AttrDataType dwType, + [In] IntPtr pValue, + [In] IntPtr pvContext + ); + + #endregion + + void OnPostViewSample( + [In] short wStreamNumber, + [In] long cnsSampleTime, + [In] long cnsSampleDuration, + [In] SampleFlag dwFlags, + [In] INSSBuffer pSample, + [In] IntPtr pvContext + ); + + void AllocateForPostView( + [In] short wStreamNum, + [In] int cbBuffer, + out INSSBuffer ppBuffer, + [In] IntPtr pvContext + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("FC54A285-38C4-45B5-AA23-85B9F7CB424B"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriterPreprocess + { + void GetMaxPreprocessingPasses( + [In] int dwInputNum, + [In] int dwFlags, + out int pdwMaxNumPasses + ); + + void SetNumPreprocessingPasses( + [In] int dwInputNum, + [In] int dwFlags, + [In] int dwNumPasses + ); + + void BeginPreprocessingPass( + [In] int dwInputNum, + [In] int dwFlags + ); + + void PreprocessSample( + [In] int dwInputNum, + [In] long cnsSampleTime, + [In] int dwFlags, + [In] INSSBuffer pSample + ); + + void EndPreprocessingPass( + [In] int dwInputNum, + [In] int dwFlags + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("DC10E6A5-072C-467D-BF57-6330A9DDE12A"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriterPushSink : IWMWriterSink + { + #region IWMWriterSink Methods + + new void OnHeader( + [In] INSSBuffer pHeader + ); + + new void IsRealTime( + [MarshalAs(UnmanagedType.Bool)] out bool pfRealTime + ); + + new void AllocateDataUnit( + [In] int cbDataUnit, + out INSSBuffer ppDataUnit + ); + + new void OnDataUnit( + [In] INSSBuffer pDataUnit + ); + + new void OnEndWriting(); + + #endregion + + void Connect( + [In] string pwszURL, + [In] string pwszTemplateURL, + [In, MarshalAs(UnmanagedType.Bool)] bool fAutoDestroy + ); + + void Disconnect(); + + void EndSession(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("96406BE4-2B2B-11D3-B36B-00C04F6108FF"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMWriterSink + { + void OnHeader( + [In] INSSBuffer pHeader + ); + + void IsRealTime( + [MarshalAs(UnmanagedType.Bool)] out bool pfRealTime + ); + + void AllocateDataUnit( + [In] int cbDataUnit, + out INSSBuffer ppDataUnit + ); + + void OnDataUnit( + [In] INSSBuffer pDataUnit + ); + + void OnEndWriting(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("0C0E4080-9081-11D2-BEEC-0060082F2054"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface INSNetSourceCreator + { + void Initialize(); + + void CreateNetSource( + [In] string pszStreamName, + [In, MarshalAs(UnmanagedType.IUnknown)] object pMonitor, + [In] byte[] pData, + [In, MarshalAs(UnmanagedType.IUnknown)] object pUserContext, + [In, MarshalAs(UnmanagedType.IUnknown)] object pCallback, + [In] long qwContext + ); + + void GetNetSourceProperties( + [In] string pszStreamName, + [MarshalAs(UnmanagedType.IUnknown)] out object ppPropertiesNode + ); + + void GetNetSourceSharedNamespace( + [MarshalAs(UnmanagedType.IUnknown)] out object ppSharedNamespace + ); + + void GetNetSourceAdminInterface( + [In] string pszStreamName, + [MarshalAs(UnmanagedType.Struct)] out object pVal + ); + + void GetNumProtocolsSupported( + out int pcProtocols + ); + + void GetProtocolName( + [In] int dwProtocolNum, + [Out] StringBuilder pwszProtocolName, + ref short pcchProtocolName + ); + + void Shutdown(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("4F528693-1035-43FE-B428-757561AD3A68"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface INSSBuffer2 : INSSBuffer + { + #region INSSBuffer Methods + + new void GetLength( + out int pdwLength + ); + + new void SetLength( + [In] int dwLength + ); + + new void GetMaxLength( + out int pdwLength + ); + + new void GetBuffer( + out IntPtr ppdwBuffer + ); + + new void GetBufferAndLength( + out IntPtr ppdwBuffer, + out int pdwLength + ); + + #endregion + + void GetSampleProperties( + [In] int cbProperties, + out byte[] pbProperties + ); + + void SetSampleProperties( + [In] int cbProperties, + [In] byte[] pbProperties + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("C87CEAAF-75BE-4BC4-84EB-AC2798507672"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface INSSBuffer3 : INSSBuffer2 + { + #region INSSBuffer Methods + + new void GetLength( + out int pdwLength + ); + + new void SetLength( + [In] int dwLength + ); + + new void GetMaxLength( + out int pdwLength + ); + + new void GetBuffer( + out IntPtr ppdwBuffer + ); + + new void GetBufferAndLength( + out IntPtr ppdwBuffer, + out int pdwLength + ); + + #endregion + + #region INSSBuffer2 Methods + + new void GetSampleProperties( + [In] int cbProperties, + out byte[] pbProperties + ); + + new void SetSampleProperties( + [In] int cbProperties, + [In] byte[] pbProperties + ); + + #endregion + + void SetProperty( + [In] Guid WM_SampleExtensionGUID, + [In] IntPtr pvBufferProperty, + [In] int dwBufferPropertySize + ); + + void GetProperty( + [In] Guid WM_SampleExtensionGUID, + [Out] IntPtr pvBufferProperty, + ref int pdwBufferPropertySize + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("B6B8FD5A-32E2-49D4-A910-C26CC85465ED"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface INSSBuffer4 : INSSBuffer3 + { + #region INSSBuffer Methods + + new void GetLength( + out int pdwLength + ); + + new void SetLength( + [In] int dwLength + ); + + new void GetMaxLength( + out int pdwLength + ); + + new void GetBuffer( + out IntPtr ppdwBuffer + ); + + new void GetBufferAndLength( + out IntPtr ppdwBuffer, + out int pdwLength + ); + + #endregion + + #region INSSBuffer2 Methods + + new void GetSampleProperties( + [In] int cbProperties, + out byte[] pbProperties + ); + + new void SetSampleProperties( + [In] int cbProperties, + [In] byte[] pbProperties + ); + + #endregion + + #region INSSBuffer3 Methods + + new void SetProperty( + [In] Guid guidBufferProperty, + [In] IntPtr pvBufferProperty, + [In] int dwBufferPropertySize + ); + + new void GetProperty( + [In] Guid guidBufferProperty, + [Out] IntPtr pvBufferProperty, + ref int pdwBufferPropertySize + ); + + #endregion + + void GetPropertyCount( + out int pcBufferProperties + ); + + void GetPropertyByIndex( + [In] int dwBufferPropertyIndex, + out Guid pguidBufferProperty, + [Out] IntPtr pvBufferProperty, + ref int pdwBufferPropertySize + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("8BB23E5F-D127-4AFB-8D02-AE5B66D54C78"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMSInternalAdminNetSource + { + void Initialize( + [In, MarshalAs(UnmanagedType.IUnknown)] object pSharedNamespace, + [In, MarshalAs(UnmanagedType.IUnknown)] object pNamespaceNode, + [In] INSNetSourceCreator pNetSourceCreator, + [In] int fEmbeddedInServer + ); + + void GetNetSourceCreator( + out INSNetSourceCreator ppNetSourceCreator + ); + + void SetCredentials( + [In, MarshalAs(UnmanagedType.BStr)] string bstrRealm, + [In, MarshalAs(UnmanagedType.BStr)] string bstrName, + [In, MarshalAs(UnmanagedType.BStr)] string bstrPassword, + [In, MarshalAs(UnmanagedType.Bool)] bool fPersist, + [In, MarshalAs(UnmanagedType.Bool)] bool fConfirmedGood + ); + + void GetCredentials( + [In, MarshalAs(UnmanagedType.BStr)] string bstrRealm, + [MarshalAs(UnmanagedType.BStr)] out string pbstrName, + [MarshalAs(UnmanagedType.BStr)] out string pbstrPassword, + [MarshalAs(UnmanagedType.Bool)] out bool pfConfirmedGood + ); + + void DeleteCredentials( + [In, MarshalAs(UnmanagedType.BStr)] string bstrRealm + ); + + void GetCredentialFlags( + out CredentialFlag lpdwFlags + ); + + void SetCredentialFlags( + [In] CredentialFlag dwFlags + ); + + [PreserveSig] + int FindProxyForURL( + [In, MarshalAs(UnmanagedType.BStr)] string bstrProtocol, + [In, MarshalAs(UnmanagedType.BStr)] string bstrHost, + [MarshalAs(UnmanagedType.Bool)] out bool pfProxyEnabled, + [MarshalAs(UnmanagedType.BStr)] out string pbstrProxyServer, + out int pdwProxyPort, + ref int pdwProxyContext + ); + + void RegisterProxyFailure( + [In] int hrParam, + [In] int dwProxyContext + ); + + void ShutdownProxyContext( + [In] int dwProxyContext + ); + + void IsUsingIE( + [In] int dwProxyContext, + [MarshalAs(UnmanagedType.Bool)] out bool pfIsUsingIE + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("E74D58C3-CF77-4B51-AF17-744687C43EAE"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMSInternalAdminNetSource2 + { + void SetCredentialsEx( + [In, MarshalAs(UnmanagedType.BStr)] string bstrRealm, + [In, MarshalAs(UnmanagedType.BStr)] string bstrUrl, + [In, MarshalAs(UnmanagedType.Bool)] bool fProxy, + [In, MarshalAs(UnmanagedType.BStr)] string bstrName, + [In, MarshalAs(UnmanagedType.BStr)] string bstrPassword, + [In, MarshalAs(UnmanagedType.Bool)] bool fPersist, + [In, MarshalAs(UnmanagedType.Bool)] bool fConfirmedGood + ); + + void GetCredentialsEx( + [In, MarshalAs(UnmanagedType.BStr)] string bstrRealm, + [In, MarshalAs(UnmanagedType.BStr)] string bstrUrl, + [In, MarshalAs(UnmanagedType.Bool)] bool fProxy, + out NetSourceURLCredPolicySettings pdwUrlPolicy, + [MarshalAs(UnmanagedType.BStr)] out string pbstrName, + [MarshalAs(UnmanagedType.BStr)] out string pbstrPassword, + [MarshalAs(UnmanagedType.Bool)] out bool pfConfirmedGood + ); + + void DeleteCredentialsEx( + [In, MarshalAs(UnmanagedType.BStr)] string bstrRealm, + [In, MarshalAs(UnmanagedType.BStr)] string bstrUrl, + [In, MarshalAs(UnmanagedType.Bool)] bool fProxy + ); + + void FindProxyForURLEx( + [In, MarshalAs(UnmanagedType.BStr)] string bstrProtocol, + [In, MarshalAs(UnmanagedType.BStr)] string bstrHost, + [In, MarshalAs(UnmanagedType.BStr)] string bstrUrl, + [MarshalAs(UnmanagedType.Bool)] out bool pfProxyEnabled, + [MarshalAs(UnmanagedType.BStr)] out string pbstrProxyServer, + out int pdwProxyPort, + ref int pdwProxyContext + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("6B63D08E-4590-44AF-9EB3-57FF1E73BF80"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMSInternalAdminNetSource3 : IWMSInternalAdminNetSource2 + { + #region IWMSInternalAdminNetSource2 Methods + + new void SetCredentialsEx( + [In, MarshalAs(UnmanagedType.BStr)] string bstrRealm, + [In, MarshalAs(UnmanagedType.BStr)] string bstrUrl, + [In, MarshalAs(UnmanagedType.Bool)] bool fProxy, + [In, MarshalAs(UnmanagedType.BStr)] string bstrName, + [In, MarshalAs(UnmanagedType.BStr)] string bstrPassword, + [In, MarshalAs(UnmanagedType.Bool)] bool fPersist, + [In, MarshalAs(UnmanagedType.Bool)] bool fConfirmedGood + ); + + new void GetCredentialsEx( + [In, MarshalAs(UnmanagedType.BStr)] string bstrRealm, + [In, MarshalAs(UnmanagedType.BStr)] string bstrUrl, + [In, MarshalAs(UnmanagedType.Bool)] bool fProxy, + out NetSourceURLCredPolicySettings pdwUrlPolicy, + [MarshalAs(UnmanagedType.BStr)] out string pbstrName, + [MarshalAs(UnmanagedType.BStr)] out string pbstrPassword, + [MarshalAs(UnmanagedType.Bool)] out bool pfConfirmedGood + ); + + new void DeleteCredentialsEx( + [In, MarshalAs(UnmanagedType.BStr)] string bstrRealm, + [In, MarshalAs(UnmanagedType.BStr)] string bstrUrl, + [In, MarshalAs(UnmanagedType.Bool)] bool fProxy + ); + + new void FindProxyForURLEx( + [In, MarshalAs(UnmanagedType.BStr)] string bstrProtocol, + [In, MarshalAs(UnmanagedType.BStr)] string bstrHost, + [In, MarshalAs(UnmanagedType.BStr)] string bstrUrl, + [MarshalAs(UnmanagedType.Bool)] out bool pfProxyEnabled, + [MarshalAs(UnmanagedType.BStr)] out string pbstrProxyServer, + out int pdwProxyPort, + ref int pdwProxyContext + ); + + #endregion + + void GetNetSourceCreator2( + [MarshalAs(UnmanagedType.IUnknown)] out object ppNetSourceCreator + ); + + [PreserveSig] + int FindProxyForURLEx2( + [In, MarshalAs(UnmanagedType.BStr)] string bstrProtocol, + [In, MarshalAs(UnmanagedType.BStr)] string bstrHost, + [In, MarshalAs(UnmanagedType.BStr)] string bstrUrl, + [MarshalAs(UnmanagedType.Bool)] out bool pfProxyEnabled, + [MarshalAs(UnmanagedType.BStr)] out string pbstrProxyServer, + out int pdwProxyPort, + ref long pqwProxyContext + ); + + void RegisterProxyFailure2( + [In] int hrParam, + [In] long qwProxyContext + ); + + void ShutdownProxyContext2( + [In] long qwProxyContext + ); + + void IsUsingIE2( + [In] long qwProxyContext, + [MarshalAs(UnmanagedType.Bool)] out bool pfIsUsingIE + ); + + void SetCredentialsEx2( + [In, MarshalAs(UnmanagedType.BStr)] string bstrRealm, + [In, MarshalAs(UnmanagedType.BStr)] string bstrUrl, + [In, MarshalAs(UnmanagedType.Bool)] bool fProxy, + [In, MarshalAs(UnmanagedType.BStr)] string bstrName, + [In, MarshalAs(UnmanagedType.BStr)] string bstrPassword, + [In, MarshalAs(UnmanagedType.Bool)] bool fPersist, + [In, MarshalAs(UnmanagedType.Bool)] bool fConfirmedGood, + [In, MarshalAs(UnmanagedType.Bool)] bool fClearTextAuthentication + ); + + void GetCredentialsEx2( + [In, MarshalAs(UnmanagedType.BStr)] string bstrRealm, + [In, MarshalAs(UnmanagedType.BStr)] string bstrUrl, + [In, MarshalAs(UnmanagedType.Bool)] bool fProxy, + [In, MarshalAs(UnmanagedType.Bool)] bool fClearTextAuthentication, + out NetSourceURLCredPolicySettings pdwUrlPolicy, + [MarshalAs(UnmanagedType.BStr)] out string pbstrName, + [MarshalAs(UnmanagedType.BStr)] out string pbstrPassword, + [MarshalAs(UnmanagedType.Bool)] out bool pfConfirmedGood + ); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("e5b7ca9a-0f1c-4f66-9002-74ec50d8b304"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMPlayerHook + { + void PreDecode(); + } + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("24C44DB0-55D1-49ae-A5CC-F13815E36363"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderAdvanced5 : IWMReaderAdvanced4 + { + #region IWMReaderAdvanced Methods + + new void SetUserProvidedClock( + [In, MarshalAs(UnmanagedType.Bool)] bool fUserClock + ); + + new void GetUserProvidedClock( + [MarshalAs(UnmanagedType.Bool)] out bool pfUserClock + ); + + new void DeliverTime( + [In] long cnsTime + ); + + new void SetManualStreamSelection( + [In, MarshalAs(UnmanagedType.Bool)] bool fSelection + ); + + new void GetManualStreamSelection( + [MarshalAs(UnmanagedType.Bool)] out bool pfSelection + ); + + new void SetStreamsSelected( + [In] short cStreamCount, + [In] short[] pwStreamNumbers, + [In] StreamSelection[] pSelections + ); + + new void GetStreamSelected( + [In] short wStreamNum, + out StreamSelection pSelection + ); + + new void SetReceiveSelectionCallbacks( + [In, MarshalAs(UnmanagedType.Bool)] bool fGetCallbacks + ); + + new void GetReceiveSelectionCallbacks( + [MarshalAs(UnmanagedType.Bool)] out bool pfGetCallbacks + ); + + new void SetReceiveStreamSamples( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fReceiveStreamSamples + ); + + new void GetReceiveStreamSamples( + [In] short wStreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfReceiveStreamSamples + ); + + new void SetAllocateForOutput( + [In] int dwOutputNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + new void GetAllocateForOutput( + [In] int dwOutputNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + + new void SetAllocateForStream( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.Bool)] bool fAllocate + ); + + new void GetAllocateForStream( + [In] short dwSreamNum, + [MarshalAs(UnmanagedType.Bool)] out bool pfAllocate + ); + + new void GetStatistics( + [In, Out, MarshalAs(UnmanagedType.LPStruct)] WMReaderStatistics pStatistics + ); + + new void SetClientInfo( + [In, MarshalAs(UnmanagedType.LPStruct)] WMReaderClientInfo pClientInfo + ); + + new void GetMaxOutputSampleSize( + [In] int dwOutput, + out int pcbMax + ); + + new void GetMaxStreamSampleSize( + [In] short wStream, + out int pcbMax + ); + + new void NotifyLateDelivery( + long cnsLateness + ); + + #endregion + + #region IWMReaderAdvanced2 Methods + + new void SetPlayMode( + [In] PlayMode Mode + ); + + new void GetPlayMode( + out PlayMode pMode + ); + + new void GetBufferProgress( + out int pdwPercent, + out long pcnsBuffering + ); + + new void GetDownloadProgress( + out int pdwPercent, + out long pqwBytesDownloaded, + out long pcnsDownload + ); + + new void GetSaveAsProgress( + out int pdwPercent + ); + + new void SaveFileAs( + [In] string pwszFilename + ); + + new void GetProtocolName( + [Out] StringBuilder pwszProtocol, + ref int pcchProtocol + ); + + new void StartAtMarker( + [In] short wMarkerIndex, + [In] long cnsDuration, + [In] float fRate, + [In] IntPtr pvContext + ); + + new void GetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + out AttrDataType pType, + [Out, MarshalAs(UnmanagedType.LPArray)] byte[] pValue, + ref short pcbLength + ); + + new void SetOutputSetting( + [In] int dwOutputNum, + [In] string pszName, + [In] AttrDataType Type, + [In] byte[] pValue, + [In] short cbLength + ); + + new void Preroll( + [In] long cnsStart, + [In] long cnsDuration, + [In] float fRate + ); + + new void SetLogClientID( + [In, MarshalAs(UnmanagedType.Bool)] bool fLogClientID + ); + + new void GetLogClientID( + [MarshalAs(UnmanagedType.Bool)] out bool pfLogClientID + ); + + new void StopBuffering(); + + new void OpenStream( + [In] IStream pStream, + [In] IWMReaderCallback pCallback, + [In] IntPtr pvContext + ); + + #endregion + + #region IWMReaderAdvanced3 Methods + + new void StopNetStreaming(); + + new void StartAtPosition( + [In] short wStreamNum, + [In, MarshalAs(UnmanagedType.LPStruct)] RA3Union pvOffsetStart, + [In, MarshalAs(UnmanagedType.LPStruct)] RA3Union pvDuration, + [In] OffsetFormat dwOffsetFormat, + [In] float fRate, + [In] IntPtr pvContext + ); + + #endregion + + #region IWMReaderAdvanced4 Methods + + new void GetLanguageCount( + [In] int dwOutputNum, + out short pwLanguageCount + ); + + new void GetLanguage( + [In] int dwOutputNum, + [In] short wLanguage, + [Out] StringBuilder pwszLanguageString, + ref short pcchLanguageStringLength + ); + + new void GetMaxSpeedFactor( + out double pdblFactor + ); + + new void IsUsingFastCache( + [MarshalAs(UnmanagedType.Bool)] out bool pfUsingFastCache + ); + + new void AddLogParam( + [In] string wszNameSpace, + [In] string wszName, + [In] string wszValue + ); + + new void SendLogParams(); + + new void CanSaveFileAs( + [MarshalAs(UnmanagedType.Bool)] out bool pfCanSave + ); + + new void CancelSaveFileAs(); + + new void GetURL( + [Out] StringBuilder pwszURL, + ref int pcchURL + ); + + #endregion + + void SetPlayerHook( + int dwOutputNum, + IWMPlayerHook pHook); + }; + + [ComImport, SuppressUnmanagedCodeSecurity, + Guid("f28c0300-9baa-4477-a846-1744d9cbf533"), + InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] + public interface IWMReaderPlaylistBurn + { + void InitPlaylistBurn( + int cFiles, + [In, MarshalAs(UnmanagedType.LPArray, ArraySubType=UnmanagedType.LPWStr)] string[] ppwszFilenames, + IWMStatusCallback pCallback, + IntPtr pvContext); + + void GetInitResults( + int cFiles, + [Out, MarshalAs(UnmanagedType.LPArray)] int[] phrStati); + + void Cancel(); + + void EndPlaylistBurn( + int hrBurnResult); + }; + + #endregion +} diff --git a/WindowsMediaLib/WMDefs.cs b/WindowsMediaLib/WMDefs.cs new file mode 100644 index 0000000..971d356 --- /dev/null +++ b/WindowsMediaLib/WMDefs.cs @@ -0,0 +1,795 @@ +#region license + +/* +WindowsMediaLib - Provide access to Windows Media interfaces via .NET +Copyright (C) 2008 +http://sourceforge.net/projects/windowsmedianet + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#endregion + +// The definitions in this namespace duplicate ones found in DirectShowLib. +// To avoid ambiguous references when using both libs, do NOT use +// "using WindowsMediaLib.Defs;" + +using System; +using System.Drawing; +using System.Runtime.InteropServices; +using System.Reflection; + +namespace WindowsMediaLib.Defs +{ + public static class MediaType + { + public static readonly Guid Null = Guid.Empty; + + /// MEDIATYPE_Video 'vids' + public static readonly Guid Video = new Guid(0x73646976, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIATYPE_Interleaved 'iavs' + public static readonly Guid Interleaved = new Guid(0x73766169, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIATYPE_Audio 'auds' + public static readonly Guid Audio = new Guid(0x73647561, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIATYPE_Text 'txts' + public static readonly Guid Texts = new Guid(0x73747874, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIATYPE_Stream + public static readonly Guid Stream = new Guid(0xe436eb83, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIATYPE_VBI + public static readonly Guid VBI = new Guid(0xf72a76e1, 0xeb0a, 0x11d0, 0xac, 0xe4, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba); + + /// MEDIATYPE_Midi + public static readonly Guid Midi = new Guid(0x7364696D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIATYPE_File + public static readonly Guid File = new Guid(0x656c6966, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIATYPE_ScriptCommand + public static readonly Guid ScriptCommand = new Guid(0x73636d64, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIATYPE_AUXLine21Data + public static readonly Guid AuxLine21Data = new Guid(0x670aea80, 0x3a82, 0x11d0, 0xb7, 0x9b, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7); + + /// MEDIATYPE_Timecode + public static readonly Guid Timecode = new Guid(0x0482dee3, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIATYPE_LMRT + public static readonly Guid LMRT = new Guid(0x74726c6d, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIATYPE_URL_STREAM + public static readonly Guid URLStream = new Guid(0x736c7275, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIATYPE_AnalogVideo + public static readonly Guid AnalogVideo = new Guid(0x0482dde1, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIATYPE_AnalogAudio + public static readonly Guid AnalogAudio = new Guid(0x0482dee1, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIATYPE_MPEG2_SECTIONS + public static readonly Guid Mpeg2Sections = new Guid(0x455f176c, 0x4b06, 0x47ce, 0x9a, 0xef, 0x8c, 0xae, 0xf7, 0x3d, 0xf7, 0xb5); + + /// MEDIATYPE_DTVCCData + public static readonly Guid DTVCCData = new Guid(0xfb77e152, 0x53b2, 0x499c, 0xb4, 0x6b, 0x50, 0x9f, 0xc3, 0x3e, 0xdf, 0xd7); + + /// MEDIATYPE_MSTVCaption + public static readonly Guid MSTVCaption = new Guid(0xB88B8A89, 0xB049, 0x4C80, 0xAD, 0xCF, 0x58, 0x98, 0x98, 0x5E, 0x22, 0xC1); + + /// WMMEDIATYPE_Image 'imag' + public static readonly Guid Image = new Guid(0x34a50fd8, 0x8aa5, 0x4386, 0x81, 0xfe, 0xa0, 0xef, 0xe0, 0x48, 0x8e, 0x31); + + /// WMMEDIATYPE_FileTransfer 'fxfr' + public static readonly Guid FileTransfer = new Guid(0xd9e47579, 0x930e, 0x4427, 0xad, 0xfc, 0xad, 0x80, 0xf2, 0x90, 0xe4, 0x70); + + /// WMMEDIATYPE_Text 'text' + public static readonly Guid Text = new Guid(0x9bba1ea7, 0x5ab2, 0x4829, 0xba, 0x57, 0x9, 0x40, 0x20, 0x9b, 0xcf, 0x3e); + } + + public static class MediaSubType + { + public static readonly Guid Null = Guid.Empty; + + /// MEDIASUBTYPE_CLPL + public static readonly Guid CLPL = new Guid(0x4C504C43, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_YUYV + public static readonly Guid YUYV = new Guid(0x56595559, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_IYUV + public static readonly Guid IYUV = new Guid(0x56555949, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_YVU9 + public static readonly Guid YVU9 = new Guid(0x39555659, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_Y411 + public static readonly Guid Y411 = new Guid(0x31313459, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_Y41P + public static readonly Guid Y41P = new Guid(0x50313459, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_YUY2 + public static readonly Guid YUY2 = new Guid(0x32595559, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_YVYU + public static readonly Guid YVYU = new Guid(0x55595659, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_UYVY + public static readonly Guid UYVY = new Guid(0x59565955, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_Y211 + public static readonly Guid Y211 = new Guid(0x31313259, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_CLJR + public static readonly Guid CLJR = new Guid(0x524a4c43, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_IF09 + public static readonly Guid IF09 = new Guid(0x39304649, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_CPLA + public static readonly Guid CPLA = new Guid(0x414c5043, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_MJPG + public static readonly Guid MJPG = new Guid(0x47504A4D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_TVMJ + public static readonly Guid TVMJ = new Guid(0x4A4D5654, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_WAKE + public static readonly Guid WAKE = new Guid(0x454B4157, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_CFCC + public static readonly Guid CFCC = new Guid(0x43434643, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_IJPG + public static readonly Guid IJPG = new Guid(0x47504A49, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_Plum + public static readonly Guid PLUM = new Guid(0x6D756C50, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_DVCS + public static readonly Guid DVCS = new Guid(0x53435644, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_DVSD + public static readonly Guid DVSD = new Guid(0x44535644, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_MDVF + public static readonly Guid MDVF = new Guid(0x4656444D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_RGB1 + public static readonly Guid RGB1 = new Guid(0xe436eb78, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_RGB4 + public static readonly Guid RGB4 = new Guid(0xe436eb79, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_RGB8 + public static readonly Guid RGB8 = new Guid(0xe436eb7a, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_RGB565 + public static readonly Guid RGB565 = new Guid(0xe436eb7b, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_RGB555 + public static readonly Guid RGB555 = new Guid(0xe436eb7c, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_RGB24 + public static readonly Guid RGB24 = new Guid(0xe436eb7d, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_RGB32 + public static readonly Guid RGB32 = new Guid(0xe436eb7e, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_ARGB1555 + public static readonly Guid ARGB1555 = new Guid(0x297c55af, 0xe209, 0x4cb3, 0xb7, 0x57, 0xc7, 0x6d, 0x6b, 0x9c, 0x88, 0xa8); + + /// MEDIASUBTYPE_ARGB4444 + public static readonly Guid ARGB4444 = new Guid(0x6e6415e6, 0x5c24, 0x425f, 0x93, 0xcd, 0x80, 0x10, 0x2b, 0x3d, 0x1c, 0xca); + + /// MEDIASUBTYPE_ARGB32 + public static readonly Guid ARGB32 = new Guid(0x773c9ac0, 0x3274, 0x11d0, 0xb7, 0x24, 0x00, 0xaa, 0x00, 0x6c, 0x1a, 0x01); + + /// MEDIASUBTYPE_A2R10G10B10 + public static readonly Guid A2R10G10B10 = new Guid(0x2f8bb76d, 0xb644, 0x4550, 0xac, 0xf3, 0xd3, 0x0c, 0xaa, 0x65, 0xd5, 0xc5); + + /// MEDIASUBTYPE_A2B10G10R10 + public static readonly Guid A2B10G10R10 = new Guid(0x576f7893, 0xbdf6, 0x48c4, 0x87, 0x5f, 0xae, 0x7b, 0x81, 0x83, 0x45, 0x67); + + /// MEDIASUBTYPE_AYUV + public static readonly Guid AYUV = new Guid(0x56555941, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_AI44 + public static readonly Guid AI44 = new Guid(0x34344941, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_IA44 + public static readonly Guid IA44 = new Guid(0x34344149, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_RGB32_D3D_DX7_RT + public static readonly Guid RGB32_D3D_DX7_RT = new Guid(0x32335237, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_RGB16_D3D_DX7_RT + public static readonly Guid RGB16_D3D_DX7_RT = new Guid(0x36315237, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_ARGB32_D3D_DX7_RT + public static readonly Guid ARGB32_D3D_DX7_RT = new Guid(0x38384137, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_ARGB4444_D3D_DX7_RT + public static readonly Guid ARGB4444_D3D_DX7_RT = new Guid(0x34344137, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_ARGB1555_D3D_DX7_RT + public static readonly Guid ARGB1555_D3D_DX7_RT = new Guid(0x35314137, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_RGB32_D3D_DX9_RT + public static readonly Guid RGB32_D3D_DX9_RT = new Guid(0x32335239, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_RGB16_D3D_DX9_RT + public static readonly Guid RGB16_D3D_DX9_RT = new Guid(0x36315239, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_ARGB32_D3D_DX9_RT + public static readonly Guid ARGB32_D3D_DX9_RT = new Guid(0x38384139, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_ARGB4444_D3D_DX9_RT + public static readonly Guid ARGB4444_D3D_DX9_RT = new Guid(0x34344139, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_ARGB1555_D3D_DX9_RT + public static readonly Guid ARGB1555_D3D_DX9_RT = new Guid(0x35314139, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_YV12 + public static readonly Guid YV12 = new Guid(0x32315659, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_NV12 + public static readonly Guid NV12 = new Guid(0x3231564E, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_IMC1 + public static readonly Guid IMC1 = new Guid(0x31434D49, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_IMC2 + public static readonly Guid IMC2 = new Guid(0x32434D49, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_IMC3 + public static readonly Guid IMC3 = new Guid(0x33434D49, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_IMC4 + public static readonly Guid IMC4 = new Guid(0x34434D49, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_S340 + public static readonly Guid S340 = new Guid(0x30343353, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_S342 + public static readonly Guid S342 = new Guid(0x32343353, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_Overlay + public static readonly Guid Overlay = new Guid(0xe436eb7f, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_MPEG1Packet + public static readonly Guid MPEG1Packet = new Guid(0xe436eb80, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_MPEG1Payload + public static readonly Guid MPEG1Payload = new Guid(0xe436eb81, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_MPEG1AudioPayload + public static readonly Guid MPEG1AudioPayload = new Guid(0x00000050, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// MEDIATYPE_MPEG1SystemStream + public static readonly Guid MPEG1SystemStream = new Guid(0xe436eb82, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_MPEG1System + public static readonly Guid MPEG1System = new Guid(0xe436eb84, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_MPEG1VideoCD + public static readonly Guid MPEG1VideoCD = new Guid(0xe436eb85, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_MPEG1Video + public static readonly Guid MPEG1Video = new Guid(0xe436eb86, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_MPEG1Audio + public static readonly Guid MPEG1Audio = new Guid(0xe436eb87, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_Avi + public static readonly Guid Avi = new Guid(0xe436eb88, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_Asf + public static readonly Guid Asf = new Guid(0x3db80f90, 0x9412, 0x11d1, 0xad, 0xed, 0x00, 0x00, 0xf8, 0x75, 0x4b, 0x99); + + /// MEDIASUBTYPE_QTMovie + public static readonly Guid QTMovie = new Guid(0xe436eb89, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_QTRpza + public static readonly Guid QTRpza = new Guid(0x617a7072, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_QTSmc + public static readonly Guid QTSmc = new Guid(0x20636d73, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_QTRle + public static readonly Guid QTRle = new Guid(0x20656c72, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_QTJpeg + public static readonly Guid QTJpeg = new Guid(0x6765706a, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_PCMAudio_Obsolete + public static readonly Guid PCMAudio_Obsolete = new Guid(0xe436eb8a, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_PCM + public static readonly Guid PCM = new Guid(0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// MEDIASUBTYPE_WAVE + public static readonly Guid WAVE = new Guid(0xe436eb8b, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_AU + public static readonly Guid AU = new Guid(0xe436eb8c, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_AIFF + public static readonly Guid AIFF = new Guid(0xe436eb8d, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_dvhd + public static readonly Guid dvhd = new Guid(0x64687664, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_dvsl + public static readonly Guid dvsl = new Guid(0x6c737664, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_dv25 + public static readonly Guid dv25 = new Guid(0x35327664, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_dv50 + public static readonly Guid dv50 = new Guid(0x30357664, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_dvh1 + public static readonly Guid dvh1 = new Guid(0x31687664, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_Line21_BytePair + public static readonly Guid Line21_BytePair = new Guid(0x6e8d4a22, 0x310c, 0x11d0, 0xb7, 0x9a, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7); + + /// MEDIASUBTYPE_Line21_GOPPacket + public static readonly Guid Line21_GOPPacket = new Guid(0x6e8d4a23, 0x310c, 0x11d0, 0xb7, 0x9a, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7); + + /// MEDIASUBTYPE_Line21_VBIRawData + public static readonly Guid Line21_VBIRawData = new Guid(0x6e8d4a24, 0x310c, 0x11d0, 0xb7, 0x9a, 0x00, 0xaa, 0x00, 0x37, 0x67, 0xa7); + + /// MEDIASUBTYPE_TELETEXT + public static readonly Guid TELETEXT = new Guid(0xf72a76e3, 0xeb0a, 0x11d0, 0xac, 0xe4, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba); + + /// MEDIASUBTYPE_WSS + public static readonly Guid WSS = new Guid(0x2791D576, 0x8E7A, 0x466F, 0x9E, 0x90, 0x5D, 0x3F, 0x30, 0x83, 0x73, 0x8B); + + /// MEDIASUBTYPE_VPS + public static readonly Guid VPS = new Guid(0xa1b3f620, 0x9792, 0x4d8d, 0x81, 0xa4, 0x86, 0xaf, 0x25, 0x77, 0x20, 0x90); + + /// MEDIASUBTYPE_DRM_Audio + public static readonly Guid DRM_Audio = new Guid(0x00000009, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_IEEE_FLOAT + public static readonly Guid IEEE_FLOAT = new Guid(0x00000003, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_DOLBY_AC3_SPDIF + public static readonly Guid DOLBY_AC3_SPDIF = new Guid(0x00000092, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_RAW_SPORT + public static readonly Guid RAW_SPORT = new Guid(0x00000240, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_SPDIF_TAG_241h + public static readonly Guid SPDIF_TAG_241h = new Guid(0x00000241, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_DssVideo + public static readonly Guid DssVideo = new Guid(0xa0af4f81, 0xe163, 0x11d0, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a); + + /// MEDIASUBTYPE_DssAudio + public static readonly Guid DssAudio = new Guid(0xa0af4f82, 0xe163, 0x11d0, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a); + + /// MEDIASUBTYPE_VPVideo + public static readonly Guid VPVideo = new Guid(0x5a9b6a40, 0x1a22, 0x11d1, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a); + + /// MEDIASUBTYPE_VPVBI + public static readonly Guid VPVBI = new Guid(0x5a9b6a41, 0x1a22, 0x11d1, 0xba, 0xd9, 0x00, 0x60, 0x97, 0x44, 0x11, 0x1a); + + /// MEDIASUBTYPE_AnalogVideo_NTSC_M + public static readonly Guid AnalogVideo_NTSC_M = new Guid(0x0482dde2, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_PAL_B + public static readonly Guid AnalogVideo_PAL_B = new Guid(0x0482dde5, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_PAL_D + public static readonly Guid AnalogVideo_PAL_D = new Guid(0x0482dde6, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_PAL_G + public static readonly Guid AnalogVideo_PAL_G = new Guid(0x0482dde7, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_PAL_H + public static readonly Guid AnalogVideo_PAL_H = new Guid(0x0482dde8, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_PAL_I + public static readonly Guid AnalogVideo_PAL_I = new Guid(0x0482dde9, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_PAL_M + public static readonly Guid AnalogVideo_PAL_M = new Guid(0x0482ddea, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_PAL_N + public static readonly Guid AnalogVideo_PAL_N = new Guid(0x0482ddeb, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_PAL_N_COMBO + public static readonly Guid AnalogVideo_PAL_N_COMBO = new Guid(0x0482ddec, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_SECAM_B + public static readonly Guid AnalogVideo_SECAM_B = new Guid(0x0482ddf0, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_SECAM_D + public static readonly Guid AnalogVideo_SECAM_D = new Guid(0x0482ddf1, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_SECAM_G + public static readonly Guid AnalogVideo_SECAM_G = new Guid(0x0482ddf2, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_SECAM_H + public static readonly Guid AnalogVideo_SECAM_H = new Guid(0x0482ddf3, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_SECAM_K + public static readonly Guid AnalogVideo_SECAM_K = new Guid(0x0482ddf4, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_SECAM_K1 + public static readonly Guid AnalogVideo_SECAM_K1 = new Guid(0x0482ddf5, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_AnalogVideo_SECAM_L + public static readonly Guid AnalogVideo_SECAM_L = new Guid(0x0482ddf6, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// MEDIASUBTYPE_I420 + public static readonly Guid I420 = new Guid(0x30323449, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// WMMEDIASUBTYPE_VIDEOIMAGE + public static readonly Guid VideoImage = new Guid(0x1d4a45f2, 0xe5f6, 0x4b44, 0x83, 0x88, 0xf0, 0xae, 0x5c, 0x0e, 0x0c, 0x37); + + /// WMMEDIASUBTYPE_MPEG2_VIDEO + public static readonly Guid Mpeg2Video = new Guid(0xe06d8026, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea); + + /// WMMEDIASUBTYPE_WebStream + public static readonly Guid WebStream = new Guid(0x776257d4, 0xc627, 0x41cb, 0x8f, 0x81, 0x7a, 0xc7, 0xff, 0x1c, 0x40, 0xcc); + + /// MEDIASUBTYPE_MPEG2_AUDIO + public static readonly Guid Mpeg2Audio = new Guid(0xe06d802b, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea); + + /// MEDIASUBTYPE_DOLBY_AC3 + public static readonly Guid DolbyAC3 = new Guid(0xe06d802c, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea); + + /// MEDIASUBTYPE_DVB_SI + public static readonly Guid DvbSI = new Guid(0xe9dd31a3, 0x221d, 0x4adb, 0x85, 0x32, 0x9a, 0xf3, 0x09, 0xc1, 0xa4, 0x08); + + /// MEDIASUBTYPE_ATSC_SI + public static readonly Guid AtscSI = new Guid(0xb3c7397c, 0xd303, 0x414d, 0xb3, 0x3c, 0x4e, 0xd2, 0xc9, 0xd2, 0x97, 0x33); + + /// MEDIASUBTYPE_MPEG2DATA + public static readonly Guid Mpeg2Data = new Guid(0xc892e55b, 0x252d, 0x42b5, 0xa3, 0x16, 0xd9, 0x97, 0xe7, 0xa5, 0xd9, 0x95); + + /// MEDIASUBTYPE_MPEG2_PROGRAM + public static readonly Guid Mpeg2Program = new Guid(0xe06d8022, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea); + + /// MEDIASUBTYPE_MPEG2_TRANSPORT + public static readonly Guid Mpeg2Transport = new Guid(0xe06d8023, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea); + + /// MEDIASUBTYPE_MPEG2_TRANSPORT_STRIDE + public static readonly Guid Mpeg2TransportStride = new Guid(0x138aa9a4, 0x1ee2, 0x4c5b, 0x98, 0x8e, 0x19, 0xab, 0xfd, 0xbc, 0x8a, 0x11); + + /// MEDIASUBTYPE_None + public static readonly Guid None = new Guid(0xe436eb8e, 0x524f, 0x11ce, 0x9f, 0x53, 0x00, 0x20, 0xaf, 0x0b, 0xa7, 0x70); + + /// MEDIASUBTYPE_H264 + public static readonly Guid H264 = new Guid(0x34363248, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_NV24 + public static readonly Guid NV24 = new Guid(0x3432564E, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// MEDIASUBTYPE_708_608Data + public static readonly Guid Data708_608 = new Guid(0xaf414bc, 0x4ed2, 0x445e, 0x98, 0x39, 0x8f, 0x9, 0x55, 0x68, 0xab, 0x3c); + + /// MEDIASUBTYPE_DtvCcData + public static readonly Guid DtvCcData = new Guid(0xF52ADDAA, 0x36F0, 0x43F5, 0x95, 0xEA, 0x6D, 0x86, 0x64, 0x84, 0x26, 0x2A); + + /// MEDIASUBTYPE_P422 + public static readonly Guid P422 = new Guid(0x32323450, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71); + + /// WMMEDIASUBTYPE_MP43 + public static readonly Guid MP43 = new Guid(0x3334504D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_MP4S + public static readonly Guid MP4S = new Guid(0x5334504D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_M4S2 + public static readonly Guid M4S2 = new Guid(0x3253344D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WMV1 + public static readonly Guid WMV1 = new Guid(0x31564D57, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WMV2 + public static readonly Guid WMV2 = new Guid(0x32564D57, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_MSS1 + public static readonly Guid MSS1 = new Guid(0x3153534D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WMAudioV9 + public static readonly Guid WMAudioV9 = new Guid(0x00000162, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WMAudio_Lossless + public static readonly Guid WMAudio_Lossless = new Guid(0x00000163, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_MSS2 + public static readonly Guid MSS2 = new Guid(0x3253534D, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WMSP1 + public static readonly Guid WMSP1 = new Guid(0x0000000A, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WMSP2 + public static readonly Guid WMSP2 = new Guid(0x0000000B, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WMV3 + public static readonly Guid WMV3 = new Guid(0x33564D57, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WMVP + public static readonly Guid WMVP = new Guid(0x50564D57, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WVP2 + public static readonly Guid WVP2 = new Guid(0x32505657, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WMVA + public static readonly Guid WMVA = new Guid(0x41564D57, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WVC1 + public static readonly Guid WVC1 = new Guid(0x31435657, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WMAudioV8 + public static readonly Guid WMAudioV8 = new Guid(0x00000161, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WMAudioV7 + public static readonly Guid WMAudioV7 = new Guid(0x00000161, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_WMAudioV2 + public static readonly Guid WMAudioV2 = new Guid(0x00000161, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_ACELPnet + public static readonly Guid ACELPnet = new Guid(0x00000130, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + + /// WMMEDIASUBTYPE_MP3 + public static readonly Guid MP3 = new Guid(0x00000055, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xAA, 0x00, 0x38, 0x9B, 0x71); + } + + public static class FormatType + { + public static readonly Guid Null = Guid.Empty; + + /// FORMAT_None + public static readonly Guid None = new Guid(0x0F6417D6, 0xc318, 0x11d0, 0xa4, 0x3f, 0x00, 0xa0, 0xc9, 0x22, 0x31, 0x96); + + /// FORMAT_VideoInfo + public static readonly Guid VideoInfo = new Guid(0x05589f80, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a); + + /// FORMAT_VideoInfo2 + public static readonly Guid VideoInfo2 = new Guid(0xf72a76A0, 0xeb0a, 0x11d0, 0xac, 0xe4, 0x00, 0x00, 0xc0, 0xcc, 0x16, 0xba); + + /// FORMAT_WaveFormatEx + public static readonly Guid WaveEx = new Guid(0x05589f81, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a); + + /// FORMAT_MPEGVideo + public static readonly Guid MpegVideo = new Guid(0x05589f82, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a); + + /// FORMAT_MPEGStreams + public static readonly Guid MpegStreams = new Guid(0x05589f83, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a); + + /// FORMAT_DvInfo + public static readonly Guid DvInfo = new Guid(0x05589f84, 0xc356, 0x11ce, 0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a); + + /// FORMAT_AnalogVideo + public static readonly Guid AnalogVideo = new Guid(0x0482dde0, 0x7817, 0x11cf, 0x8a, 0x03, 0x00, 0xaa, 0x00, 0x6e, 0xcb, 0x65); + + /// FORMAT_MPEG2Video + public static readonly Guid Mpeg2Video = new Guid(0xe06d80e3, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea); + + /// FORMAT_DolbyAC3 + public static readonly Guid DolbyAC3 = new Guid(0xe06d80e4, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea); + + /// FORMAT_MPEG2Audio + public static readonly Guid Mpeg2Audio = new Guid(0xe06d80e5, 0xdb46, 0x11cf, 0xb4, 0xd1, 0x00, 0x80, 0x5f, 0x6c, 0xbb, 0xea); + + /// FORMAT_525WSS + public static readonly Guid WSS525 = new Guid(0xc7ecf04d, 0x4582, 0x4869, 0x9a, 0xbb, 0xbf, 0xb5, 0x23, 0xb6, 0x2e, 0xdf); + + /// WMFORMAT_Script + public static readonly Guid Script = new Guid(0x5c8510f2, 0xdebe, 0x4ca7, 0xbb, 0xa5, 0xf0, 0x7a, 0x10, 0x4f, 0x8d, 0xff); + + /// WMFORMAT_WebStream + public static readonly Guid WebStream = new Guid(0xda1e6b13, 0x8359, 0x4050, 0xb3, 0x98, 0x38, 0x8e, 0x96, 0x5b, 0xf0, 0x0c); + } + + /// + /// From WM_MEDIA_TYPE - When you are done with an instance of this class, + /// it should be released with FreeWMMediaType() to avoid leaking + /// + [StructLayout(LayoutKind.Sequential), UnmanagedName("WM_MEDIA_TYPE")] + public class AMMediaType + { + public Guid majorType; + public Guid subType; + [MarshalAs(UnmanagedType.Bool)] public bool fixedSizeSamples; + [MarshalAs(UnmanagedType.Bool)] public bool temporalCompression; + public int sampleSize; + public Guid formatType; + public IntPtr unkPtr; // IUnknown Pointer + public int formatSize; + public IntPtr formatPtr; // Pointer to a buff determined by formatType + } + + + /// + /// From BITMAPINFOHEADER + /// + [StructLayout(LayoutKind.Sequential, Pack = 2), UnmanagedName("BITMAPINFOHEADER")] + public struct BitmapInfoHeader + { + public int Size; + public int Width; + public int Height; + public short Planes; + public short BitCount; + public int Compression; + public int ImageSize; + public int XPelsPerMeter; + public int YPelsPerMeter; + public int ClrUsed; + public int ClrImportant; + } + + + /// + /// From VIDEOINFOHEADER + /// + [StructLayout(LayoutKind.Sequential), UnmanagedName("VIDEOINFOHEADER")] + public class VideoInfoHeader + { + public Rectangle SrcRect; + public Rectangle TargetRect; + public int BitRate; + public int BitErrorRate; + public long AvgTimePerFrame; + public BitmapInfoHeader BmiHeader; + } + + + /// + /// From VIDEOINFOHEADER2 + /// + [StructLayout(LayoutKind.Sequential), UnmanagedName("VIDEOINFOHEADER2")] + public class VideoInfoHeader2 + { + public Rectangle SrcRect; + public Rectangle TargetRect; + public int BitRate; + public int BitErrorRate; + public long AvgTimePerFrame; + public int InterlaceFlags; + public int CopyProtectFlags; + public int PictAspectRatioX; + public int PictAspectRatioY; + public int ControlFlags; + public int Reserved2; + public BitmapInfoHeader BmiHeader; + } + + + /// + /// From WAVEFORMAT + /// + [StructLayout(LayoutKind.Sequential, Pack=2), UnmanagedName("WAVEFORMAT")] + public class WaveFormat + { + public short wFormatTag; /* format type */ + public short nChannels; /* number of channels (i.e. mono, stereo, etc.) */ + public int nSamplesPerSec; /* sample rate */ + public int nAvgBytesPerSec; /* for buffer estimation */ + public short nBlockAlign; /* block size of data */ + } + + /// + /// From WAVEFORMATEX + /// + [StructLayout(LayoutKind.Sequential), UnmanagedName("WAVEFORMATEX")] + public class WaveFormatEx : WaveFormat + { + public short wBitsPerSample; + public short cbSize; + } + + static public class AMToString + { + /// + /// Produces a usable string that describes the MediaType object + /// + /// Concatenation of MajorType + SubType + FormatType + Fixed + Temporal + SampleSize.ToString + public static string AMMediaTypeToString(AMMediaType pmt) + { + return string.Format("{0} {1} {2} {3} {4} {5}", + MediaTypeToString(pmt.majorType), + MediaSubTypeToString(pmt.subType), + MediaFormatTypeToString(pmt.formatType), + (pmt.fixedSizeSamples ? "FixedSamples" : "NotFixedSamples"), + (pmt.temporalCompression ? "temporalCompression" : "NottemporalCompression"), + pmt.sampleSize.ToString()); + } + + /// + /// Converts AMMediaType.MajorType Guid to a readable string + /// + /// MajorType Guid as a readable string or Guid if unrecognized + public static string MediaTypeToString(Guid guid) + { + // Walk the MediaSubType class looking for a match + return WalkClass(typeof(MediaType), guid); + } + + /// + /// Converts the AMMediaType.SubType Guid to a readable string + /// + /// SubType Guid as a readable string or Guid if unrecognized + public static string MediaSubTypeToString(Guid guid) + { + // Walk the MediaSubType class looking for a match + string s = WalkClass(typeof(MediaSubType), guid); + + // There is a special set of Guids that contain the FourCC code + // as part of the Guid. If we haven't found a name, check to see if + // it is one of those. + if (s == guid.ToString() && FourCC.IsA4ccSubtype(guid)) + { + s = new FourCC(guid).ToString(); + } + + return s; + } + + /// + /// Converts the AMMediaType.FormatType Guid to a readable string + /// + /// FormatType Guid as a readable string or Guid if unrecognized + public static string MediaFormatTypeToString(Guid guid) + { + // Walk the FormatType class looking for a match + return WalkClass(typeof(FormatType), guid); + + } + + /// + /// Use reflection to walk a class looking for a property containing a specified guid + /// + /// Class to scan + /// Guid to scan for + /// String representing property name that matches, or Guid.ToString() for no match + private static string WalkClass(Type MyType, Guid guid) + { + object o = null; + + // Read the fields from the class + FieldInfo[] Fields = MyType.GetFields(); + + // Walk the returned array + foreach (FieldInfo m in Fields) + { + // Read the value of the property. The parameter is ignored. + o = m.GetValue(o); + + // Compare it with the sought value + if ((Guid)o == guid) + { + return m.Name; + } + } + + return guid.ToString(); + } + } + +} diff --git a/WindowsMediaLib/WMUtils.cs b/WindowsMediaLib/WMUtils.cs new file mode 100644 index 0000000..512db2b --- /dev/null +++ b/WindowsMediaLib/WMUtils.cs @@ -0,0 +1,2069 @@ +#region license + +/* +WindowsMediaLib - Provide access to Windows Media interfaces via .NET +Copyright (C) 2008 +http://sourceforge.net/projects/windowsmedianet + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. + +You should have received a copy of the GNU Lesser General Public +License along with this library; if not, write to the Free Software +Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#endregion + +using System; +using System.Text; +using System.Runtime.InteropServices; +using System.Security; +using System.Diagnostics; + +using WindowsMediaLib.Defs; + +namespace WindowsMediaLib +{ + static public class WMUtils + { + /// + /// Free the nested structures and release any + /// COM objects within an WMMediaType struct. + /// + public static void FreeWMMediaType(AMMediaType mediaType) + { + if (mediaType != null) + { + if (mediaType.formatSize != 0) + { + Marshal.FreeCoTaskMem(mediaType.formatPtr); + mediaType.formatSize = 0; + mediaType.formatPtr = IntPtr.Zero; + } + if (mediaType.unkPtr != IntPtr.Zero) + { + Marshal.Release(mediaType.unkPtr); + mediaType.unkPtr = IntPtr.Zero; + } + } + } + + [DllImport("WMVCore.dll", PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMValidateData( + byte[] pbData, + ref int pdwDataSize + ); + + [DllImport("WMVCore.dll", ExactSpelling = true, CharSet = CharSet.Unicode, PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern int WMCheckURLExtension( + string pwszURL + ); + + [DllImport("WMVCore.dll", ExactSpelling = true, CharSet = CharSet.Unicode, PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMCheckURLScheme( + string pwszURLScheme + ); + + [DllImport("WMVCore.dll", ExactSpelling = true, CharSet = CharSet.Unicode, PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMIsAvailableOffline( + string pwszURL, + string pwszLanguage, + [MarshalAs(UnmanagedType.Bool)] out bool pfIsAvailableOffline + ); + + [DllImport("WMVCore.dll", PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMCreateEditor( + out IWMMetadataEditor ppMetadataEditor + ); + + [DllImport("WMVCore.dll", PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMCreateWriterNetworkSink( + out IWMWriterNetworkSink ppSink + ); + + [DllImport("WMVCore.dll", PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMCreateWriter( + IntPtr pUnkCert, + out IWMWriter ppWriter + ); + + [DllImport("WMVCore.dll", PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMCreateProfileManager( + out IWMProfileManager ppProfileManager + ); + + [DllImport("WMVCore.dll", ExactSpelling = true, CharSet = CharSet.Unicode, PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMIsContentProtected( + string pwszFileName, + [MarshalAs(UnmanagedType.Bool)] out bool pfIsProtected + ); + + [DllImport("WMVCore.dll", PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMCreateReader( + IntPtr pUnkCert, + Rights dwRights, + out IWMReader ppReader + ); + + [DllImport("WMVCore.dll", PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMCreateSyncReader( + IntPtr pUnkCert, + Rights dwRights, + out IWMSyncReader ppSyncReader); + + [DllImport("WMVCore.dll", PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMCreateIndexer( + out IWMIndexer ppIndexer + ); + + [DllImport("WMVCore.dll", PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMCreateBackupRestorer( + IWMStatusCallback pCallback, + out IWMLicenseBackup ppBackup + ); + + [DllImport("WMVCore.dll", PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMCreateWriterFileSink( + out IWMWriterFileSink ppSink + ); + + [DllImport("WMVCore.dll", PreserveSig = false), SuppressUnmanagedCodeSecurity] + public static extern void WMCreateWriterPushSink( + out IWMWriterPushSink ppSink + ); + + } + + abstract public class COMBase + { + protected const int S_Ok = 0; + protected const int S_False = 0; + + protected const int E_NotImplemented = unchecked((int)0x80004001); + protected const int E_NoInterface = unchecked((int)0x80004002); + protected const int E_Pointer = unchecked((int)0x80004003); + protected const int E_Abort = unchecked((int)0x80004004); + protected const int E_Fail = unchecked((int)0x80004005); + protected const int E_Unexpected = unchecked((int)0x8000FFFF); + protected const int E_OutOfMemory = unchecked((int)0x8007000E); + protected const int E_InvalidArgument = unchecked((int)0x80070057); + protected const int E_BufferTooSmall = unchecked((int)0x8007007a); + + protected static bool Succeeded(int hr) + { + return hr >= 0; + } + + protected static bool Failed(int hr) + { + return hr < 0; + } + + protected static void SafeRelease(object o) + { + if (o != null) + { + if (Marshal.IsComObject(o)) + { + Marshal.ReleaseComObject(o); + } + else + { + IDisposable iDis = o as IDisposable; + if (iDis != null) + { + iDis.Dispose(); + } + } + } + } + + protected static void TRACE(string s) + { + Debug.WriteLine(s); + } + } + + static public class NSResults + { + public const int S_CALLPENDING = unchecked((int)0x000D0000); + public const int S_CALLABORTED = unchecked((int)0x000D0001); + public const int S_STREAM_TRUNCATED = unchecked((int)0x000D0002); + public const int W_SERVER_BANDWIDTH_LIMIT = unchecked((int)0x800D0003); + public const int W_FILE_BANDWIDTH_LIMIT = unchecked((int)0x800D0004); + public const int E_NOCONNECTION = unchecked((int)0xC00D0005); + public const int E_CANNOTCONNECT = unchecked((int)0xC00D0006); + public const int E_CANNOTDESTROYTITLE = unchecked((int)0xC00D0007); + public const int E_CANNOTRENAMETITLE = unchecked((int)0xC00D0008); + public const int E_CANNOTOFFLINEDISK = unchecked((int)0xC00D0009); + public const int E_CANNOTONLINEDISK = unchecked((int)0xC00D000A); + public const int E_NOREGISTEREDWALKER = unchecked((int)0xC00D000B); + public const int E_NOFUNNEL = unchecked((int)0xC00D000C); + public const int E_NO_LOCALPLAY = unchecked((int)0xC00D000D); + public const int E_NETWORK_BUSY = unchecked((int)0xC00D000E); + public const int E_TOO_MANY_SESS = unchecked((int)0xC00D000F); + public const int E_ALREADY_CONNECTED = unchecked((int)0xC00D0010); + public const int E_INVALID_INDEX = unchecked((int)0xC00D0011); + public const int E_PROTOCOL_MISMATCH = unchecked((int)0xC00D0012); + public const int E_TIMEOUT = unchecked((int)0xC00D0013); + public const int E_NET_WRITE = unchecked((int)0xC00D0014); + public const int E_NET_READ = unchecked((int)0xC00D0015); + public const int E_DISK_WRITE = unchecked((int)0xC00D0016); + public const int E_DISK_READ = unchecked((int)0xC00D0017); + public const int E_FILE_WRITE = unchecked((int)0xC00D0018); + public const int E_FILE_READ = unchecked((int)0xC00D0019); + public const int E_FILE_NOT_FOUND = unchecked((int)0xC00D001A); + public const int E_FILE_EXISTS = unchecked((int)0xC00D001B); + public const int E_INVALID_NAME = unchecked((int)0xC00D001C); + public const int E_FILE_OPEN_FAILED = unchecked((int)0xC00D001D); + public const int E_FILE_ALLOCATION_FAILED = unchecked((int)0xC00D001E); + public const int E_FILE_INIT_FAILED = unchecked((int)0xC00D001F); + public const int E_FILE_PLAY_FAILED = unchecked((int)0xC00D0020); + public const int E_SET_DISK_UID_FAILED = unchecked((int)0xC00D0021); + public const int E_INDUCED = unchecked((int)0xC00D0022); + public const int E_CCLINK_DOWN = unchecked((int)0xC00D0023); + public const int E_INTERNAL = unchecked((int)0xC00D0024); + public const int E_BUSY = unchecked((int)0xC00D0025); + public const int E_UNRECOGNIZED_STREAM_TYPE = unchecked((int)0xC00D0026); + public const int E_NETWORK_SERVICE_FAILURE = unchecked((int)0xC00D0027); + public const int E_NETWORK_RESOURCE_FAILURE = unchecked((int)0xC00D0028); + public const int E_CONNECTION_FAILURE = unchecked((int)0xC00D0029); + public const int E_SHUTDOWN = unchecked((int)0xC00D002A); + public const int E_INVALID_REQUEST = unchecked((int)0xC00D002B); + public const int E_INSUFFICIENT_BANDWIDTH = unchecked((int)0xC00D002C); + public const int E_NOT_REBUILDING = unchecked((int)0xC00D002D); + public const int E_LATE_OPERATION = unchecked((int)0xC00D002E); + public const int E_INVALID_DATA = unchecked((int)0xC00D002F); + public const int E_FILE_BANDWIDTH_LIMIT = unchecked((int)0xC00D0030); + public const int E_OPEN_FILE_LIMIT = unchecked((int)0xC00D0031); + public const int E_BAD_CONTROL_DATA = unchecked((int)0xC00D0032); + public const int E_NO_STREAM = unchecked((int)0xC00D0033); + public const int E_STREAM_END = unchecked((int)0xC00D0034); + public const int E_SERVER_NOT_FOUND = unchecked((int)0xC00D0035); + public const int E_DUPLICATE_NAME = unchecked((int)0xC00D0036); + public const int E_DUPLICATE_ADDRESS = unchecked((int)0xC00D0037); + public const int E_BAD_MULTICAST_ADDRESS = unchecked((int)0xC00D0038); + public const int E_BAD_ADAPTER_ADDRESS = unchecked((int)0xC00D0039); + public const int E_BAD_DELIVERY_MODE = unchecked((int)0xC00D003A); + public const int E_INVALID_CHANNEL = unchecked((int)0xC00D003B); + public const int E_INVALID_STREAM = unchecked((int)0xC00D003C); + public const int E_INVALID_ARCHIVE = unchecked((int)0xC00D003D); + public const int E_NOTITLES = unchecked((int)0xC00D003E); + public const int E_INVALID_CLIENT = unchecked((int)0xC00D003F); + public const int E_INVALID_BLACKHOLE_ADDRESS = unchecked((int)0xC00D0040); + public const int E_INCOMPATIBLE_FORMAT = unchecked((int)0xC00D0041); + public const int E_INVALID_KEY = unchecked((int)0xC00D0042); + public const int E_INVALID_PORT = unchecked((int)0xC00D0043); + public const int E_INVALID_TTL = unchecked((int)0xC00D0044); + public const int E_STRIDE_REFUSED = unchecked((int)0xC00D0045); + public const int E_MMSAUTOSERVER_CANTFINDWALKER = unchecked((int)0xC00D0046); + public const int E_MAX_BITRATE = unchecked((int)0xC00D0047); + public const int E_LOGFILEPERIOD = unchecked((int)0xC00D0048); + public const int E_MAX_CLIENTS = unchecked((int)0xC00D0049); + public const int E_LOG_FILE_SIZE = unchecked((int)0xC00D004A); + public const int E_MAX_FILERATE = unchecked((int)0xC00D004B); + public const int E_WALKER_UNKNOWN = unchecked((int)0xC00D004C); + public const int E_WALKER_SERVER = unchecked((int)0xC00D004D); + public const int E_WALKER_USAGE = unchecked((int)0xC00D004E); + public const int I_TIGER_START = unchecked((int)0x400D004F); + public const int E_TIGER_FAIL = unchecked((int)0xC00D0050); + public const int I_CUB_START = unchecked((int)0x400D0051); + public const int I_CUB_RUNNING = unchecked((int)0x400D0052); + public const int E_CUB_FAIL = unchecked((int)0xC00D0053); + public const int I_DISK_START = unchecked((int)0x400D0054); + public const int E_DISK_FAIL = unchecked((int)0xC00D0055); + public const int I_DISK_REBUILD_STARTED = unchecked((int)0x400D0056); + public const int I_DISK_REBUILD_FINISHED = unchecked((int)0x400D0057); + public const int I_DISK_REBUILD_ABORTED = unchecked((int)0x400D0058); + public const int I_LIMIT_FUNNELS = unchecked((int)0x400D0059); + public const int I_START_DISK = unchecked((int)0x400D005A); + public const int I_STOP_DISK = unchecked((int)0x400D005B); + public const int I_STOP_CUB = unchecked((int)0x400D005C); + public const int I_KILL_USERSESSION = unchecked((int)0x400D005D); + public const int I_KILL_CONNECTION = unchecked((int)0x400D005E); + public const int I_REBUILD_DISK = unchecked((int)0x400D005F); + public const int W_UNKNOWN_EVENT = unchecked((int)0x800D0060); + public const int E_MAX_FUNNELS_ALERT = unchecked((int)0xC00D0060); + public const int E_ALLOCATE_FILE_FAIL = unchecked((int)0xC00D0061); + public const int E_PAGING_ERROR = unchecked((int)0xC00D0062); + public const int E_BAD_BLOCK0_VERSION = unchecked((int)0xC00D0063); + public const int E_BAD_DISK_UID = unchecked((int)0xC00D0064); + public const int E_BAD_FSMAJOR_VERSION = unchecked((int)0xC00D0065); + public const int E_BAD_STAMPNUMBER = unchecked((int)0xC00D0066); + public const int E_PARTIALLY_REBUILT_DISK = unchecked((int)0xC00D0067); + public const int E_ENACTPLAN_GIVEUP = unchecked((int)0xC00D0068); + public const int E_NO_FORMATS = unchecked((int)0xC00D006B); + public const int E_NO_REFERENCES = unchecked((int)0xC00D006C); + public const int E_WAVE_OPEN = unchecked((int)0xC00D006D); + public const int I_LOGGING_FAILED = unchecked((int)0x400D006E); + public const int E_CANNOTCONNECTEVENTS = unchecked((int)0xC00D006F); + public const int I_LIMIT_BANDWIDTH = unchecked((int)0x400D0070); + public const int E_NO_DEVICE = unchecked((int)0xC00D0071); + public const int E_NO_SPECIFIED_DEVICE = unchecked((int)0xC00D0072); + //public const int E_NOTFOUND = unchecked((int)0xC00D07F0); + public const int E_NOTHING_TO_DO = unchecked((int)0xC00D07F1); + public const int E_NO_MULTICAST = unchecked((int)0xC00D07F2); + public const int E_MONITOR_GIVEUP = unchecked((int)0xC00D00C8); + public const int E_REMIRRORED_DISK = unchecked((int)0xC00D00C9); + public const int E_INSUFFICIENT_DATA = unchecked((int)0xC00D00CA); + public const int E_ASSERT = unchecked((int)0xC00D00CB); + public const int E_BAD_ADAPTER_NAME = unchecked((int)0xC00D00CC); + public const int E_NOT_LICENSED = unchecked((int)0xC00D00CD); + public const int E_NO_SERVER_CONTACT = unchecked((int)0xC00D00CE); + public const int E_TOO_MANY_TITLES = unchecked((int)0xC00D00CF); + public const int E_TITLE_SIZE_EXCEEDED = unchecked((int)0xC00D00D0); + public const int E_UDP_DISABLED = unchecked((int)0xC00D00D1); + public const int E_TCP_DISABLED = unchecked((int)0xC00D00D2); + public const int E_HTTP_DISABLED = unchecked((int)0xC00D00D3); + public const int E_LICENSE_EXPIRED = unchecked((int)0xC00D00D4); + public const int E_TITLE_BITRATE = unchecked((int)0xC00D00D5); + public const int E_EMPTY_PROGRAM_NAME = unchecked((int)0xC00D00D6); + public const int E_MISSING_CHANNEL = unchecked((int)0xC00D00D7); + public const int E_NO_CHANNELS = unchecked((int)0xC00D00D8); + public const int E_INVALID_INDEX2 = unchecked((int)0xC00D00D9); + public const int E_CUB_FAIL_LINK = unchecked((int)0xC00D0190); + public const int I_CUB_UNFAIL_LINK = unchecked((int)0x400D0191); + public const int E_BAD_CUB_UID = unchecked((int)0xC00D0192); + public const int I_RESTRIPE_START = unchecked((int)0x400D0193); + public const int I_RESTRIPE_DONE = unchecked((int)0x400D0194); + public const int E_GLITCH_MODE = unchecked((int)0xC00D0195); + public const int I_RESTRIPE_DISK_OUT = unchecked((int)0x400D0196); + public const int I_RESTRIPE_CUB_OUT = unchecked((int)0x400D0197); + public const int I_DISK_STOP = unchecked((int)0x400D0198); + public const int I_CATATONIC_FAILURE = unchecked((int)0x800D0199); + public const int I_CATATONIC_AUTO_UNFAIL = unchecked((int)0x800D019A); + public const int E_NO_MEDIA_PROTOCOL = unchecked((int)0xC00D019B); + public const int E_INVALID_INPUT_FORMAT = unchecked((int)0xC00D0BB8); + public const int E_MSAUDIO_NOT_INSTALLED = unchecked((int)0xC00D0BB9); + public const int E_UNEXPECTED_MSAUDIO_ERROR = unchecked((int)0xC00D0BBA); + public const int E_INVALID_OUTPUT_FORMAT = unchecked((int)0xC00D0BBB); + public const int E_NOT_CONFIGURED = unchecked((int)0xC00D0BBC); + public const int E_PROTECTED_CONTENT = unchecked((int)0xC00D0BBD); + public const int E_LICENSE_REQUIRED = unchecked((int)0xC00D0BBE); + public const int E_TAMPERED_CONTENT = unchecked((int)0xC00D0BBF); + public const int E_LICENSE_OUTOFDATE = unchecked((int)0xC00D0BC0); + public const int E_LICENSE_INCORRECT_RIGHTS = unchecked((int)0xC00D0BC1); + public const int E_AUDIO_CODEC_NOT_INSTALLED = unchecked((int)0xC00D0BC2); + public const int E_AUDIO_CODEC_ERROR = unchecked((int)0xC00D0BC3); + public const int E_VIDEO_CODEC_NOT_INSTALLED = unchecked((int)0xC00D0BC4); + public const int E_VIDEO_CODEC_ERROR = unchecked((int)0xC00D0BC5); + public const int E_INVALIDPROFILE = unchecked((int)0xC00D0BC6); + public const int E_INCOMPATIBLE_VERSION = unchecked((int)0xC00D0BC7); + public const int S_REBUFFERING = unchecked((int)0x000D0BC8); + public const int S_DEGRADING_QUALITY = unchecked((int)0x000D0BC9); + public const int E_OFFLINE_MODE = unchecked((int)0xC00D0BCA); + public const int E_NOT_CONNECTED = unchecked((int)0xC00D0BCB); + public const int E_TOO_MUCH_DATA = unchecked((int)0xC00D0BCC); + public const int E_UNSUPPORTED_PROPERTY = unchecked((int)0xC00D0BCD); + public const int E_8BIT_WAVE_UNSUPPORTED = unchecked((int)0xC00D0BCE); + public const int E_NO_MORE_SAMPLES = unchecked((int)0xC00D0BCF); + public const int E_INVALID_SAMPLING_RATE = unchecked((int)0xC00D0BD0); + public const int E_MAX_PACKET_SIZE_TOO_SMALL = unchecked((int)0xC00D0BD1); + public const int E_LATE_PACKET = unchecked((int)0xC00D0BD2); + public const int E_DUPLICATE_PACKET = unchecked((int)0xC00D0BD3); + public const int E_SDK_BUFFERTOOSMALL = unchecked((int)0xC00D0BD4); + public const int E_INVALID_NUM_PASSES = unchecked((int)0xC00D0BD5); + public const int E_ATTRIBUTE_READ_ONLY = unchecked((int)0xC00D0BD6); + public const int E_ATTRIBUTE_NOT_ALLOWED = unchecked((int)0xC00D0BD7); + public const int E_INVALID_EDL = unchecked((int)0xC00D0BD8); + public const int E_DATA_UNIT_EXTENSION_TOO_LARGE = unchecked((int)0xC00D0BD9); + public const int E_CODEC_DMO_ERROR = unchecked((int)0xC00D0BDA); + public const int E_NO_CD = unchecked((int)0xC00D0FA0); + public const int E_CANT_READ_DIGITAL = unchecked((int)0xC00D0FA1); + public const int E_DEVICE_DISCONNECTED = unchecked((int)0xC00D0FA2); + public const int E_DEVICE_NOT_SUPPORT_FORMAT = unchecked((int)0xC00D0FA3); + public const int E_SLOW_READ_DIGITAL = unchecked((int)0xC00D0FA4); + public const int E_MIXER_INVALID_LINE = unchecked((int)0xC00D0FA5); + public const int E_MIXER_INVALID_CONTROL = unchecked((int)0xC00D0FA6); + public const int E_MIXER_INVALID_VALUE = unchecked((int)0xC00D0FA7); + public const int E_MIXER_UNKNOWN_MMRESULT = unchecked((int)0xC00D0FA8); + public const int E_USER_STOP = unchecked((int)0xC00D0FA9); + public const int E_MP3_FORMAT_NOT_FOUND = unchecked((int)0xC00D0FAA); + public const int E_CD_READ_ERROR_NO_CORRECTION = unchecked((int)0xC00D0FAB); + public const int E_CD_READ_ERROR = unchecked((int)0xC00D0FAC); + public const int E_CD_SLOW_COPY = unchecked((int)0xC00D0FAD); + public const int E_CD_COPYTO_CD = unchecked((int)0xC00D0FAE); + public const int E_MIXER_NODRIVER = unchecked((int)0xC00D0FAF); + public const int E_REDBOOK_ENABLED_WHILE_COPYING = unchecked((int)0xC00D0FB0); + public const int E_CD_REFRESH = unchecked((int)0xC00D0FB1); + public const int E_CD_DRIVER_PROBLEM = unchecked((int)0xC00D0FB2); + public const int E_WONT_DO_DIGITAL = unchecked((int)0xC00D0FB3); + public const int E_WMPXML_NOERROR = unchecked((int)0xC00D0FB4); + public const int E_WMPXML_ENDOFDATA = unchecked((int)0xC00D0FB5); + public const int E_WMPXML_PARSEERROR = unchecked((int)0xC00D0FB6); + public const int E_WMPXML_ATTRIBUTENOTFOUND = unchecked((int)0xC00D0FB7); + public const int E_WMPXML_PINOTFOUND = unchecked((int)0xC00D0FB8); + public const int E_WMPXML_EMPTYDOC = unchecked((int)0xC00D0FB9); + public const int E_WMP_WINDOWSAPIFAILURE = unchecked((int)0xC00D0FC8); + public const int E_WMP_RECORDING_NOT_ALLOWED = unchecked((int)0xC00D0FC9); + public const int E_DEVICE_NOT_READY = unchecked((int)0xC00D0FCA); + public const int E_DAMAGED_FILE = unchecked((int)0xC00D0FCB); + public const int E_MPDB_GENERIC = unchecked((int)0xC00D0FCC); + public const int E_FILE_FAILED_CHECKS = unchecked((int)0xC00D0FCD); + public const int E_MEDIA_LIBRARY_FAILED = unchecked((int)0xC00D0FCE); + public const int E_SHARING_VIOLATION = unchecked((int)0xC00D0FCF); + public const int E_NO_ERROR_STRING_FOUND = unchecked((int)0xC00D0FD0); + public const int E_WMPOCX_NO_REMOTE_CORE = unchecked((int)0xC00D0FD1); + public const int E_WMPOCX_NO_ACTIVE_CORE = unchecked((int)0xC00D0FD2); + public const int E_WMPOCX_NOT_RUNNING_REMOTELY = unchecked((int)0xC00D0FD3); + public const int E_WMPOCX_NO_REMOTE_WINDOW = unchecked((int)0xC00D0FD4); + public const int E_WMPOCX_ERRORMANAGERNOTAVAILABLE = unchecked((int)0xC00D0FD5); + public const int E_PLUGIN_NOTSHUTDOWN = unchecked((int)0xC00D0FD6); + public const int E_WMP_CANNOT_FIND_FOLDER = unchecked((int)0xC00D0FD7); + public const int E_WMP_STREAMING_RECORDING_NOT_ALLOWED = unchecked((int)0xC00D0FD8); + public const int E_WMP_PLUGINDLL_NOTFOUND = unchecked((int)0xC00D0FD9); + public const int E_NEED_TO_ASK_USER = unchecked((int)0xC00D0FDA); + public const int E_WMPOCX_PLAYER_NOT_DOCKED = unchecked((int)0xC00D0FDB); + public const int E_WMP_EXTERNAL_NOTREADY = unchecked((int)0xC00D0FDC); + public const int E_WMP_MLS_STALE_DATA = unchecked((int)0xC00D0FDD); + public const int E_WMP_UI_SUBCONTROLSNOTSUPPORTED = unchecked((int)0xC00D0FDE); + public const int E_WMP_UI_VERSIONMISMATCH = unchecked((int)0xC00D0FDF); + public const int E_WMP_UI_NOTATHEMEFILE = unchecked((int)0xC00D0FE0); + public const int E_WMP_UI_SUBELEMENTNOTFOUND = unchecked((int)0xC00D0FE1); + public const int E_WMP_UI_VERSIONPARSE = unchecked((int)0xC00D0FE2); + public const int E_WMP_UI_VIEWIDNOTFOUND = unchecked((int)0xC00D0FE3); + public const int E_WMP_UI_PASSTHROUGH = unchecked((int)0xC00D0FE4); + public const int E_WMP_UI_OBJECTNOTFOUND = unchecked((int)0xC00D0FE5); + public const int E_WMP_UI_SECONDHANDLER = unchecked((int)0xC00D0FE6); + public const int E_WMP_UI_NOSKININZIP = unchecked((int)0xC00D0FE7); + public const int S_WMP_UI_VERSIONMISMATCH = unchecked((int)0x000D0FE8); + public const int S_WMP_EXCEPTION = unchecked((int)0x000D0FE9); + public const int E_WMP_URLDOWNLOADFAILED = unchecked((int)0xC00D0FEA); + public const int E_WMPOCX_UNABLE_TO_LOAD_SKIN = unchecked((int)0xC00D0FEB); + public const int E_WMP_INVALID_SKIN = unchecked((int)0xC00D0FEC); + public const int E_WMP_SENDMAILFAILED = unchecked((int)0xC00D0FED); + public const int E_WMP_SAVEAS_READONLY = unchecked((int)0xC00D0FF0); + public const int E_WMP_RBC_JPGMAPPINGIMAGE = unchecked((int)0xC00D1004); + public const int E_WMP_JPGTRANSPARENCY = unchecked((int)0xC00D1005); + public const int E_WMP_INVALID_MAX_VAL = unchecked((int)0xC00D1009); + public const int E_WMP_INVALID_MIN_VAL = unchecked((int)0xC00D100A); + public const int E_WMP_CS_JPGPOSITIONIMAGE = unchecked((int)0xC00D100E); + public const int E_WMP_CS_NOTEVENLYDIVISIBLE = unchecked((int)0xC00D100F); + public const int E_WMPZIP_NOTAZIPFILE = unchecked((int)0xC00D1018); + public const int E_WMPZIP_CORRUPT = unchecked((int)0xC00D1019); + public const int E_WMPZIP_FILENOTFOUND = unchecked((int)0xC00D101A); + public const int E_WMP_IMAGE_FILETYPE_UNSUPPORTED = unchecked((int)0xC00D1022); + public const int E_WMP_IMAGE_INVALID_FORMAT = unchecked((int)0xC00D1023); + public const int E_WMP_GIF_UNEXPECTED_ENDOFFILE = unchecked((int)0xC00D1024); + public const int E_WMP_GIF_INVALID_FORMAT = unchecked((int)0xC00D1025); + public const int E_WMP_GIF_BAD_VERSION_NUMBER = unchecked((int)0xC00D1026); + public const int E_WMP_GIF_NO_IMAGE_IN_FILE = unchecked((int)0xC00D1027); + public const int E_WMP_PNG_INVALIDFORMAT = unchecked((int)0xC00D1028); + public const int E_WMP_PNG_UNSUPPORTED_BITDEPTH = unchecked((int)0xC00D1029); + public const int E_WMP_PNG_UNSUPPORTED_COMPRESSION = unchecked((int)0xC00D102A); + public const int E_WMP_PNG_UNSUPPORTED_FILTER = unchecked((int)0xC00D102B); + public const int E_WMP_PNG_UNSUPPORTED_INTERLACE = unchecked((int)0xC00D102C); + public const int E_WMP_PNG_UNSUPPORTED_BAD_CRC = unchecked((int)0xC00D102D); + public const int E_WMP_BMP_INVALID_BITMASK = unchecked((int)0xC00D102E); + public const int E_WMP_BMP_TOPDOWN_DIB_UNSUPPORTED = unchecked((int)0xC00D102F); + public const int E_WMP_BMP_BITMAP_NOT_CREATED = unchecked((int)0xC00D1030); + public const int E_WMP_BMP_COMPRESSION_UNSUPPORTED = unchecked((int)0xC00D1031); + public const int E_WMP_BMP_INVALID_FORMAT = unchecked((int)0xC00D1032); + public const int E_WMP_JPG_JERR_ARITHCODING_NOTIMPL = unchecked((int)0xC00D1033); + public const int E_WMP_JPG_INVALID_FORMAT = unchecked((int)0xC00D1034); + public const int E_WMP_JPG_BAD_DCTSIZE = unchecked((int)0xC00D1035); + public const int E_WMP_JPG_BAD_VERSION_NUMBER = unchecked((int)0xC00D1036); + public const int E_WMP_JPG_BAD_PRECISION = unchecked((int)0xC00D1037); + public const int E_WMP_JPG_CCIR601_NOTIMPL = unchecked((int)0xC00D1038); + public const int E_WMP_JPG_NO_IMAGE_IN_FILE = unchecked((int)0xC00D1039); + public const int E_WMP_JPG_READ_ERROR = unchecked((int)0xC00D103A); + public const int E_WMP_JPG_FRACT_SAMPLE_NOTIMPL = unchecked((int)0xC00D103B); + public const int E_WMP_JPG_IMAGE_TOO_BIG = unchecked((int)0xC00D103C); + public const int E_WMP_JPG_UNEXPECTED_ENDOFFILE = unchecked((int)0xC00D103D); + public const int E_WMP_JPG_SOF_UNSUPPORTED = unchecked((int)0xC00D103E); + public const int E_WMP_JPG_UNKNOWN_MARKER = unchecked((int)0xC00D103F); + public const int S_WMP_LOADED_GIF_IMAGE = unchecked((int)0x000D1040); + public const int S_WMP_LOADED_PNG_IMAGE = unchecked((int)0x000D1041); + public const int S_WMP_LOADED_BMP_IMAGE = unchecked((int)0x000D1042); + public const int S_WMP_LOADED_JPG_IMAGE = unchecked((int)0x000D1043); + public const int E_WMG_RATEUNAVAILABLE = unchecked((int)0xC00D104A); + public const int E_WMG_PLUGINUNAVAILABLE = unchecked((int)0xC00D104B); + public const int E_WMG_CANNOTQUEUE = unchecked((int)0xC00D104C); + public const int E_WMG_PREROLLLICENSEACQUISITIONNOTALLOWED = unchecked((int)0xC00D104D); + public const int E_WMG_UNEXPECTEDPREROLLSTATUS = unchecked((int)0xC00D104E); + public const int E_WMG_INVALIDSTATE = unchecked((int)0xC00D1054); + public const int E_WMG_SINKALREADYEXISTS = unchecked((int)0xC00D1055); + public const int E_WMG_NOSDKINTERFACE = unchecked((int)0xC00D1056); + public const int E_WMG_NOTALLOUTPUTSRENDERED = unchecked((int)0xC00D1057); + public const int E_WMG_FILETRANSFERNOTALLOWED = unchecked((int)0xC00D1058); + public const int E_WMR_UNSUPPORTEDSTREAM = unchecked((int)0xC00D1059); + public const int E_WMR_PINNOTFOUND = unchecked((int)0xC00D105A); + public const int E_WMR_WAITINGONFORMATSWITCH = unchecked((int)0xC00D105B); + public const int E_WMR_NOSOURCEFILTER = unchecked((int)0xC00D105C); + public const int E_WMR_PINTYPENOMATCH = unchecked((int)0xC00D105D); + public const int E_WMR_NOCALLBACKAVAILABLE = unchecked((int)0xC00D105E); + public const int S_WMR_ALREADYRENDERED = unchecked((int)0x000D105F); + public const int S_WMR_PINTYPEPARTIALMATCH = unchecked((int)0x000D1060); + public const int S_WMR_PINTYPEFULLMATCH = unchecked((int)0x000D1061); + public const int E_WMR_SAMPLEPROPERTYNOTSET = unchecked((int)0xC00D1062); + public const int E_WMR_CANNOT_RENDER_BINARY_STREAM = unchecked((int)0xC00D1063); + public const int E_WMG_LICENSE_TAMPERED = unchecked((int)0xC00D1064); + public const int E_WMR_WILLNOT_RENDER_BINARY_STREAM = unchecked((int)0xC00D1065); + public const int E_WMX_UNRECOGNIZED_PLAYLIST_FORMAT = unchecked((int)0xC00D1068); + public const int E_ASX_INVALIDFORMAT = unchecked((int)0xC00D1069); + public const int E_ASX_INVALIDVERSION = unchecked((int)0xC00D106A); + public const int E_ASX_INVALID_REPEAT_BLOCK = unchecked((int)0xC00D106B); + public const int E_ASX_NOTHING_TO_WRITE = unchecked((int)0xC00D106C); + public const int E_URLLIST_INVALIDFORMAT = unchecked((int)0xC00D106D); + public const int E_WMX_ATTRIBUTE_DOES_NOT_EXIST = unchecked((int)0xC00D106E); + public const int E_WMX_ATTRIBUTE_ALREADY_EXISTS = unchecked((int)0xC00D106F); + public const int E_WMX_ATTRIBUTE_UNRETRIEVABLE = unchecked((int)0xC00D1070); + public const int E_WMX_ITEM_DOES_NOT_EXIST = unchecked((int)0xC00D1071); + public const int E_WMX_ITEM_TYPE_ILLEGAL = unchecked((int)0xC00D1072); + public const int E_WMX_ITEM_UNSETTABLE = unchecked((int)0xC00D1073); + public const int E_WMX_PLAYLIST_EMPTY = unchecked((int)0xC00D1074); + public const int E_MLS_SMARTPLAYLIST_FILTER_NOT_REGISTERED = unchecked((int)0xC00D1075); + public const int E_WMX_INVALID_FORMAT_OVER_NESTING = unchecked((int)0xC00D1076); + public const int E_WMPCORE_NOSOURCEURLSTRING = unchecked((int)0xC00D107C); + public const int E_WMPCORE_COCREATEFAILEDFORGITOBJECT = unchecked((int)0xC00D107D); + public const int E_WMPCORE_FAILEDTOGETMARSHALLEDEVENTHANDLERINTERFACE = unchecked((int)0xC00D107E); + public const int E_WMPCORE_BUFFERTOOSMALL = unchecked((int)0xC00D107F); + public const int E_WMPCORE_UNAVAILABLE = unchecked((int)0xC00D1080); + public const int E_WMPCORE_INVALIDPLAYLISTMODE = unchecked((int)0xC00D1081); + public const int E_WMPCORE_ITEMNOTINPLAYLIST = unchecked((int)0xC00D1086); + public const int E_WMPCORE_PLAYLISTEMPTY = unchecked((int)0xC00D1087); + public const int E_WMPCORE_NOBROWSER = unchecked((int)0xC00D1088); + public const int E_WMPCORE_UNRECOGNIZED_MEDIA_URL = unchecked((int)0xC00D1089); + public const int E_WMPCORE_GRAPH_NOT_IN_LIST = unchecked((int)0xC00D108A); + public const int E_WMPCORE_PLAYLIST_EMPTY_OR_SINGLE_MEDIA = unchecked((int)0xC00D108B); + public const int E_WMPCORE_ERRORSINKNOTREGISTERED = unchecked((int)0xC00D108C); + public const int E_WMPCORE_ERRORMANAGERNOTAVAILABLE = unchecked((int)0xC00D108D); + public const int E_WMPCORE_WEBHELPFAILED = unchecked((int)0xC00D108E); + public const int E_WMPCORE_MEDIA_ERROR_RESUME_FAILED = unchecked((int)0xC00D108F); + public const int E_WMPCORE_NO_REF_IN_ENTRY = unchecked((int)0xC00D1090); + public const int E_WMPCORE_WMX_LIST_ATTRIBUTE_NAME_EMPTY = unchecked((int)0xC00D1091); + public const int E_WMPCORE_WMX_LIST_ATTRIBUTE_NAME_ILLEGAL = unchecked((int)0xC00D1092); + public const int E_WMPCORE_WMX_LIST_ATTRIBUTE_VALUE_EMPTY = unchecked((int)0xC00D1093); + public const int E_WMPCORE_WMX_LIST_ATTRIBUTE_VALUE_ILLEGAL = unchecked((int)0xC00D1094); + public const int E_WMPCORE_WMX_LIST_ITEM_ATTRIBUTE_NAME_EMPTY = unchecked((int)0xC00D1095); + public const int E_WMPCORE_WMX_LIST_ITEM_ATTRIBUTE_NAME_ILLEGAL = unchecked((int)0xC00D1096); + public const int E_WMPCORE_WMX_LIST_ITEM_ATTRIBUTE_VALUE_EMPTY = unchecked((int)0xC00D1097); + public const int E_WMPCORE_LIST_ENTRY_NO_REF = unchecked((int)0xC00D1098); + public const int E_WMPCORE_MISNAMED_FILE = unchecked((int)0xC00D1099); + public const int E_WMPCORE_CODEC_NOT_TRUSTED = unchecked((int)0xC00D109A); + public const int E_WMPCORE_CODEC_NOT_FOUND = unchecked((int)0xC00D109B); + public const int E_WMPCORE_CODEC_DOWNLOAD_NOT_ALLOWED = unchecked((int)0xC00D109C); + public const int E_WMPCORE_ERROR_DOWNLOADING_PLAYLIST = unchecked((int)0xC00D109D); + public const int E_WMPCORE_FAILED_TO_BUILD_PLAYLIST = unchecked((int)0xC00D109E); + public const int E_WMPCORE_PLAYLIST_ITEM_ALTERNATE_NONE = unchecked((int)0xC00D109F); + public const int E_WMPCORE_PLAYLIST_ITEM_ALTERNATE_EXHAUSTED = unchecked((int)0xC00D10A0); + public const int E_WMPCORE_PLAYLIST_ITEM_ALTERNATE_NAME_NOT_FOUND = unchecked((int)0xC00D10A1); + public const int E_WMPCORE_PLAYLIST_ITEM_ALTERNATE_MORPH_FAILED = unchecked((int)0xC00D10A2); + public const int E_WMPCORE_PLAYLIST_ITEM_ALTERNATE_INIT_FAILED = unchecked((int)0xC00D10A3); + public const int E_WMPCORE_MEDIA_ALTERNATE_REF_EMPTY = unchecked((int)0xC00D10A4); + public const int E_WMPCORE_PLAYLIST_NO_EVENT_NAME = unchecked((int)0xC00D10A5); + public const int E_WMPCORE_PLAYLIST_EVENT_ATTRIBUTE_ABSENT = unchecked((int)0xC00D10A6); + public const int E_WMPCORE_PLAYLIST_EVENT_EMPTY = unchecked((int)0xC00D10A7); + public const int E_WMPCORE_PLAYLIST_STACK_EMPTY = unchecked((int)0xC00D10A8); + public const int E_WMPCORE_CURRENT_MEDIA_NOT_ACTIVE = unchecked((int)0xC00D10A9); + public const int E_WMPCORE_USER_CANCEL = unchecked((int)0xC00D10AB); + public const int E_WMPCORE_PLAYLIST_REPEAT_EMPTY = unchecked((int)0xC00D10AC); + public const int E_WMPCORE_PLAYLIST_REPEAT_START_MEDIA_NONE = unchecked((int)0xC00D10AD); + public const int E_WMPCORE_PLAYLIST_REPEAT_END_MEDIA_NONE = unchecked((int)0xC00D10AE); + public const int E_WMPCORE_INVALID_PLAYLIST_URL = unchecked((int)0xC00D10AF); + public const int E_WMPCORE_MISMATCHED_RUNTIME = unchecked((int)0xC00D10B0); + public const int E_WMPCORE_PLAYLIST_IMPORT_FAILED_NO_ITEMS = unchecked((int)0xC00D10B1); + public const int E_WMPCORE_VIDEO_TRANSFORM_FILTER_INSERTION = unchecked((int)0xC00D10B2); + public const int E_WMPCORE_MEDIA_UNAVAILABLE = unchecked((int)0xC00D10B3); + public const int E_WMPCORE_WMX_ENTRYREF_NO_REF = unchecked((int)0xC00D10B4); + public const int E_WMPCORE_NO_PLAYABLE_MEDIA_IN_PLAYLIST = unchecked((int)0xC00D10B5); + public const int E_WMPCORE_PLAYLIST_EMPTY_NESTED_PLAYLIST_SKIPPED_ITEMS = unchecked((int)0xC00D10B6); + public const int E_WMPCORE_BUSY = unchecked((int)0xC00D10B7); + public const int E_WMPCORE_MEDIA_CHILD_PLAYLIST_UNAVAILABLE = unchecked((int)0xC00D10B8); + public const int E_WMPCORE_MEDIA_NO_CHILD_PLAYLIST = unchecked((int)0xC00D10B9); + public const int E_WMPCORE_FILE_NOT_FOUND = unchecked((int)0xC00D10BA); + public const int E_WMPCORE_TEMP_FILE_NOT_FOUND = unchecked((int)0xC00D10BB); + public const int E_WMDM_REVOKED = unchecked((int)0xC00D10BC); + public const int E_DDRAW_GENERIC = unchecked((int)0xC00D10BD); + public const int E_DISPLAY_MODE_CHANGE_FAILED = unchecked((int)0xC00D10BE); + public const int E_PLAYLIST_CONTAINS_ERRORS = unchecked((int)0xC00D10BF); + public const int E_CHANGING_PROXY_NAME = unchecked((int)0xC00D10C0); + public const int E_CHANGING_PROXY_PORT = unchecked((int)0xC00D10C1); + public const int E_CHANGING_PROXY_EXCEPTIONLIST = unchecked((int)0xC00D10C2); + public const int E_CHANGING_PROXYBYPASS = unchecked((int)0xC00D10C3); + public const int E_CHANGING_PROXY_PROTOCOL_NOT_FOUND = unchecked((int)0xC00D10C4); + public const int E_GRAPH_NOAUDIOLANGUAGE = unchecked((int)0xC00D10C5); + public const int E_GRAPH_NOAUDIOLANGUAGESELECTED = unchecked((int)0xC00D10C6); + public const int E_CORECD_NOTAMEDIACD = unchecked((int)0xC00D10C7); + public const int E_WMPCORE_MEDIA_URL_TOO_LONG = unchecked((int)0xC00D10C8); + public const int E_WMPFLASH_CANT_FIND_COM_SERVER = unchecked((int)0xC00D10C9); + public const int E_WMPFLASH_INCOMPATIBLEVERSION = unchecked((int)0xC00D10CA); + public const int E_WMPOCXGRAPH_IE_DISALLOWS_ACTIVEX_CONTROLS = unchecked((int)0xC00D10CB); + public const int E_NEED_CORE_REFERENCE = unchecked((int)0xC00D10CC); + public const int E_MEDIACD_READ_ERROR = unchecked((int)0xC00D10CD); + public const int E_IE_DISALLOWS_ACTIVEX_CONTROLS = unchecked((int)0xC00D10CE); + public const int E_FLASH_PLAYBACK_NOT_ALLOWED = unchecked((int)0xC00D10CF); + public const int E_UNABLE_TO_CREATE_RIP_LOCATION = unchecked((int)0xC00D10D0); + public const int E_WMPCORE_SOME_CODECS_MISSING = unchecked((int)0xC00D10D1); + public const int S_WMPCORE_PLAYLISTCLEARABORT = unchecked((int)0x000D10FE); + public const int S_WMPCORE_PLAYLISTREMOVEITEMABORT = unchecked((int)0x000D10FF); + public const int S_WMPCORE_PLAYLIST_CREATION_PENDING = unchecked((int)0x000D1102); + public const int S_WMPCORE_MEDIA_VALIDATION_PENDING = unchecked((int)0x000D1103); + public const int S_WMPCORE_PLAYLIST_REPEAT_SECONDARY_SEGMENTS_IGNORED = unchecked((int)0x000D1104); + public const int S_WMPCORE_COMMAND_NOT_AVAILABLE = unchecked((int)0x000D1105); + public const int S_WMPCORE_PLAYLIST_NAME_AUTO_GENERATED = unchecked((int)0x000D1106); + public const int S_WMPCORE_PLAYLIST_IMPORT_MISSING_ITEMS = unchecked((int)0x000D1107); + public const int S_WMPCORE_PLAYLIST_COLLAPSED_TO_SINGLE_MEDIA = unchecked((int)0x000D1108); + public const int S_WMPCORE_MEDIA_CHILD_PLAYLIST_OPEN_PENDING = unchecked((int)0x000D1109); + public const int S_WMPCORE_MORE_NODES_AVAIABLE = unchecked((int)0x000D110A); + public const int E_WMPIM_USEROFFLINE = unchecked((int)0xC00D1126); + public const int E_WMPIM_USERCANCELED = unchecked((int)0xC00D1127); + public const int E_WMPIM_DIALUPFAILED = unchecked((int)0xC00D1128); + public const int E_WINSOCK_ERROR_STRING = unchecked((int)0xC00D1129); + public const int E_WMPBR_NOLISTENER = unchecked((int)0xC00D1130); + public const int E_WMPBR_BACKUPCANCEL = unchecked((int)0xC00D1131); + public const int E_WMPBR_RESTORECANCEL = unchecked((int)0xC00D1132); + public const int E_WMPBR_ERRORWITHURL = unchecked((int)0xC00D1133); + public const int E_WMPBR_NAMECOLLISION = unchecked((int)0xC00D1134); + public const int S_WMPBR_SUCCESS = unchecked((int)0x000D1135); + public const int S_WMPBR_PARTIALSUCCESS = unchecked((int)0x000D1136); + public const int E_WMPBR_DRIVE_INVALID = unchecked((int)0xC00D1137); + public const int S_WMPEFFECT_TRANSPARENT = unchecked((int)0x000D1144); + public const int S_WMPEFFECT_OPAQUE = unchecked((int)0x000D1145); + public const int S_OPERATION_PENDING = unchecked((int)0x000D114E); + public const int E_DVD_NO_SUBPICTURE_STREAM = unchecked((int)0xC00D1162); + public const int E_DVD_COPY_PROTECT = unchecked((int)0xC00D1163); + public const int E_DVD_AUTHORING_PROBLEM = unchecked((int)0xC00D1164); + public const int E_DVD_INVALID_DISC_REGION = unchecked((int)0xC00D1165); + public const int E_DVD_COMPATIBLE_VIDEO_CARD = unchecked((int)0xC00D1166); + public const int E_DVD_MACROVISION = unchecked((int)0xC00D1167); + public const int E_DVD_SYSTEM_DECODER_REGION = unchecked((int)0xC00D1168); + public const int E_DVD_DISC_DECODER_REGION = unchecked((int)0xC00D1169); + public const int E_DVD_NO_VIDEO_STREAM = unchecked((int)0xC00D116A); + public const int E_DVD_NO_AUDIO_STREAM = unchecked((int)0xC00D116B); + public const int E_DVD_GRAPH_BUILDING = unchecked((int)0xC00D116C); + public const int E_DVD_NO_DECODER = unchecked((int)0xC00D116D); + public const int E_DVD_PARENTAL = unchecked((int)0xC00D116E); + public const int E_DVD_CANNOT_JUMP = unchecked((int)0xC00D116F); + public const int E_DVD_DEVICE_CONTENTION = unchecked((int)0xC00D1170); + public const int E_DVD_NO_VIDEO_MEMORY = unchecked((int)0xC00D1171); + public const int E_DVD_CANNOT_COPY_PROTECTED = unchecked((int)0xC00D1172); + public const int E_DVD_REQUIRED_PROPERTY_NOT_SET = unchecked((int)0xC00D1173); + public const int E_DVD_INVALID_TITLE_CHAPTER = unchecked((int)0xC00D1174); + public const int E_NO_CD_BURNER = unchecked((int)0xC00D1176); + public const int E_DEVICE_IS_NOT_READY = unchecked((int)0xC00D1177); + public const int E_PDA_UNSUPPORTED_FORMAT = unchecked((int)0xC00D1178); + public const int E_NO_PDA = unchecked((int)0xC00D1179); + public const int E_PDA_UNSPECIFIED_ERROR = unchecked((int)0xC00D117A); + public const int E_MEMSTORAGE_BAD_DATA = unchecked((int)0xC00D117B); + public const int E_PDA_FAIL_SELECT_DEVICE = unchecked((int)0xC00D117C); + public const int E_PDA_FAIL_READ_WAVE_FILE = unchecked((int)0xC00D117D); + public const int E_IMAPI_LOSSOFSTREAMING = unchecked((int)0xC00D117E); + public const int E_PDA_DEVICE_FULL = unchecked((int)0xC00D117F); + public const int E_FAIL_LAUNCH_ROXIO_PLUGIN = unchecked((int)0xC00D1180); + public const int E_PDA_DEVICE_FULL_IN_SESSION = unchecked((int)0xC00D1181); + public const int E_IMAPI_MEDIUM_INVALIDTYPE = unchecked((int)0xC00D1182); + public const int E_WMP_PROTOCOL_PROBLEM = unchecked((int)0xC00D1194); + public const int E_WMP_NO_DISK_SPACE = unchecked((int)0xC00D1195); + public const int E_WMP_LOGON_FAILURE = unchecked((int)0xC00D1196); + public const int E_WMP_CANNOT_FIND_FILE = unchecked((int)0xC00D1197); + public const int E_WMP_SERVER_INACCESSIBLE = unchecked((int)0xC00D1198); + public const int E_WMP_UNSUPPORTED_FORMAT = unchecked((int)0xC00D1199); + public const int E_WMP_DSHOW_UNSUPPORTED_FORMAT = unchecked((int)0xC00D119A); + public const int E_WMP_PLAYLIST_EXISTS = unchecked((int)0xC00D119B); + public const int E_WMP_NONMEDIA_FILES = unchecked((int)0xC00D119C); + public const int E_WMP_INVALID_ASX = unchecked((int)0xC00D119D); + public const int E_WMP_ALREADY_IN_USE = unchecked((int)0xC00D119E); + public const int E_WMP_IMAPI_FAILURE = unchecked((int)0xC00D119F); + public const int E_WMP_WMDM_FAILURE = unchecked((int)0xC00D11A0); + public const int E_WMP_CODEC_NEEDED_WITH_4CC = unchecked((int)0xC00D11A1); + public const int E_WMP_CODEC_NEEDED_WITH_FORMATTAG = unchecked((int)0xC00D11A2); + public const int E_WMP_MSSAP_NOT_AVAILABLE = unchecked((int)0xC00D11A3); + public const int E_WMP_WMDM_INTERFACEDEAD = unchecked((int)0xC00D11A4); + public const int E_WMP_WMDM_NOTCERTIFIED = unchecked((int)0xC00D11A5); + public const int E_WMP_WMDM_LICENSE_NOTEXIST = unchecked((int)0xC00D11A6); + public const int E_WMP_WMDM_LICENSE_EXPIRED = unchecked((int)0xC00D11A7); + public const int E_WMP_WMDM_BUSY = unchecked((int)0xC00D11A8); + public const int E_WMP_WMDM_NORIGHTS = unchecked((int)0xC00D11A9); + public const int E_WMP_WMDM_INCORRECT_RIGHTS = unchecked((int)0xC00D11AA); + public const int E_WMP_IMAPI_GENERIC = unchecked((int)0xC00D11AB); + public const int E_WMP_IMAPI_DEVICE_NOTPRESENT = unchecked((int)0xC00D11AD); + public const int E_WMP_IMAPI_STASHINUSE = unchecked((int)0xC00D11AE); + public const int E_WMP_IMAPI_LOSS_OF_STREAMING = unchecked((int)0xC00D11AF); + public const int E_WMP_SERVER_UNAVAILABLE = unchecked((int)0xC00D11B0); + public const int E_WMP_FILE_OPEN_FAILED = unchecked((int)0xC00D11B1); + public const int E_WMP_VERIFY_ONLINE = unchecked((int)0xC00D11B2); + public const int E_WMP_SERVER_NOT_RESPONDING = unchecked((int)0xC00D11B3); + public const int E_WMP_DRM_CORRUPT_BACKUP = unchecked((int)0xC00D11B4); + public const int E_WMP_DRM_LICENSE_SERVER_UNAVAILABLE = unchecked((int)0xC00D11B5); + public const int E_WMP_NETWORK_FIREWALL = unchecked((int)0xC00D11B6); + public const int E_WMP_NO_REMOVABLE_MEDIA = unchecked((int)0xC00D11B7); + public const int E_WMP_PROXY_CONNECT_TIMEOUT = unchecked((int)0xC00D11B8); + public const int E_WMP_NEED_UPGRADE = unchecked((int)0xC00D11B9); + public const int E_WMP_AUDIO_HW_PROBLEM = unchecked((int)0xC00D11BA); + public const int E_WMP_INVALID_PROTOCOL = unchecked((int)0xC00D11BB); + public const int E_WMP_INVALID_LIBRARY_ADD = unchecked((int)0xC00D11BC); + public const int E_WMP_MMS_NOT_SUPPORTED = unchecked((int)0xC00D11BD); + public const int E_WMP_NO_PROTOCOLS_SELECTED = unchecked((int)0xC00D11BE); + public const int E_WMP_GOFULLSCREEN_FAILED = unchecked((int)0xC00D11BF); + public const int E_WMP_NETWORK_ERROR = unchecked((int)0xC00D11C0); + public const int E_WMP_CONNECT_TIMEOUT = unchecked((int)0xC00D11C1); + public const int E_WMP_MULTICAST_DISABLED = unchecked((int)0xC00D11C2); + public const int E_WMP_SERVER_DNS_TIMEOUT = unchecked((int)0xC00D11C3); + public const int E_WMP_PROXY_NOT_FOUND = unchecked((int)0xC00D11C4); + public const int E_WMP_TAMPERED_CONTENT = unchecked((int)0xC00D11C5); + public const int E_WMP_OUTOFMEMORY = unchecked((int)0xC00D11C6); + public const int E_WMP_AUDIO_CODEC_NOT_INSTALLED = unchecked((int)0xC00D11C7); + public const int E_WMP_VIDEO_CODEC_NOT_INSTALLED = unchecked((int)0xC00D11C8); + public const int E_WMP_IMAPI_DEVICE_INVALIDTYPE = unchecked((int)0xC00D11C9); + public const int E_WMP_DRM_DRIVER_AUTH_FAILURE = unchecked((int)0xC00D11CA); + public const int E_WMP_NETWORK_RESOURCE_FAILURE = unchecked((int)0xC00D11CB); + public const int E_WMP_UPGRADE_APPLICATION = unchecked((int)0xC00D11CC); + public const int E_WMP_UNKNOWN_ERROR = unchecked((int)0xC00D11CD); + public const int E_WMP_INVALID_KEY = unchecked((int)0xC00D11CE); + public const int E_WMP_CD_ANOTHER_USER = unchecked((int)0xC00D11CF); + public const int E_WMP_DRM_NEEDS_AUTHORIZATION = unchecked((int)0xC00D11D0); + public const int E_WMP_BAD_DRIVER = unchecked((int)0xC00D11D1); + public const int E_WMP_ACCESS_DENIED = unchecked((int)0xC00D11D2); + public const int E_WMP_LICENSE_RESTRICTS = unchecked((int)0xC00D11D3); + public const int E_WMP_INVALID_REQUEST = unchecked((int)0xC00D11D4); + public const int E_WMP_CD_STASH_NO_SPACE = unchecked((int)0xC00D11D5); + public const int E_WMP_DRM_NEW_HARDWARE = unchecked((int)0xC00D11D6); + public const int E_WMP_DRM_INVALID_SIG = unchecked((int)0xC00D11D7); + public const int E_WMP_DRM_CANNOT_RESTORE = unchecked((int)0xC00D11D8); + public const int E_CD_NO_BUFFERS_READ = unchecked((int)0xC00D11F8); + public const int E_CD_EMPTY_TRACK_QUEUE = unchecked((int)0xC00D11F9); + public const int E_CD_NO_READER = unchecked((int)0xC00D11FA); + public const int E_CD_ISRC_INVALID = unchecked((int)0xC00D11FB); + public const int E_CD_MEDIA_CATALOG_NUMBER_INVALID = unchecked((int)0xC00D11FC); + public const int E_SLOW_READ_DIGITAL_WITH_ERRORCORRECTION = unchecked((int)0xC00D11FD); + public const int E_CD_SPEEDDETECT_NOT_ENOUGH_READS = unchecked((int)0xC00D11FE); + public const int E_CD_QUEUEING_DISABLED = unchecked((int)0xC00D11FF); + public const int E_WMP_POLICY_VALUE_NOT_CONFIGURED = unchecked((int)0xC00D122A); + public const int E_WMP_HWND_NOTFOUND = unchecked((int)0xC00D125C); + public const int E_BKGDOWNLOAD_WRONG_NO_FILES = unchecked((int)0xC00D125D); + public const int E_BKGDOWNLOAD_COMPLETECANCELLEDJOB = unchecked((int)0xC00D125E); + public const int E_BKGDOWNLOAD_CANCELCOMPLETEDJOB = unchecked((int)0xC00D125F); + public const int E_BKGDOWNLOAD_NOJOBPOINTER = unchecked((int)0xC00D1260); + public const int E_BKGDOWNLOAD_INVALIDJOBSIGNATURE = unchecked((int)0xC00D1261); + public const int E_BKGDOWNLOAD_FAILED_TO_CREATE_TEMPFILE = unchecked((int)0xC00D1262); + public const int E_BKGDOWNLOAD_PLUGIN_FAILEDINITIALIZE = unchecked((int)0xC00D1263); + public const int E_BKGDOWNLOAD_PLUGIN_FAILEDTOMOVEFILE = unchecked((int)0xC00D1264); + public const int E_BKGDOWNLOAD_CALLFUNCFAILED = unchecked((int)0xC00D1265); + public const int E_BKGDOWNLOAD_CALLFUNCTIMEOUT = unchecked((int)0xC00D1266); + public const int E_BKGDOWNLOAD_CALLFUNCENDED = unchecked((int)0xC00D1267); + public const int E_BKGDOWNLOAD_WMDUNPACKFAILED = unchecked((int)0xC00D1268); + public const int E_BKGDOWNLOAD_FAILEDINITIALIZE = unchecked((int)0xC00D1269); + public const int E_INTERFACE_NOT_REGISTERED_IN_GIT = unchecked((int)0xC00D126A); + public const int E_BKGDOWNLOAD_INVALID_FILE_NAME = unchecked((int)0xC00D126B); + public const int E_IMAGE_DOWNLOAD_FAILED = unchecked((int)0xC00D128E); + public const int E_WMP_UDRM_NOUSERLIST = unchecked((int)0xC00D12C0); + public const int E_WMP_DRM_NOT_ACQUIRING = unchecked((int)0xC00D12C1); + public const int E_WMP_BSTR_TOO_LONG = unchecked((int)0xC00D12F2); + public const int E_WMP_AUTOPLAY_INVALID_STATE = unchecked((int)0xC00D12FC); + public const int E_CURL_NOTSAFE = unchecked((int)0xC00D1324); + public const int E_CURL_INVALIDCHAR = unchecked((int)0xC00D1325); + public const int E_CURL_INVALIDHOSTNAME = unchecked((int)0xC00D1326); + public const int E_CURL_INVALIDPATH = unchecked((int)0xC00D1327); + public const int E_CURL_INVALIDSCHEME = unchecked((int)0xC00D1328); + public const int E_CURL_INVALIDURL = unchecked((int)0xC00D1329); + public const int E_CURL_CANTWALK = unchecked((int)0xC00D132B); + public const int E_CURL_INVALIDPORT = unchecked((int)0xC00D132C); + public const int E_CURLHELPER_NOTADIRECTORY = unchecked((int)0xC00D132D); + public const int E_CURLHELPER_NOTAFILE = unchecked((int)0xC00D132E); + public const int E_CURL_CANTDECODE = unchecked((int)0xC00D132F); + public const int E_CURLHELPER_NOTRELATIVE = unchecked((int)0xC00D1330); + public const int E_CURL_INVALIDBUFFERSIZE = unchecked((int)0xC00D1355); + public const int E_SUBSCRIPTIONSERVICE_PLAYBACK_DISALLOWED = unchecked((int)0xC00D1356); + public const int E_ADVANCEDEDIT_TOO_MANY_PICTURES = unchecked((int)0xC00D136A); + public const int E_REDIRECT = unchecked((int)0xC00D1388); + public const int E_STALE_PRESENTATION = unchecked((int)0xC00D1389); + public const int E_NAMESPACE_WRONG_PERSIST = unchecked((int)0xC00D138A); + public const int E_NAMESPACE_WRONG_TYPE = unchecked((int)0xC00D138B); + public const int E_NAMESPACE_NODE_CONFLICT = unchecked((int)0xC00D138C); + public const int E_NAMESPACE_NODE_NOT_FOUND = unchecked((int)0xC00D138D); + public const int E_NAMESPACE_BUFFER_TOO_SMALL = unchecked((int)0xC00D138E); + public const int E_NAMESPACE_TOO_MANY_CALLBACKS = unchecked((int)0xC00D138F); + public const int E_NAMESPACE_DUPLICATE_CALLBACK = unchecked((int)0xC00D1390); + public const int E_NAMESPACE_CALLBACK_NOT_FOUND = unchecked((int)0xC00D1391); + public const int E_NAMESPACE_NAME_TOO_LONG = unchecked((int)0xC00D1392); + public const int E_NAMESPACE_DUPLICATE_NAME = unchecked((int)0xC00D1393); + public const int E_NAMESPACE_EMPTY_NAME = unchecked((int)0xC00D1394); + public const int E_NAMESPACE_INDEX_TOO_LARGE = unchecked((int)0xC00D1395); + public const int E_NAMESPACE_BAD_NAME = unchecked((int)0xC00D1396); + public const int E_NAMESPACE_WRONG_SECURITY = unchecked((int)0xC00D1397); + public const int E_CACHE_ARCHIVE_CONFLICT = unchecked((int)0xC00D13EC); + public const int E_CACHE_ORIGIN_SERVER_NOT_FOUND = unchecked((int)0xC00D13ED); + public const int E_CACHE_ORIGIN_SERVER_TIMEOUT = unchecked((int)0xC00D13EE); + public const int E_CACHE_NOT_BROADCAST = unchecked((int)0xC00D13EF); + public const int E_CACHE_CANNOT_BE_CACHED = unchecked((int)0xC00D13F0); + public const int E_CACHE_NOT_MODIFIED = unchecked((int)0xC00D13F1); + public const int E_CANNOT_REMOVE_PUBLISHING_POINT = unchecked((int)0xC00D1450); + public const int E_CANNOT_REMOVE_PLUGIN = unchecked((int)0xC00D1451); + public const int E_WRONG_PUBLISHING_POINT_TYPE = unchecked((int)0xC00D1452); + public const int E_UNSUPPORTED_LOAD_TYPE = unchecked((int)0xC00D1453); + public const int E_INVALID_PLUGIN_LOAD_TYPE_CONFIGURATION = unchecked((int)0xC00D1454); + public const int E_INVALID_PUBLISHING_POINT_NAME = unchecked((int)0xC00D1455); + public const int E_TOO_MANY_MULTICAST_SINKS = unchecked((int)0xC00D1456); + public const int E_PUBLISHING_POINT_INVALID_REQUEST_WHILE_STARTED = unchecked((int)0xC00D1457); + public const int E_MULTICAST_PLUGIN_NOT_ENABLED = unchecked((int)0xC00D1458); + public const int E_INVALID_OPERATING_SYSTEM_VERSION = unchecked((int)0xC00D1459); + public const int E_PUBLISHING_POINT_REMOVED = unchecked((int)0xC00D145A); + public const int E_INVALID_PUSH_PUBLISHING_POINT_START_REQUEST = unchecked((int)0xC00D145B); + public const int E_UNSUPPORTED_LANGUAGE = unchecked((int)0xC00D145C); + public const int E_WRONG_OS_VERSION = unchecked((int)0xC00D145D); + public const int E_PUBLISHING_POINT_STOPPED = unchecked((int)0xC00D145E); + public const int E_PLAYLIST_ENTRY_ALREADY_PLAYING = unchecked((int)0xC00D14B4); + public const int E_EMPTY_PLAYLIST = unchecked((int)0xC00D14B5); + public const int E_PLAYLIST_PARSE_FAILURE = unchecked((int)0xC00D14B6); + public const int E_PLAYLIST_UNSUPPORTED_ENTRY = unchecked((int)0xC00D14B7); + public const int E_PLAYLIST_ENTRY_NOT_IN_PLAYLIST = unchecked((int)0xC00D14B8); + public const int E_PLAYLIST_ENTRY_SEEK = unchecked((int)0xC00D14B9); + public const int E_PLAYLIST_RECURSIVE_PLAYLISTS = unchecked((int)0xC00D14BA); + public const int E_PLAYLIST_TOO_MANY_NESTED_PLAYLISTS = unchecked((int)0xC00D14BB); + public const int E_PLAYLIST_SHUTDOWN = unchecked((int)0xC00D14BC); + public const int E_PLAYLIST_END_RECEDING = unchecked((int)0xC00D14BD); + public const int I_PLAYLIST_CHANGE_RECEDING = unchecked((int)0x400D14BE); + public const int E_DATAPATH_NO_SINK = unchecked((int)0xC00D1518); + public const int S_PUBLISHING_POINT_STARTED_WITH_FAILED_SINKS = unchecked((int)0x000D1519); + public const int E_INVALID_PUSH_TEMPLATE = unchecked((int)0xC00D151A); + public const int E_INVALID_PUSH_PUBLISHING_POINT = unchecked((int)0xC00D151B); + public const int E_CRITICAL_ERROR = unchecked((int)0xC00D151C); + public const int E_NO_NEW_CONNECTIONS = unchecked((int)0xC00D151D); + public const int E_WSX_INVALID_VERSION = unchecked((int)0xC00D151E); + public const int E_HEADER_MISMATCH = unchecked((int)0xC00D151F); + public const int E_PUSH_DUPLICATE_PUBLISHING_POINT_NAME = unchecked((int)0xC00D1520); + public const int E_NO_SCRIPT_ENGINE = unchecked((int)0xC00D157C); + public const int E_PLUGIN_ERROR_REPORTED = unchecked((int)0xC00D157D); + public const int E_SOURCE_PLUGIN_NOT_FOUND = unchecked((int)0xC00D157E); + public const int E_PLAYLIST_PLUGIN_NOT_FOUND = unchecked((int)0xC00D157F); + public const int E_DATA_SOURCE_ENUMERATION_NOT_SUPPORTED = unchecked((int)0xC00D1580); + public const int E_MEDIA_PARSER_INVALID_FORMAT = unchecked((int)0xC00D1581); + public const int E_SCRIPT_DEBUGGER_NOT_INSTALLED = unchecked((int)0xC00D1582); + public const int E_FEATURE_REQUIRES_ENTERPRISE_SERVER = unchecked((int)0xC00D1583); + public const int E_WIZARD_RUNNING = unchecked((int)0xC00D1584); + public const int E_INVALID_LOG_URL = unchecked((int)0xC00D1585); + public const int E_INVALID_MTU_RANGE = unchecked((int)0xC00D1586); + public const int E_INVALID_PLAY_STATISTICS = unchecked((int)0xC00D1587); + public const int E_LOG_NEED_TO_BE_SKIPPED = unchecked((int)0xC00D1588); + public const int E_HTTP_TEXT_DATACONTAINER_SIZE_LIMIT_EXCEEDED = unchecked((int)0xC00D1589); + public const int E_PORT_IN_USE = unchecked((int)0xC00D158A); + public const int E_PORT_IN_USE_HTTP = unchecked((int)0xC00D158B); + public const int E_HTTP_TEXT_DATACONTAINER_INVALID_SERVER_RESPONSE = unchecked((int)0xC00D158C); + public const int E_ARCHIVE_REACH_QUOTA = unchecked((int)0xC00D158D); + public const int E_ARCHIVE_ABORT_DUE_TO_BCAST = unchecked((int)0xC00D158E); + public const int E_ARCHIVE_GAP_DETECTED = unchecked((int)0xC00D158F); + public const int E_BAD_MARKIN = unchecked((int)0xC00D1B58); + public const int E_BAD_MARKOUT = unchecked((int)0xC00D1B59); + public const int E_NOMATCHING_MEDIASOURCE = unchecked((int)0xC00D1B5A); + public const int E_UNSUPPORTED_SOURCETYPE = unchecked((int)0xC00D1B5B); + public const int E_TOO_MANY_AUDIO = unchecked((int)0xC00D1B5C); + public const int E_TOO_MANY_VIDEO = unchecked((int)0xC00D1B5D); + public const int E_NOMATCHING_ELEMENT = unchecked((int)0xC00D1B5E); + public const int E_MISMATCHED_MEDIACONTENT = unchecked((int)0xC00D1B5F); + public const int E_CANNOT_DELETE_ACTIVE_SOURCEGROUP = unchecked((int)0xC00D1B60); + public const int E_AUDIODEVICE_BUSY = unchecked((int)0xC00D1B61); + public const int E_AUDIODEVICE_UNEXPECTED = unchecked((int)0xC00D1B62); + public const int E_AUDIODEVICE_BADFORMAT = unchecked((int)0xC00D1B63); + public const int E_VIDEODEVICE_BUSY = unchecked((int)0xC00D1B64); + public const int E_VIDEODEVICE_UNEXPECTED = unchecked((int)0xC00D1B65); + public const int E_INVALIDCALL_WHILE_ENCODER_RUNNING = unchecked((int)0xC00D1B66); + public const int E_NO_PROFILE_IN_SOURCEGROUP = unchecked((int)0xC00D1B67); + public const int E_VIDEODRIVER_UNSTABLE = unchecked((int)0xC00D1B68); + public const int E_VIDCAPSTARTFAILED = unchecked((int)0xC00D1B69); + public const int E_VIDSOURCECOMPRESSION = unchecked((int)0xC00D1B6A); + public const int E_VIDSOURCESIZE = unchecked((int)0xC00D1B6B); + public const int E_ICMQUERYFORMAT = unchecked((int)0xC00D1B6C); + public const int E_VIDCAPCREATEWINDOW = unchecked((int)0xC00D1B6D); + public const int E_VIDCAPDRVINUSE = unchecked((int)0xC00D1B6E); + public const int E_NO_MEDIAFORMAT_IN_SOURCE = unchecked((int)0xC00D1B6F); + public const int E_NO_VALID_OUTPUT_STREAM = unchecked((int)0xC00D1B70); + public const int E_NO_VALID_SOURCE_PLUGIN = unchecked((int)0xC00D1B71); + public const int E_NO_ACTIVE_SOURCEGROUP = unchecked((int)0xC00D1B72); + public const int E_NO_SCRIPT_STREAM = unchecked((int)0xC00D1B73); + public const int E_INVALIDCALL_WHILE_ARCHIVAL_RUNNING = unchecked((int)0xC00D1B74); + public const int E_INVALIDPACKETSIZE = unchecked((int)0xC00D1B75); + public const int E_PLUGIN_CLSID_INVALID = unchecked((int)0xC00D1B76); + public const int E_UNSUPPORTED_ARCHIVETYPE = unchecked((int)0xC00D1B77); + public const int E_UNSUPPORTED_ARCHIVEOPERATION = unchecked((int)0xC00D1B78); + public const int E_ARCHIVE_FILENAME_NOTSET = unchecked((int)0xC00D1B79); + public const int E_SOURCEGROUP_NOTPREPARED = unchecked((int)0xC00D1B7A); + public const int E_PROFILE_MISMATCH = unchecked((int)0xC00D1B7B); + public const int E_INCORRECTCLIPSETTINGS = unchecked((int)0xC00D1B7C); + public const int E_NOSTATSAVAILABLE = unchecked((int)0xC00D1B7D); + public const int E_NOTARCHIVING = unchecked((int)0xC00D1B7E); + public const int E_INVALIDCALL_WHILE_ENCODER_STOPPED = unchecked((int)0xC00D1B7F); + public const int E_NOSOURCEGROUPS = unchecked((int)0xC00D1B80); + public const int E_INVALIDINPUTFPS = unchecked((int)0xC00D1B81); + public const int E_NO_DATAVIEW_SUPPORT = unchecked((int)0xC00D1B82); + public const int E_CODEC_UNAVAILABLE = unchecked((int)0xC00D1B83); + public const int E_ARCHIVE_SAME_AS_INPUT = unchecked((int)0xC00D1B84); + public const int E_SOURCE_NOTSPECIFIED = unchecked((int)0xC00D1B85); + public const int E_NO_REALTIME_TIMECOMPRESSION = unchecked((int)0xC00D1B86); + public const int E_UNSUPPORTED_ENCODER_DEVICE = unchecked((int)0xC00D1B87); + public const int E_UNEXPECTED_DISPLAY_SETTINGS = unchecked((int)0xC00D1B88); + public const int E_NO_AUDIODATA = unchecked((int)0xC00D1B89); + public const int E_INPUTSOURCE_PROBLEM = unchecked((int)0xC00D1B8A); + public const int E_WME_VERSION_MISMATCH = unchecked((int)0xC00D1B8B); + public const int E_NO_REALTIME_PREPROCESS = unchecked((int)0xC00D1B8C); + public const int E_NO_REPEAT_PREPROCESS = unchecked((int)0xC00D1B8D); + public const int E_CANNOT_PAUSE_LIVEBROADCAST = unchecked((int)0xC00D1B8E); + public const int E_DRM_PROFILE_NOT_SET = unchecked((int)0xC00D1B8F); + public const int E_DUPLICATE_DRMPROFILE = unchecked((int)0xC00D1B90); + public const int E_INVALID_DEVICE = unchecked((int)0xC00D1B91); + public const int E_SPEECHEDL_ON_NON_MIXEDMODE = unchecked((int)0xC00D1B92); + public const int E_DRM_PASSWORD_TOO_LONG = unchecked((int)0xC00D1B93); + public const int E_DEVCONTROL_FAILED_SEEK = unchecked((int)0xC00D1B94); + public const int E_INTERLACE_REQUIRE_SAMESIZE = unchecked((int)0xC00D1B95); + public const int E_TOO_MANY_DEVICECONTROL = unchecked((int)0xC00D1B96); + public const int E_NO_MULTIPASS_FOR_LIVEDEVICE = unchecked((int)0xC00D1B97); + public const int E_MISSING_AUDIENCE = unchecked((int)0xC00D1B98); + public const int E_AUDIENCE_CONTENTTYPE_MISMATCH = unchecked((int)0xC00D1B99); + public const int E_MISSING_SOURCE_INDEX = unchecked((int)0xC00D1B9A); + public const int E_NUM_LANGUAGE_MISMATCH = unchecked((int)0xC00D1B9B); + public const int E_LANGUAGE_MISMATCH = unchecked((int)0xC00D1B9C); + public const int E_VBRMODE_MISMATCH = unchecked((int)0xC00D1B9D); + public const int E_INVALID_INPUT_AUDIENCE_INDEX = unchecked((int)0xC00D1B9E); + public const int E_INVALID_INPUT_LANGUAGE = unchecked((int)0xC00D1B9F); + public const int E_INVALID_INPUT_STREAM = unchecked((int)0xC00D1BA0); + public const int E_EXPECT_MONO_WAV_INPUT = unchecked((int)0xC00D1BA1); + public const int E_INPUT_WAVFORMAT_MISMATCH = unchecked((int)0xC00D1BA2); + public const int E_RECORDQ_DISK_FULL = unchecked((int)0xC00D1BA3); + public const int E_NO_PAL_INVERSE_TELECINE = unchecked((int)0xC00D1BA4); + public const int E_ACTIVE_SG_DEVICE_DISCONNECTED = unchecked((int)0xC00D1BA5); + public const int E_ACTIVE_SG_DEVICE_CONTROL_DISCONNECTED = unchecked((int)0xC00D1BA6); + public const int E_NO_FRAMES_SUBMITTED_TO_ANALYZER = unchecked((int)0xC00D1BA7); + public const int E_INPUT_DOESNOT_SUPPORT_SMPTE = unchecked((int)0xC00D1BA8); + public const int E_NO_SMPTE_WITH_MULTIPLE_SOURCEGROUPS = unchecked((int)0xC00D1BA9); + public const int E_BAD_CONTENTEDL = unchecked((int)0xC00D1BAA); + public const int E_INTERLACEMODE_MISMATCH = unchecked((int)0xC00D1BAB); + public const int E_NONSQUAREPIXELMODE_MISMATCH = unchecked((int)0xC00D1BAC); + public const int E_SMPTEMODE_MISMATCH = unchecked((int)0xC00D1BAD); + public const int E_END_OF_TAPE = unchecked((int)0xC00D1BAE); + public const int E_NO_MEDIA_IN_AUDIENCE = unchecked((int)0xC00D1BAF); + public const int E_NO_AUDIENCES = unchecked((int)0xC00D1BB0); + public const int E_NO_AUDIO_COMPAT = unchecked((int)0xC00D1BB1); + public const int E_INVALID_VBR_COMPAT = unchecked((int)0xC00D1BB2); + public const int E_NO_PROFILE_NAME = unchecked((int)0xC00D1BB3); + public const int E_INVALID_VBR_WITH_UNCOMP = unchecked((int)0xC00D1BB4); + public const int E_MULTIPLE_VBR_AUDIENCES = unchecked((int)0xC00D1BB5); + public const int E_UNCOMP_COMP_COMBINATION = unchecked((int)0xC00D1BB6); + public const int E_MULTIPLE_AUDIO_CODECS = unchecked((int)0xC00D1BB7); + public const int E_MULTIPLE_AUDIO_FORMATS = unchecked((int)0xC00D1BB8); + public const int E_AUDIO_BITRATE_STEPDOWN = unchecked((int)0xC00D1BB9); + public const int E_INVALID_AUDIO_PEAKRATE = unchecked((int)0xC00D1BBA); + public const int E_INVALID_AUDIO_PEAKRATE_2 = unchecked((int)0xC00D1BBB); + public const int E_INVALID_AUDIO_BUFFERMAX = unchecked((int)0xC00D1BBC); + public const int E_MULTIPLE_VIDEO_CODECS = unchecked((int)0xC00D1BBD); + public const int E_MULTIPLE_VIDEO_SIZES = unchecked((int)0xC00D1BBE); + public const int E_INVALID_VIDEO_BITRATE = unchecked((int)0xC00D1BBF); + public const int E_VIDEO_BITRATE_STEPDOWN = unchecked((int)0xC00D1BC0); + public const int E_INVALID_VIDEO_PEAKRATE = unchecked((int)0xC00D1BC1); + public const int E_INVALID_VIDEO_PEAKRATE_2 = unchecked((int)0xC00D1BC2); + public const int E_INVALID_VIDEO_WIDTH = unchecked((int)0xC00D1BC3); + public const int E_INVALID_VIDEO_HEIGHT = unchecked((int)0xC00D1BC4); + public const int E_INVALID_VIDEO_FPS = unchecked((int)0xC00D1BC5); + public const int E_INVALID_VIDEO_KEYFRAME = unchecked((int)0xC00D1BC6); + public const int E_INVALID_VIDEO_IQUALITY = unchecked((int)0xC00D1BC7); + public const int E_INVALID_VIDEO_CQUALITY = unchecked((int)0xC00D1BC8); + public const int E_INVALID_VIDEO_BUFFER = unchecked((int)0xC00D1BC9); + public const int E_INVALID_VIDEO_BUFFERMAX = unchecked((int)0xC00D1BCA); + public const int E_INVALID_VIDEO_BUFFERMAX_2 = unchecked((int)0xC00D1BCB); + public const int E_INVALID_VIDEO_WIDTH_ALIGN = unchecked((int)0xC00D1BCC); + public const int E_INVALID_VIDEO_HEIGHT_ALIGN = unchecked((int)0xC00D1BCD); + public const int E_MULTIPLE_SCRIPT_BITRATES = unchecked((int)0xC00D1BCE); + public const int E_INVALID_SCRIPT_BITRATE = unchecked((int)0xC00D1BCF); + public const int E_MULTIPLE_FILE_BITRATES = unchecked((int)0xC00D1BD0); + public const int E_INVALID_FILE_BITRATE = unchecked((int)0xC00D1BD1); + public const int E_SAME_AS_INPUT_COMBINATION = unchecked((int)0xC00D1BD2); + public const int E_SOURCE_CANNOT_LOOP = unchecked((int)0xC00D1BD3); + public const int E_INVALID_FOLDDOWN_COEFFICIENTS = unchecked((int)0xC00D1BD4); + public const int E_DRMPROFILE_NOTFOUND = unchecked((int)0xC00D1BD5); + public const int E_INVALID_TIMECODE = unchecked((int)0xC00D1BD6); + public const int E_NO_AUDIO_TIMECOMPRESSION = unchecked((int)0xC00D1BD7); + public const int E_NO_TWOPASS_TIMECOMPRESSION = unchecked((int)0xC00D1BD8); + public const int E_TIMECODE_REQUIRES_VIDEOSTREAM = unchecked((int)0xC00D1BD9); + public const int E_NO_MBR_WITH_TIMECODE = unchecked((int)0xC00D1BDA); + public const int E_INVALID_INTERLACEMODE = unchecked((int)0xC00D1BDB); + public const int E_INVALID_INTERLACE_COMPAT = unchecked((int)0xC00D1BDC); + public const int E_INVALID_NONSQUAREPIXEL_COMPAT = unchecked((int)0xC00D1BDD); + public const int E_INVALID_SOURCE_WITH_DEVICE_CONTROL = unchecked((int)0xC00D1BDE); + public const int E_CANNOT_GENERATE_BROADCAST_INFO_FOR_QUALITYVBR = unchecked((int)0xC00D1BDF); + public const int E_EXCEED_MAX_DRM_PROFILE_LIMIT = unchecked((int)0xC00D1BE0); + public const int E_DEVICECONTROL_UNSTABLE = unchecked((int)0xC00D1BE1); + public const int E_INVALID_PIXEL_ASPECT_RATIO = unchecked((int)0xC00D1BE2); + public const int E_AUDIENCE__LANGUAGE_CONTENTTYPE_MISMATCH = unchecked((int)0xC00D1BE3); + public const int E_INVALID_PROFILE_CONTENTTYPE = unchecked((int)0xC00D1BE4); + public const int E_TRANSFORM_PLUGIN_NOT_FOUND = unchecked((int)0xC00D1BE5); + public const int E_TRANSFORM_PLUGIN_INVALID = unchecked((int)0xC00D1BE6); + public const int E_EDL_REQUIRED_FOR_DEVICE_MULTIPASS = unchecked((int)0xC00D1BE7); + public const int E_INVALID_VIDEO_WIDTH_FOR_INTERLACED_ENCODING = unchecked((int)0xC00D1BE8); + public const int E_DRM_INVALID_APPLICATION = unchecked((int)0xC00D2711); + public const int E_DRM_LICENSE_STORE_ERROR = unchecked((int)0xC00D2712); + public const int E_DRM_SECURE_STORE_ERROR = unchecked((int)0xC00D2713); + public const int E_DRM_LICENSE_STORE_SAVE_ERROR = unchecked((int)0xC00D2714); + public const int E_DRM_SECURE_STORE_UNLOCK_ERROR = unchecked((int)0xC00D2715); + public const int E_DRM_INVALID_CONTENT = unchecked((int)0xC00D2716); + public const int E_DRM_UNABLE_TO_OPEN_LICENSE = unchecked((int)0xC00D2717); + public const int E_DRM_INVALID_LICENSE = unchecked((int)0xC00D2718); + public const int E_DRM_INVALID_MACHINE = unchecked((int)0xC00D2719); + public const int E_DRM_ENUM_LICENSE_FAILED = unchecked((int)0xC00D271B); + public const int E_DRM_INVALID_LICENSE_REQUEST = unchecked((int)0xC00D271C); + public const int E_DRM_UNABLE_TO_INITIALIZE = unchecked((int)0xC00D271D); + public const int E_DRM_UNABLE_TO_ACQUIRE_LICENSE = unchecked((int)0xC00D271E); + public const int E_DRM_INVALID_LICENSE_ACQUIRED = unchecked((int)0xC00D271F); + public const int E_DRM_NO_RIGHTS = unchecked((int)0xC00D2720); + public const int E_DRM_KEY_ERROR = unchecked((int)0xC00D2721); + public const int E_DRM_ENCRYPT_ERROR = unchecked((int)0xC00D2722); + public const int E_DRM_DECRYPT_ERROR = unchecked((int)0xC00D2723); + public const int E_DRM_LICENSE_INVALID_XML = unchecked((int)0xC00D2725); + public const int S_DRM_LICENSE_ACQUIRED = unchecked((int)0x000D2726); + public const int S_DRM_INDIVIDUALIZED = unchecked((int)0x000D2727); + public const int E_DRM_NEEDS_INDIVIDUALIZATION = unchecked((int)0xC00D2728); + public const int E_DRM_ALREADY_INDIVIDUALIZED = unchecked((int)0xC00D2729); + public const int E_DRM_ACTION_NOT_QUERIED = unchecked((int)0xC00D272A); + public const int E_DRM_ACQUIRING_LICENSE = unchecked((int)0xC00D272B); + public const int E_DRM_INDIVIDUALIZING = unchecked((int)0xC00D272C); + public const int E_DRM_PARAMETERS_MISMATCHED = unchecked((int)0xC00D272F); + public const int E_DRM_UNABLE_TO_CREATE_LICENSE_OBJECT = unchecked((int)0xC00D2730); + public const int E_DRM_UNABLE_TO_CREATE_INDI_OBJECT = unchecked((int)0xC00D2731); + public const int E_DRM_UNABLE_TO_CREATE_ENCRYPT_OBJECT = unchecked((int)0xC00D2732); + public const int E_DRM_UNABLE_TO_CREATE_DECRYPT_OBJECT = unchecked((int)0xC00D2733); + public const int E_DRM_UNABLE_TO_CREATE_PROPERTIES_OBJECT = unchecked((int)0xC00D2734); + public const int E_DRM_UNABLE_TO_CREATE_BACKUP_OBJECT = unchecked((int)0xC00D2735); + public const int E_DRM_INDIVIDUALIZE_ERROR = unchecked((int)0xC00D2736); + public const int E_DRM_LICENSE_OPEN_ERROR = unchecked((int)0xC00D2737); + public const int E_DRM_LICENSE_CLOSE_ERROR = unchecked((int)0xC00D2738); + public const int E_DRM_GET_LICENSE_ERROR = unchecked((int)0xC00D2739); + public const int E_DRM_QUERY_ERROR = unchecked((int)0xC00D273A); + public const int E_DRM_REPORT_ERROR = unchecked((int)0xC00D273B); + public const int E_DRM_GET_LICENSESTRING_ERROR = unchecked((int)0xC00D273C); + public const int E_DRM_GET_CONTENTSTRING_ERROR = unchecked((int)0xC00D273D); + public const int E_DRM_MONITOR_ERROR = unchecked((int)0xC00D273E); + public const int E_DRM_UNABLE_TO_SET_PARAMETER = unchecked((int)0xC00D273F); + public const int E_DRM_INVALID_APPDATA = unchecked((int)0xC00D2740); + public const int E_DRM_INVALID_APPDATA_VERSION = unchecked((int)0xC00D2741); + public const int E_DRM_BACKUP_EXISTS = unchecked((int)0xC00D2742); + public const int E_DRM_BACKUP_CORRUPT = unchecked((int)0xC00D2743); + public const int E_DRM_BACKUPRESTORE_BUSY = unchecked((int)0xC00D2744); + public const int S_DRM_MONITOR_CANCELLED = unchecked((int)0x000D2746); + public const int S_DRM_ACQUIRE_CANCELLED = unchecked((int)0x000D2747); + public const int E_DRM_LICENSE_UNUSABLE = unchecked((int)0xC00D2748); + public const int E_DRM_INVALID_PROPERTY = unchecked((int)0xC00D2749); + public const int E_DRM_SECURE_STORE_NOT_FOUND = unchecked((int)0xC00D274A); + public const int E_DRM_CACHED_CONTENT_ERROR = unchecked((int)0xC00D274B); + public const int E_DRM_INDIVIDUALIZATION_INCOMPLETE = unchecked((int)0xC00D274C); + public const int E_DRM_DRIVER_AUTH_FAILURE = unchecked((int)0xC00D274D); + public const int E_DRM_NEED_UPGRADE_MSSAP = unchecked((int)0xC00D274E); + public const int E_DRM_REOPEN_CONTENT = unchecked((int)0xC00D274F); + public const int E_DRM_DRIVER_DIGIOUT_FAILURE = unchecked((int)0xC00D2750); + public const int E_DRM_INVALID_SECURESTORE_PASSWORD = unchecked((int)0xC00D2751); + public const int E_DRM_APPCERT_REVOKED = unchecked((int)0xC00D2752); + public const int E_DRM_RESTORE_FRAUD = unchecked((int)0xC00D2753); + public const int E_DRM_HARDWARE_INCONSISTENT = unchecked((int)0xC00D2754); + public const int E_DRM_SDMI_TRIGGER = unchecked((int)0xC00D2755); + public const int E_DRM_SDMI_NOMORECOPIES = unchecked((int)0xC00D2756); + public const int E_DRM_UNABLE_TO_CREATE_HEADER_OBJECT = unchecked((int)0xC00D2757); + public const int E_DRM_UNABLE_TO_CREATE_KEYS_OBJECT = unchecked((int)0xC00D2758); + public const int E_DRM_LICENSE_NOTACQUIRED = unchecked((int)0xC00D2759); + public const int E_DRM_UNABLE_TO_CREATE_CODING_OBJECT = unchecked((int)0xC00D275A); + public const int E_DRM_UNABLE_TO_CREATE_STATE_DATA_OBJECT = unchecked((int)0xC00D275B); + public const int E_DRM_BUFFER_TOO_SMALL = unchecked((int)0xC00D275C); + public const int E_DRM_UNSUPPORTED_PROPERTY = unchecked((int)0xC00D275D); + public const int E_DRM_ERROR_BAD_NET_RESP = unchecked((int)0xC00D275E); + public const int E_DRM_STORE_NOTALLSTORED = unchecked((int)0xC00D275F); + public const int E_DRM_SECURITY_COMPONENT_SIGNATURE_INVALID = unchecked((int)0xC00D2760); + public const int E_DRM_INVALID_DATA = unchecked((int)0xC00D2761); + public const int E_DRM_UNABLE_TO_CONTACT_SERVER = unchecked((int)0xC00D2762); + public const int E_DRM_UNABLE_TO_CREATE_AUTHENTICATION_OBJECT = unchecked((int)0xC00D2763); + public const int E_DRM_NOT_CONFIGURED = unchecked((int)0xC00D2764); + public const int E_DRM_DEVICE_ACTIVATION_CANCELED = unchecked((int)0xC00D2765); + public const int E_DRM_LICENSE_EXPIRED = unchecked((int)0xC00D27D8); + public const int E_DRM_LICENSE_NOTENABLED = unchecked((int)0xC00D27D9); + public const int E_DRM_LICENSE_APPSECLOW = unchecked((int)0xC00D27DA); + public const int E_DRM_STORE_NEEDINDI = unchecked((int)0xC00D27DB); + public const int E_DRM_STORE_NOTALLOWED = unchecked((int)0xC00D27DC); + public const int E_DRM_LICENSE_APP_NOTALLOWED = unchecked((int)0xC00D27DD); + public const int S_DRM_NEEDS_INDIVIDUALIZATION = unchecked((int)0x000D27DE); + public const int E_DRM_LICENSE_CERT_EXPIRED = unchecked((int)0xC00D27DF); + public const int E_DRM_LICENSE_SECLOW = unchecked((int)0xC00D27E0); + public const int E_DRM_LICENSE_CONTENT_REVOKED = unchecked((int)0xC00D27E1); + public const int E_DRM_LICENSE_NOSAP = unchecked((int)0xC00D280A); + public const int E_DRM_LICENSE_NOSVP = unchecked((int)0xC00D280B); + public const int E_DRM_LICENSE_NOWDM = unchecked((int)0xC00D280C); + public const int E_DRM_LICENSE_NOTRUSTEDCODEC = unchecked((int)0xC00D280D); + public const int E_DRM_NEEDS_UPGRADE_TEMPFILE = unchecked((int)0xC00D283D); + public const int E_DRM_NEED_UPGRADE_PD = unchecked((int)0xC00D283E); + public const int E_DRM_SIGNATURE_FAILURE = unchecked((int)0xC00D283F); + public const int E_DRM_LICENSE_SERVER_INFO_MISSING = unchecked((int)0xC00D2840); + public const int E_DRM_BUSY = unchecked((int)0xC00D2841); + public const int E_DRM_PD_TOO_MANY_DEVICES = unchecked((int)0xC00D2842); + public const int E_DRM_INDIV_FRAUD = unchecked((int)0xC00D2843); + public const int E_DRM_INDIV_NO_CABS = unchecked((int)0xC00D2844); + public const int E_DRM_INDIV_SERVICE_UNAVAILABLE = unchecked((int)0xC00D2845); + public const int E_DRM_RESTORE_SERVICE_UNAVAILABLE = unchecked((int)0xC00D2846); + public const int S_REBOOT_RECOMMENDED = unchecked((int)0x000D2AF8); + public const int S_REBOOT_REQUIRED = unchecked((int)0x000D2AF9); + public const int E_REBOOT_RECOMMENDED = unchecked((int)0xC00D2AFA); + public const int E_REBOOT_REQUIRED = unchecked((int)0xC00D2AFB); + public const int E_UNKNOWN_PROTOCOL = unchecked((int)0xC00D2EE0); + public const int E_REDIRECT_TO_PROXY = unchecked((int)0xC00D2EE1); + public const int E_INTERNAL_SERVER_ERROR = unchecked((int)0xC00D2EE2); + public const int E_BAD_REQUEST = unchecked((int)0xC00D2EE3); + public const int E_ERROR_FROM_PROXY = unchecked((int)0xC00D2EE4); + public const int E_PROXY_TIMEOUT = unchecked((int)0xC00D2EE5); + public const int E_SERVER_UNAVAILABLE = unchecked((int)0xC00D2EE6); + public const int E_REFUSED_BY_SERVER = unchecked((int)0xC00D2EE7); + public const int E_INCOMPATIBLE_SERVER = unchecked((int)0xC00D2EE8); + public const int E_MULTICAST_DISABLED = unchecked((int)0xC00D2EE9); + public const int E_INVALID_REDIRECT = unchecked((int)0xC00D2EEA); + public const int E_ALL_PROTOCOLS_DISABLED = unchecked((int)0xC00D2EEB); + public const int E_MSBD_NO_LONGER_SUPPORTED = unchecked((int)0xC00D2EEC); + public const int E_PROXY_NOT_FOUND = unchecked((int)0xC00D2EED); + public const int E_CANNOT_CONNECT_TO_PROXY = unchecked((int)0xC00D2EEE); + public const int E_SERVER_DNS_TIMEOUT = unchecked((int)0xC00D2EEF); + public const int E_PROXY_DNS_TIMEOUT = unchecked((int)0xC00D2EF0); + public const int E_CLOSED_ON_SUSPEND = unchecked((int)0xC00D2EF1); + public const int E_CANNOT_READ_PLAYLIST_FROM_MEDIASERVER = unchecked((int)0xC00D2EF2); + public const int E_SESSION_NOT_FOUND = unchecked((int)0xC00D2EF3); + public const int E_REQUIRE_STREAMING_CLIENT = unchecked((int)0xC00D2EF4); + public const int E_PLAYLIST_ENTRY_HAS_CHANGED = unchecked((int)0xC00D2EF5); + public const int E_PROXY_ACCESSDENIED = unchecked((int)0xC00D2EF6); + public const int E_PROXY_SOURCE_ACCESSDENIED = unchecked((int)0xC00D2EF7); + public const int E_NETWORK_SINK_WRITE = unchecked((int)0xC00D2EF8); + public const int E_FIREWALL = unchecked((int)0xC00D2EF9); + public const int E_MMS_NOT_SUPPORTED = unchecked((int)0xC00D2EFA); + public const int E_SERVER_ACCESSDENIED = unchecked((int)0xC00D2EFB); + public const int E_RESOURCE_GONE = unchecked((int)0xC00D2EFC); + public const int E_NO_EXISTING_PACKETIZER = unchecked((int)0xC00D2EFD); + public const int E_BAD_SYNTAX_IN_SERVER_RESPONSE = unchecked((int)0xC00D2EFE); + public const int I_RECONNECTED = unchecked((int)0x400D2EFF); + public const int E_RESET_SOCKET_CONNECTION = unchecked((int)0xC00D2F00); + public const int I_NOLOG_STOP = unchecked((int)0x400D2F01); + public const int E_TOO_MANY_HOPS = unchecked((int)0xC00D2F02); + public const int I_EXISTING_PACKETIZER = unchecked((int)0x400D2F03); + public const int I_MANUAL_PROXY = unchecked((int)0x400D2F04); + public const int E_TOO_MUCH_DATA_FROM_SERVER = unchecked((int)0xC00D2F05); + public const int E_CONNECT_TIMEOUT = unchecked((int)0xC00D2F06); + public const int E_PROXY_CONNECT_TIMEOUT = unchecked((int)0xC00D2F07); + public const int E_SESSION_INVALID = unchecked((int)0xC00D2F08); + public const int S_EOSRECEDING = unchecked((int)0x000D2F09); + public const int E_PACKETSINK_UNKNOWN_FEC_STREAM = unchecked((int)0xC00D2F0A); + public const int E_PUSH_CANNOTCONNECT = unchecked((int)0xC00D2F0B); + public const int E_INCOMPATIBLE_PUSH_SERVER = unchecked((int)0xC00D2F0C); + public const int S_CHANGENOTICE = unchecked((int)0x000D2F0D); + public const int E_END_OF_PLAYLIST = unchecked((int)0xC00D32C8); + public const int E_USE_FILE_SOURCE = unchecked((int)0xC00D32C9); + public const int E_PROPERTY_NOT_FOUND = unchecked((int)0xC00D32CA); + public const int E_PROPERTY_READ_ONLY = unchecked((int)0xC00D32CC); + public const int E_TABLE_KEY_NOT_FOUND = unchecked((int)0xC00D32CD); + public const int E_INVALID_QUERY_OPERATOR = unchecked((int)0xC00D32CF); + public const int E_INVALID_QUERY_PROPERTY = unchecked((int)0xC00D32D0); + public const int E_PROPERTY_NOT_SUPPORTED = unchecked((int)0xC00D32D2); + public const int E_SCHEMA_CLASSIFY_FAILURE = unchecked((int)0xC00D32D4); + public const int E_METADATA_FORMAT_NOT_SUPPORTED = unchecked((int)0xC00D32D5); + public const int E_METADATA_NO_EDITING_CAPABILITY = unchecked((int)0xC00D32D6); + public const int E_METADATA_CANNOT_SET_LOCALE = unchecked((int)0xC00D32D7); + public const int E_METADATA_LANGUAGE_NOT_SUPORTED = unchecked((int)0xC00D32D8); + public const int E_METADATA_NO_RFC1766_NAME_FOR_LOCALE = unchecked((int)0xC00D32D9); + public const int E_METADATA_NOT_AVAILABLE = unchecked((int)0xC00D32DA); + public const int E_METADATA_CACHE_DATA_NOT_AVAILABLE = unchecked((int)0xC00D32DB); + public const int E_METADATA_INVALID_DOCUMENT_TYPE = unchecked((int)0xC00D32DC); + public const int E_METADATA_IDENTIFIER_NOT_AVAILABLE = unchecked((int)0xC00D32DD); + public const int E_METADATA_CANNOT_RETRIEVE_FROM_OFFLINE_CACHE = unchecked((int)0xC00D32DE); + + public const int I_NO_EVENTS = unchecked((int)0x400D0069); + public const int E_REGKEY_NOT_FOUND = unchecked((int)0xC00D006A); + } + + static public class WMError + { + #region Private methods + + /// + /// From #defines in WinBase.h + /// + [Flags] + private enum LoadLibraryExFlags + { + DontResolveDllReferences = 0x00000001, + LoadLibraryAsDataFile = 0x00000002, + LoadWithAlteredSearchPath = 0x00000008, + LoadIgnoreCodeAuthzLevel = 0x00000010 + } + + /// + /// From FORMAT_MESSAGE_* defines in WinBase.h + /// + [Flags] + private enum FormatMessageFlags + { + AllocateBuffer = 0x00000100, + IgnoreInserts = 0x00000200, + FromString = 0x00000400, + FromHmodule = 0x00000800, + FromSystem = 0x00001000, + ArgumentArray = 0x00002000, + MaxWidthMask = 0x000000FF + } + + [DllImport("kernel32.dll", ExactSpelling = true, CharSet = CharSet.Unicode, EntryPoint = "FormatMessageW"), SuppressUnmanagedCodeSecurity] + private static extern int FormatMessage(FormatMessageFlags dwFlags, IntPtr lpSource, + int dwMessageId, int dwLanguageId, ref IntPtr lpBuffer, int nSize, IntPtr Arguments); + + [DllImport("kernel32.dll", ExactSpelling = true, CharSet = CharSet.Unicode, EntryPoint = "LoadLibraryExW"), SuppressUnmanagedCodeSecurity] + private static extern IntPtr LoadLibraryEx(string lpFileName, IntPtr hFile, LoadLibraryExFlags dwFlags); + + [DllImport("kernel32.dll"), SuppressUnmanagedCodeSecurity] + [return: MarshalAs(UnmanagedType.Bool)] + private static extern bool FreeLibrary(IntPtr hFile); + + [DllImport("kernel32.dll", SetLastError = true), SuppressUnmanagedCodeSecurity] + private static extern IntPtr LocalFree(IntPtr hMem); + + #endregion + + public static string GetErrorText(int hr) + { + string sRet = null; + IntPtr hModule; + FormatMessageFlags dwFormatFlags = FormatMessageFlags.AllocateBuffer | FormatMessageFlags.IgnoreInserts | FormatMessageFlags.FromSystem; + int dwBufferLength; + IntPtr ip = IntPtr.Zero; + + // Load the Windows Media error message dll + hModule = LoadLibraryEx("wmerror.dll", IntPtr.Zero, LoadLibraryExFlags.LoadLibraryAsDataFile); + if (hModule != IntPtr.Zero) + { + // If the load succeeds, make sure we look in it + dwFormatFlags |= FormatMessageFlags.FromHmodule; + } + + // Scan both the Windows Media library, and the system library looking for the message + dwBufferLength = FormatMessage( + dwFormatFlags, + hModule, // module to get message from (NULL == system) + hr, // error number to get message for + 0, // default language + ref ip, + 0, + IntPtr.Zero + ); + + try + { + // Convert the returned buffer to a string. If ip is null (due to not finding + // the message), no exception is thrown. sRet just stays null. The + // try/finally is for the (remote) possibility that we run out of memory + // creating the string. + sRet = Marshal.PtrToStringUni(ip); + } + finally + { + // Cleanup + FreeLibrary(hModule); + LocalFree(ip); + } + + return sRet; + } + + /// + /// If hr has a "failed" status code (E_*), throw an exception. Note that status + /// messages (S_*) are not considered failure codes. If Windows Media error text + /// is available, it is used to build the exception, otherwise a generic com error + /// is thrown. + /// + /// The HRESULT to check + public static void ThrowExceptionForHR(int hr) + { + // If an error has occurred + if (hr < 0) + { + // If a string is returned, build a com error from it + string buf = GetErrorText(hr); + if (buf != null) + { + throw new COMException(buf, hr); + } + else + { + // No string, just use standard com error + Marshal.ThrowExceptionForHR(hr); + } + } + } + + } + + [AttributeUsage(AttributeTargets.Enum | AttributeTargets.Struct | AttributeTargets.Class)] + internal class UnmanagedNameAttribute : Attribute + { + private string m_Name; + + public UnmanagedNameAttribute(string s) + { + m_Name = s; + } + + public override string ToString() + { + return m_Name; + } + } + + static public class Constants + { + //////////////////////////////////////////////////////////////// + // + // These are the special case attributes that give information + // about the Windows Media file. + // + public const int g_dwWMSpecialAttributes = 20; + public const string g_wszWMDuration = "Duration"; + public const string g_wszWMBitrate = "Bitrate"; + public const string g_wszWMSeekable = "Seekable"; + public const string g_wszWMStridable = "Stridable"; + public const string g_wszWMBroadcast = "Broadcast"; + public const string g_wszWMProtected = "Is_Protected"; + public const string g_wszWMTrusted = "Is_Trusted"; + public const string g_wszWMSignature_Name = "Signature_Name"; + public const string g_wszWMHasAudio = "HasAudio"; + public const string g_wszWMHasImage = "HasImage"; + public const string g_wszWMHasScript = "HasScript"; + public const string g_wszWMHasVideo = "HasVideo"; + public const string g_wszWMCurrentBitrate = "CurrentBitrate"; + public const string g_wszWMOptimalBitrate = "OptimalBitrate"; + public const string g_wszWMHasAttachedImages = "HasAttachedImages"; + public const string g_wszWMSkipBackward = "Can_Skip_Backward"; + public const string g_wszWMSkipForward = "Can_Skip_Forward"; + public const string g_wszWMNumberOfFrames = "NumberOfFrames"; + public const string g_wszWMFileSize = "FileSize"; + public const string g_wszWMHasArbitraryDataStream = "HasArbitraryDataStream"; + public const string g_wszWMHasFileTransferStream = "HasFileTransferStream"; + public const string g_wszWMContainerFormat = "WM/ContainerFormat"; + + //////////////////////////////////////////////////////////////// + // + // The content description object supports 5 basic attributes. + // + public const int g_dwWMContentAttributes = 5; + public const string g_wszWMTitle = "Title"; + public const string g_wszWMAuthor = "Author"; + public const string g_wszWMDescription = "Description"; + public const string g_wszWMRating = "Rating"; + public const string g_wszWMCopyright = "Copyright"; + + //////////////////////////////////////////////////////////////// + // + // These attributes are used to configure and query DRM settings in the reader and writer. + // + public const string g_wszWMUse_DRM = "Use_DRM"; + public const string g_wszWMDRM_Flags = "DRM_Flags"; + public const string g_wszWMDRM_Level = "DRM_Level"; + public const string g_wszWMUse_Advanced_DRM = "Use_Advanced_DRM"; + public const string g_wszWMDRM_KeySeed = "DRM_KeySeed"; + public const string g_wszWMDRM_KeyID = "DRM_KeyID"; + public const string g_wszWMDRM_ContentID = "DRM_ContentID"; + public const string g_wszWMDRM_SourceID = "DRM_SourceID"; + public const string g_wszWMDRM_IndividualizedVersion = "DRM_IndividualizedVersion"; + public const string g_wszWMDRM_LicenseAcqURL = "DRM_LicenseAcqURL"; + public const string g_wszWMDRM_V1LicenseAcqURL = "DRM_V1LicenseAcqURL"; + public const string g_wszWMDRM_HeaderSignPrivKey = "DRM_HeaderSignPrivKey"; + public const string g_wszWMDRM_LASignaturePrivKey = "DRM_LASignaturePrivKey"; + public const string g_wszWMDRM_LASignatureCert = "DRM_LASignatureCert"; + public const string g_wszWMDRM_LASignatureLicSrvCert = "DRM_LASignatureLicSrvCert"; + public const string g_wszWMDRM_LASignatureRootCert = "DRM_LASignatureRootCert"; + + //////////////////////////////////////////////////////////////// + // + // These are the additional attributes defined in the WM attribute + // namespace that give information about the content. + // + public const string g_wszWMAlbumTitle = "WM/AlbumTitle"; + public const string g_wszWMTrack = "WM/Track"; + public const string g_wszWMPromotionURL = "WM/PromotionURL"; + public const string g_wszWMAlbumCoverURL = "WM/AlbumCoverURL"; + public const string g_wszWMGenre = "WM/Genre"; + public const string g_wszWMYear = "WM/Year"; + public const string g_wszWMGenreID = "WM/GenreID"; + public const string g_wszWMMCDI = "WM/MCDI"; + public const string g_wszWMComposer = "WM/Composer"; + public const string g_wszWMLyrics = "WM/Lyrics"; + public const string g_wszWMTrackNumber = "WM/TrackNumber"; + public const string g_wszWMToolName = "WM/ToolName"; + public const string g_wszWMToolVersion = "WM/ToolVersion"; + public const string g_wszWMIsVBR = "IsVBR"; + public const string g_wszWMAlbumArtist = "WM/AlbumArtist"; + + //////////////////////////////////////////////////////////////// + // + // These optional attributes may be used to give information + // about the branding of the content. + // + public const string g_wszWMBannerImageType = "BannerImageType"; + public const string g_wszWMBannerImageData = "BannerImageData"; + public const string g_wszWMBannerImageURL = "BannerImageURL"; + public const string g_wszWMCopyrightURL = "CopyrightURL"; + //////////////////////////////////////////////////////////////// + // + // Optional attributes, used to give information + // about video stream properties. + // + public const string g_wszWMAspectRatioX = "AspectRatioX"; + public const string g_wszWMAspectRatioY = "AspectRatioY"; + //////////////////////////////////////////////////////////////// + // + // Optional attributes, used to give information + // about the overall streaming properties of VBR files. + // This attribute takes the format: + // WORD wReserved (must be 0) + // WM_LEAKY_BUCKET_PAIR pair1 + // WM_LEAKY_BUCKET_PAIR pair2 + // ... + // + public const string g_wszASFLeakyBucketPairs = "ASFLeakyBucketPairs"; + //////////////////////////////////////////////////////////////// + // + // The NSC file supports the following attributes. + // + public const int g_dwWMNSCAttributes = 5; + public const string g_wszWMNSCName = "NSC_Name"; + public const string g_wszWMNSCAddress = "NSC_Address"; + public const string g_wszWMNSCPhone = "NSC_Phone"; + public const string g_wszWMNSCEmail = "NSC_Email"; + public const string g_wszWMNSCDescription = "NSC_Description"; + + //////////////////////////////////////////////////////////////// + // + // Attributes introduced in V9 + // + public const string g_wszWMWriter = "WM/Writer"; + public const string g_wszWMConductor = "WM/Conductor"; + public const string g_wszWMProducer = "WM/Producer"; + public const string g_wszWMDirector = "WM/Director"; + public const string g_wszWMContentGroupDescription = "WM/ContentGroupDescription"; + public const string g_wszWMSubTitle = "WM/SubTitle"; + public const string g_wszWMPartOfSet = "WM/PartOfSet"; + public const string g_wszWMProtectionType = "WM/ProtectionType"; + public const string g_wszWMVideoHeight = "WM/VideoHeight"; + public const string g_wszWMVideoWidth = "WM/VideoWidth"; + public const string g_wszWMVideoFrameRate = "WM/VideoFrameRate"; + public const string g_wszWMMediaClassPrimaryID = "WM/MediaClassPrimaryID"; + public const string g_wszWMMediaClassSecondaryID = "WM/MediaClassSecondaryID"; + public const string g_wszWMPeriod = "WM/Period"; + public const string g_wszWMCategory = "WM/Category"; + public const string g_wszWMPicture = "WM/Picture"; + public const string g_wszWMLyrics_Synchronised = "WM/Lyrics_Synchronised"; + public const string g_wszWMOriginalLyricist = "WM/OriginalLyricist"; + public const string g_wszWMOriginalArtist = "WM/OriginalArtist"; + public const string g_wszWMOriginalAlbumTitle = "WM/OriginalAlbumTitle"; + public const string g_wszWMOriginalReleaseYear = "WM/OriginalReleaseYear"; + public const string g_wszWMOriginalFilename = "WM/OriginalFilename"; + public const string g_wszWMPublisher = "WM/Publisher"; + public const string g_wszWMEncodedBy = "WM/EncodedBy"; + public const string g_wszWMEncodingSettings = "WM/EncodingSettings"; + public const string g_wszWMEncodingTime = "WM/EncodingTime"; + public const string g_wszWMAuthorURL = "WM/AuthorURL"; + public const string g_wszWMUserWebURL = "WM/UserWebURL"; + public const string g_wszWMAudioFileURL = "WM/AudioFileURL"; + public const string g_wszWMAudioSourceURL = "WM/AudioSourceURL"; + public const string g_wszWMLanguage = "WM/Language"; + public const string g_wszWMParentalRating = "WM/ParentalRating"; + public const string g_wszWMBeatsPerMinute = "WM/BeatsPerMinute"; + public const string g_wszWMInitialKey = "WM/InitialKey"; + public const string g_wszWMMood = "WM/Mood"; + public const string g_wszWMText = "WM/Text"; + public const string g_wszWMDVDID = "WM/DVDID"; + public const string g_wszWMWMContentID = "WM/WMContentID"; + public const string g_wszWMWMCollectionID = "WM/WMCollectionID"; + public const string g_wszWMWMCollectionGroupID = "WM/WMCollectionGroupID"; + public const string g_wszWMUniqueFileIdentifier = "WM/UniqueFileIdentifier"; + public const string g_wszWMModifiedBy = "WM/ModifiedBy"; + public const string g_wszWMRadioStationName = "WM/RadioStationName"; + public const string g_wszWMRadioStationOwner = "WM/RadioStationOwner"; + public const string g_wszWMPlaylistDelay = "WM/PlaylistDelay"; + public const string g_wszWMCodec = "WM/Codec"; + public const string g_wszWMDRM = "WM/DRM"; + public const string g_wszWMISRC = "WM/ISRC"; + public const string g_wszWMProvider = "WM/Provider"; + public const string g_wszWMProviderRating = "WM/ProviderRating"; + public const string g_wszWMProviderStyle = "WM/ProviderStyle"; + public const string g_wszWMContentDistributor = "WM/ContentDistributor"; + public const string g_wszWMSubscriptionContentID = "WM/SubscriptionContentID"; + public const string g_wszWMWMADRCPeakReference = "WM/WMADRCPeakReference"; + public const string g_wszWMWMADRCPeakTarget = "WM/WMADRCPeakTarget"; + public const string g_wszWMWMADRCAverageReference = "WM/WMADRCAverageReference"; + public const string g_wszWMWMADRCAverageTarget = "WM/WMADRCAverageTarget"; + //////////////////////////////////////////////////////////////// + // + // Attributes introduced in V10 + // + public const string g_wszWMStreamTypeInfo = "WM/StreamTypeInfo"; + public const string g_wszWMPeakBitrate = "WM/PeakBitrate"; + public const string g_wszWMASFPacketCount = "WM/ASFPacketCount"; + public const string g_wszWMASFSecurityObjectsSize = "WM/ASFSecurityObjectsSize"; + public const string g_wszWMSharedUserRating = "WM/SharedUserRating"; + public const string g_wszWMSubTitleDescription = "WM/SubTitleDescription"; + public const string g_wszWMMediaCredits = "WM/MediaCredits"; + public const string g_wszWMParentalRatingReason = "WM/ParentalRatingReason"; + public const string g_wszWMOriginalReleaseTime = "WM/OriginalReleaseTime"; + public const string g_wszWMMediaStationCallSign = "WM/MediaStationCallSign"; + public const string g_wszWMMediaStationName = "WM/MediaStationName"; + public const string g_wszWMMediaNetworkAffiliation = "WM/MediaNetworkAffiliation"; + public const string g_wszWMMediaOriginalChannel = "WM/MediaOriginalChannel"; + public const string g_wszWMMediaOriginalBroadcastDateTime = "WM/MediaOriginalBroadcastDateTime"; + public const string g_wszWMMediaIsStereo = "WM/MediaIsStereo"; + public const string g_wszWMVideoClosedCaptioning = "WM/VideoClosedCaptioning"; + public const string g_wszWMMediaIsRepeat = "WM/MediaIsRepeat"; + public const string g_wszWMMediaIsLive = "WM/MediaIsLive"; + public const string g_wszWMMediaIsTape = "WM/MediaIsTape"; + public const string g_wszWMMediaIsDelay = "WM/MediaIsDelay"; + public const string g_wszWMMediaIsSubtitled = "WM/MediaIsSubtitled"; + public const string g_wszWMMediaIsPremiere = "WM/MediaIsPremiere"; + public const string g_wszWMMediaIsFinale = "WM/MediaIsFinale"; + public const string g_wszWMMediaIsSAP = "WM/MediaIsSAP"; + public const string g_wszWMProviderCopyright = "WM/ProviderCopyright"; + //////////////////////////////////////////////////////////////// + // + // Attributes introduced in V11 + // + public const string g_wszWMISAN = "WM/ISAN"; + public const string g_wszWMADID = "WM/ADID"; + public const string g_wszWMWMShadowFileSourceFileType = "WM/WMShadowFileSourceFileType"; + public const string g_wszWMWMShadowFileSourceDRMType = "WM/WMShadowFileSourceDRMType"; + public const string g_wszWMWMCPDistributor = "WM/WMCPDistributor"; + public const string g_wszWMWMCPDistributorID = "WM/WMCPDistributorID"; + //////////////////////////////////////////////////////////////// + // + // These are setting names for use in Get/SetOutputSetting + // + public const string g_wszEarlyDataDelivery = "EarlyDataDelivery"; + public const string g_wszJustInTimeDecode = "JustInTimeDecode"; + public const string g_wszSingleOutputBuffer = "SingleOutputBuffer"; + public const string g_wszSoftwareScaling = "SoftwareScaling"; + public const string g_wszDeliverOnReceive = "DeliverOnReceive"; + public const string g_wszScrambledAudio = "ScrambledAudio"; + public const string g_wszDedicatedDeliveryThread = "DedicatedDeliveryThread"; + public const string g_wszEnableDiscreteOutput = "EnableDiscreteOutput"; + public const string g_wszSpeakerConfig = "SpeakerConfig"; + public const string g_wszDynamicRangeControl = "DynamicRangeControl"; + public const string g_wszAllowInterlacedOutput = "AllowInterlacedOutput"; + public const string g_wszVideoSampleDurations = "VideoSampleDurations"; + public const string g_wszStreamLanguage = "StreamLanguage"; + public const string g_wszEnableWMAProSPDIFOutput = "EnableWMAProSPDIFOutput"; + + //////////////////////////////////////////////////////////////// + // + // These are setting names for use in Get/SetInputSetting + // + public const string g_wszDeinterlaceMode = "DeinterlaceMode"; + public const string g_wszInitialPatternForInverseTelecine = "InitialPatternForInverseTelecine"; + public const string g_wszJPEGCompressionQuality = "JPEGCompressionQuality"; + public const string g_wszWatermarkCLSID = "WatermarkCLSID"; + public const string g_wszWatermarkConfig = "WatermarkConfig"; + public const string g_wszInterlacedCoding = "InterlacedCoding"; + public const string g_wszFixedFrameRate = "FixedFrameRate"; + + //////////////////////////////////////////////////////////////// + // + // All known IWMPropertyVault property names + // + // g_wszOriginalSourceFormatTag is obsolete and has been superceded by g_wszOriginalWaveFormat + public const string g_wszOriginalSourceFormatTag = "_SOURCEFORMATTAG"; + public const string g_wszOriginalWaveFormat = "_ORIGINALWAVEFORMAT"; + public const string g_wszEDL = "_EDL"; + public const string g_wszComplexity = "_COMPLEXITYEX"; + public const string g_wszDecoderComplexityRequested = "_DECODERCOMPLEXITYPROFILE"; + + //////////////////////////////////////////////////////////////// + // + // All known IWMIStreamProps property names + // + public const string g_wszReloadIndexOnSeek = "ReloadIndexOnSeek"; + public const string g_wszStreamNumIndexObjects = "StreamNumIndexObjects"; + public const string g_wszFailSeekOnError = "FailSeekOnError"; + public const string g_wszPermitSeeksBeyondEndOfStream = "PermitSeeksBeyondEndOfStream"; + public const string g_wszUsePacketAtSeekPoint = "UsePacketAtSeekPoint"; + public const string g_wszSourceBufferTime = "SourceBufferTime"; + public const string g_wszSourceMaxBytesAtOnce = "SourceMaxBytesAtOnce"; + + //////////////////////////////////////////////////////////////// + // + // VBR encoding settings + // + public const string g_wszVBREnabled = "_VBRENABLED"; + public const string g_wszVBRQuality = "_VBRQUALITY"; + public const string g_wszVBRBitrateMax = "_RMAX"; + public const string g_wszVBRBufferWindowMax = "_BMAX"; + + //////////////////////////////////////////////////////////////// + // + // VBR Video settings + // + public const string g_wszVBRPeak = "VBR Peak"; + public const string g_wszBufferAverage = "Buffer Average"; + + //////////////////////////////////////////////////////////////// + // + // Codec encoding complexity settings + // + // g_wszComplexity should be used to set desired encoding complexity on the + // stream's IWMPropertyVault (see above for definition) + // The below settings can be queried from IWMCodecInfo3::GetCodecProp() + // + public const string g_wszComplexityMax = "_COMPLEXITYEXMAX"; + public const string g_wszComplexityOffline = "_COMPLEXITYEXOFFLINE"; + public const string g_wszComplexityLive = "_COMPLEXITYEXLIVE"; + public const string g_wszIsVBRSupported = "_ISVBRSUPPORTED"; + //////////////////////////////////////////////////////////////// + // + // Codec enumeration settings + // + // g_wszVBREnabled can be used as a codec enumeration setting (see above for definition) + public const string g_wszNumPasses = "_PASSESUSED"; + + //////////////////////////////////////////////////////////////// + // + // These are WMA Voice V9 attribute names and values + // + public const string g_wszMusicSpeechClassMode = "MusicSpeechClassMode"; + public const string g_wszMusicClassMode = "MusicClassMode"; + public const string g_wszSpeechClassMode = "SpeechClassMode"; + public const string g_wszMixedClassMode = "MixedClassMode"; + + //////////////////////////////////////////////////////////////// + // + // The WMA Voice V9 supports the following format property. + // + public const string g_wszSpeechCaps = "SpeechFormatCap"; + + //////////////////////////////////////////////////////////////// + // + // Multi-channel WMA properties + // + public const string g_wszPeakValue = "PeakValue"; + public const string g_wszAverageLevel = "AverageLevel"; + public const string g_wszFold6To2Channels3 = "Fold6To2Channels3"; + public const string g_wszFoldToChannelsTemplate = "Fold%luTo%luChannels%lu"; + + //////////////////////////////////////////////////////////////// + // + // Complexity profile description strings + // + public const string g_wszDeviceConformanceTemplate = "DeviceConformanceTemplate"; + + //////////////////////////////////////////////////////////////// + // + // Frame interpolation on video decode + // + public const string g_wszEnableFrameInterpolation = "EnableFrameInterpolation"; + + //////////////////////////////////////////////////////////////// + // + // Needs previous sample for Delta frame on video decode + // + public const string g_wszNeedsPreviousSample = "NeedsPreviousSample"; + + public const string g_wszWMDRM_ACTIONLIST_TAG = "ACTIONLIST"; + public const string g_wszWMDRM_ACTION_TAG = "ACTION"; + public const string g_wszWMDRM_RIGHT_PLAYBACK = "Play"; + public const string g_wszWMDRM_RIGHT_COPY = "Copy"; + public const string g_wszWMDRM_RIGHT_PLAYLIST_BURN = "PlaylistBurn"; + public const string g_wszWMDRM_RIGHT_CREATE_THUMBNAIL_IMAGE = "CreateThumbnailImage"; + public const string g_wszWMDRM_RIGHT_COPY_TO_CD = "Print.redbook"; + public const string g_wszWMDRM_RIGHT_COPY_TO_SDMI_DEVICE = "Transfer.SDMI"; + public const string g_wszWMDRM_RIGHT_COPY_TO_NON_SDMI_DEVICE = "Transfer.NONSDMI"; + public const string g_wszWMDRM_RIGHT_BACKUP = "Backup"; + public const string g_wszWMDRM_RIGHT_COLLABORATIVE_PLAY = "CollaborativePlay"; + public const string g_wszWMDRM_ActionAllowed = "ActionAllowed."; + public const string g_wszWMDRM_ActionAllowed_Playback = "ActionAllowed.Play"; + public const string g_wszWMDRM_ActionAllowed_Copy = "ActionAllowed.Copy"; + public const string g_wszWMDRM_ActionAllowed_PlaylistBurn = "ActionAllowed.PlaylistBurn"; + public const string g_wszWMDRM_ActionAllowed_CreateThumbnailImage = "ActionAllowed.CreateThumbnailImage"; + public const string g_wszWMDRM_ActionAllowed_CopyToCD = "ActionAllowed.Print.redbook"; + public const string g_wszWMDRM_ActionAllowed_CopyToSDMIDevice = "ActionAllowed.Transfer.SDMI"; + public const string g_wszWMDRM_ActionAllowed_CopyToNonSDMIDevice = "ActionAllowed.Transfer.NONSDMI"; + public const string g_wszWMDRM_ActionAllowed_Backup = "ActionAllowed.Backup"; + public const string g_wszWMDRM_ActionAllowed_CollaborativePlay = "ActionAllowed.CollaborativePlay"; + public const string g_wszWMDRM_LicenseState = "LicenseStateData."; + public const string g_wszWMDRM_LicenseState_Playback = "LicenseStateData.Play"; + public const string g_wszWMDRM_LicenseState_Copy = "LicenseStateData.Copy"; + public const string g_wszWMDRM_LicenseState_PlaylistBurn = "LicenseStateData.PlaylistBurn"; + public const string g_wszWMDRM_LicenseState_CreateThumbnailImage = "LicenseStateData.CreateThumbnailImage"; + public const string g_wszWMDRM_LicenseState_CopyToCD = "LicenseStateData.Print.redbook"; + public const string g_wszWMDRM_LicenseState_CopyToSDMIDevice = "LicenseStateData.Transfer.SDMI"; + public const string g_wszWMDRM_LicenseState_CopyToNonSDMIDevice = "LicenseStateData.Transfer.NONSDMI"; + public const string g_wszWMDRM_LicenseState_Backup = "LicenseStateData.Backup"; + public const string g_wszWMDRM_LicenseState_CollaborativePlay = "LicenseStateData.CollaborativePlay"; + public const string g_wszWMDRMNET_Revocation = "WMDRMNET_REVOCATION"; + public const string g_wszWMDRM_SAPLEVEL = "SAPLEVEL"; + public const string g_wszWMDRM_SAPRequired = "SAPRequired"; + public const string g_wszWMDRM_PRIORITY = "PRIORITY"; + public const string g_wszWMDRM_ISSUEDATE = "ISSUEDATE"; + public const string g_wszWMDRM_UplinkID = "UplinkID"; + public const string g_wszWMDRM_REVINFOVERSION = "REVINFOVERSION"; + + public const string g_wszWMDRM_IsDRM = "IsDRM"; + public const string g_wszWMDRM_IsDRMCached = "IsDRMCached"; + public const string g_wszWMDRM_BaseLicenseAcqURL = "BaseLAURL"; + public const string g_wszWMDRM_Rights = "Rights"; + public const string g_wszWMDRM_LicenseID = "LID"; + public const string g_wszWMDRM_DRMHeader = "DRMHeader."; + public const string g_wszWMDRM_DRMHeader_KeyID = "DRMHeader.KID"; + public const string g_wszWMDRM_DRMHeader_LicenseAcqURL = "DRMHeader.LAINFO"; + public const string g_wszWMDRM_DRMHeader_ContentID = "DRMHeader.CID"; + public const string g_wszWMDRM_DRMHeader_IndividualizedVersion = "DRMHeader.SECURITYVERSION"; + public const string g_wszWMDRM_DRMHeader_ContentDistributor = "DRMHeader.ContentDistributor"; + public const string g_wszWMDRM_DRMHeader_SubscriptionContentID = "DRMHeader.SubscriptionContentID"; + } + + [StructLayout(LayoutKind.Sequential)] + public class WmShort + { + private short m_value; + + public WmShort() + { + m_value = 0; + } + + public WmShort(short v) + { + m_value = v; + } + + public override string ToString() + { + return m_value.ToString(); + } + + public override int GetHashCode() + { + return m_value.GetHashCode(); + } + + public static implicit operator short(WmShort l) + { + return l.m_value; + } + + public static implicit operator WmShort(short l) + { + return new WmShort(l); + } + + public short ToInt16() + { + return m_value; + } + + public void Assign(short f) + { + m_value = f; + } + + public static WmShort FromInt16(short l) + { + return new WmShort(l); + } + } + + [StructLayout(LayoutKind.Sequential)] + public class WmInt + { + private int m_value; + + public WmInt() + { + m_value = 0; + } + + public WmInt(int v) + { + m_value = v; + } + + public override string ToString() + { + return m_value.ToString(); + } + + public override int GetHashCode() + { + return m_value.GetHashCode(); + } + + public static implicit operator int(WmInt l) + { + return l.m_value; + } + + public static implicit operator WmInt(int l) + { + return new WmInt(l); + } + + public int ToInt32() + { + return m_value; + } + + public void Assign(int f) + { + m_value = f; + } + + public static WmInt FromInt32(int l) + { + return new WmInt(l); + } + } + + [StructLayout(LayoutKind.Sequential)] + public class FourCC + { + protected const string m_SubTypeExtension = "-0000-0010-8000-00aa00389b71"; + private int m_fourCC; + + public FourCC(string fcc) + { + if (fcc.Length != 4) + { + throw new ArgumentException(fcc + " is not a valid FourCC"); + } + + byte[] asc = Encoding.ASCII.GetBytes(fcc); + + LoadFromBytes(asc[0], asc[1], asc[2], asc[3]); + } + + public FourCC(char a, char b, char c, char d) + : this(new string(new char[] { a, b, c, d })) + { } + + public FourCC(int fcc) + { + m_fourCC = fcc; + } + + public FourCC(byte[] b) + { + if (b.Length != 4) + { + throw new Exception("Invalid byte array passed to FourCC"); + } + + LoadFromBytes(b[0], b[1], b[2], b[3]); + } + + public FourCC(byte a, byte b, byte c, byte d) + { + LoadFromBytes(a, b, c, d); + } + + public FourCC(Guid g) + { + if (!IsA4ccSubtype(g)) + { + throw new Exception("Not a FourCC Guid"); + } + + byte[] asc; + asc = g.ToByteArray(); + + LoadFromBytes(asc[0], asc[1], asc[2], asc[3]); + } + + public void LoadFromBytes(byte a, byte b, byte c, byte d) + { + m_fourCC = a; + m_fourCC |= b << 8; + m_fourCC |= c << 16; + m_fourCC |= d << 24; + } + + public int ToInt32() + { + return m_fourCC; + } + + public byte[] GetBytes() + { + byte[] b = new byte[4]; + + b[0] = (byte)(m_fourCC & 0xff); + b[1] = (byte)((m_fourCC >> 8) & 0xff); + b[2] = (byte)((m_fourCC >> 16) & 0xff); + b[3] = (byte)((m_fourCC >> 24) & 0xff); + + return b; + } + + public static explicit operator int(FourCC f) + { + return f.ToInt32(); + } + + public Guid ToMediaSubtype() + { + return new Guid(m_fourCC.ToString("X") + m_SubTypeExtension); + } + + public static bool operator ==(FourCC fcc1, FourCC fcc2) + { + // If both are null, or both are same instance, return true. + if (Object.ReferenceEquals(fcc1, fcc2)) + { + return true; + } + + // If one is null, but not both, return false. + if (((object)fcc1 == null) || ((object)fcc2 == null)) + { + return false; + } + + return fcc1.m_fourCC == fcc2.m_fourCC; + } + + public static bool operator !=(FourCC fcc1, FourCC fcc2) + { + return !(fcc1 == fcc2); + } + + public override bool Equals(object obj) + { + if (!(obj is FourCC)) + return false; + + return (obj as FourCC).m_fourCC == m_fourCC; + } + + public override int GetHashCode() + { + return m_fourCC.GetHashCode(); + } + + public override string ToString() + { + char c; + char[] ca = new char[4]; + + c = Convert.ToChar(m_fourCC & 255); + if (!Char.IsLetterOrDigit(c)) + { + c = ' '; + } + ca[0] = c; + + c = Convert.ToChar((m_fourCC >> 8) & 255); + if (!Char.IsLetterOrDigit(c)) + { + c = ' '; + } + ca[1] = c; + + c = Convert.ToChar((m_fourCC >> 16) & 255); + if (!Char.IsLetterOrDigit(c)) + { + c = ' '; + } + ca[2] = c; + + c = Convert.ToChar((m_fourCC >> 24) & 255); + if (!Char.IsLetterOrDigit(c)) + { + c = ' '; + } + ca[3] = c; + + string s = new string(ca); + + return s; + } + + public static bool IsA4ccSubtype(Guid g) + { + return (g.ToString().Contains(m_SubTypeExtension)); + } + } + + #region Internal + + // These classes are used internally and there is probably no reason you will ever + // need to use them directly. + + internal class MTMarshaler : ICustomMarshaler + { + [DllImport("Kernel32.dll", EntryPoint = "RtlMoveMemory"), SuppressUnmanagedCodeSecurity] + private static extern void CopyMemory(IntPtr Destination, IntPtr Source, int Length); + + protected AMMediaType m_mt; + + public IntPtr MarshalManagedToNative(object managedObj) + { + m_mt = managedObj as AMMediaType; + + IntPtr ip = Marshal.AllocCoTaskMem(Marshal.SizeOf(m_mt) + m_mt.formatSize); + + // This class is only used for output. No need to burn the cpu cycles to copy + // over data that just gets overwritten. + + //Marshal.StructureToPtr(m_mt, ip, false); + + //if ((m_mt.formatSize > 0) && (m_mt.formatPtr != IntPtr.Zero)) + //{ + // CopyMemory(new IntPtr(ip.ToInt64() + Marshal.SizeOf(m_mt)), m_mt.formatPtr, m_mt.formatSize); + //} + + return ip; + } + + // Called just after invoking the COM method. The IntPtr is the same one that just got returned + // from MarshalManagedToNative. The return value is unused. + public object MarshalNativeToManaged(IntPtr pNativeData) + { + if (m_mt == null) + { + m_mt = new AMMediaType(); + } + Marshal.PtrToStructure(pNativeData, m_mt); + + if (m_mt.formatSize > 0) + { + IntPtr ip = m_mt.formatPtr; + + m_mt.formatPtr = Marshal.AllocCoTaskMem(m_mt.formatSize); + CopyMemory(m_mt.formatPtr, ip, m_mt.formatSize); + } + + return m_mt; + } + + // It appears this routine is never called + public void CleanUpManagedData(object ManagedObj) + { + m_mt = null; + } + + public void CleanUpNativeData(IntPtr pNativeData) + { + Marshal.FreeCoTaskMem(pNativeData); + } + + // The number of bytes to marshal out - never called + public int GetNativeDataSize() + { + return -1; + } + + // This method is called by interop to create the custom marshaler. The (optional) + // cookie is the value specified in MarshalCookie="asdf", or "" is none is specified. + public static ICustomMarshaler GetInstance(string cookie) + { + return new MTMarshaler(); + } + } + + + #endregion +} diff --git a/WindowsMediaLib/WindowsMediaLib.csproj b/WindowsMediaLib/WindowsMediaLib.csproj new file mode 100644 index 0000000..da59c8c --- /dev/null +++ b/WindowsMediaLib/WindowsMediaLib.csproj @@ -0,0 +1,144 @@ + + + + Local + 8.0.50727 + 2.0 + {7EA4160F-3BBD-47C9-A38C-4053B64B24A8} + Debug + AnyCPU + + + + + WindowsMediaLib + + + JScript + Grid + IE50 + false + Library + WindowsMediaLib + OnBuildSuccess + + + + + + + true + v2.0 + 2.0 + publish\ + true + Disk + false + Foreground + 7 + Days + false + false + true + 0 + 1.0.0.%2a + false + false + true + + + ..\bin\Debug\ + false + 285212672 + false + + + TRACE;DEBUG;ALLOW_UNTESTED_INTERFACES + + + true + 4096 + false + + + false + false + false + false + 4 + full + prompt + AllRules.ruleset + + + ..\bin\Release\ + false + 285212672 + false + + + TRACE + + + false + 4096 + false + + + true + false + false + false + 4 + none + prompt + AllRules.ruleset + + + + System + + + + + + Code + + + Code + + + Code + + + Code + + + Code + + + + + False + .NET Framework 3.5 SP1 Client Profile + false + + + False + .NET Framework 3.5 SP1 + true + + + False + Windows Installer 3.1 + true + + + + + + + + + + \ No newline at end of file diff --git a/WindowsMediaLib/WindowsMediaLib.csproj.user b/WindowsMediaLib/WindowsMediaLib.csproj.user new file mode 100644 index 0000000..e98b7a3 --- /dev/null +++ b/WindowsMediaLib/WindowsMediaLib.csproj.user @@ -0,0 +1,13 @@ + + + + + + + + + + en-US + false + + \ No newline at end of file